mediacutlet

sequence:
  - variables:
      tv_show_query: " { other_tv_show_title } "
  - if:
      - condition: or
        conditions:
          - condition: state
            entity_id: media_player.living_room
            state: "off"
          - condition: state

zxt-tzx

import type { AnyColumn, SQL, Table } from "drizzle-orm";
import { sql } from "drizzle-orm";
import type { PgColumn } from "drizzle-orm/pg-core";
import { type SelectedFields } from "drizzle-orm/pg-core";
import { type SelectResultFields } from "drizzle-orm/query-builders/select.types";

import { jsonBuildObject } from "./external-utils";
import type {
  ExtractColumnData,
  PathsToStringProperty,

zxt-tzx

import type { SQLWrapper } from "drizzle-orm";
import { sql } from "drizzle-orm";

import type { DbClient } from "@/db";

export const explainAnalyze = async <T extends SQLWrapper>(
  db: DbClient,
  query: T,
) => {
  const debugResult = await db.execute(sql`EXPLAIN ANALYZE ${query.getSQL()}`);

zxt-tzx

import type { SQL, Table } from "drizzle-orm";
import { getTableColumns, sql } from "drizzle-orm";

// from https://github.com/drizzle-team/drizzle-orm/issues/1728
export function conflictUpdateAllExcept<
  T extends Table,
  E extends (keyof T["$inferInsert"])[],
>(table: T, except: E) {
  const columns = getTableColumns(table);
  const updateColumns = Object.entries(columns).filter(

dvins

Overriding A Peer Dependency With PNPM

This guide explains how to override peer dependencies in a PNPM monorepo by using a custom hook. It provides a step-by-step solution to ensure consistent versioning across packages that rely on different versions of the same dependency.

Background

When working with a monorepo a challenges arises if you need to use multiple versions of the same package.

Nominally, this can be solved through package aliases and overides. However, a particularly sticky situation is when downstream packages rely peer dependencies of uptstream packages you need two or more versions of.

EdamAme-x

import { Hono } from 'hono';
import type { MergeSchemaPath, MergePath, Env, Schema } from 'hono/types';

export interface Module {
    path: string
    routes: Hono
}

export function mergeRoutes<T extends Module[], H extends Hono>(base: H, ...routes: T) {
    for (const route of routes) {

rphlmr

// Credits to Louistiti from Drizzle Discord: https://discord.com/channels/1043890932593987624/1130802621750448160/1143083373535973406

import { sql } from "drizzle-orm";

const clearDb = async (): Promise<void> => {
  const query = sql<string>`SELECT table_name
      FROM information_schema.tables
      WHERE table_schema = 'public'
        AND table_type = 'BASE TABLE';
    `;

PabloSzx

// Using:
// [email protected]
// [email protected]

import globby from 'globby';
import { dirname } from 'path';
import { fileURLToPath } from 'url';
import chalk from 'chalk';

async function main() {

Alia5

export type Await<T> = T extends PromiseLike<infer U> ? Await<U> : T;
export type IsPromise<T> = PromiseLike<infer U> ? true : false;

export type Length<T> = T extends { length: infer L } ? L : never;

export type KeysOfType<O, T> = {
    [K in keyof O]: O[K] extends T ? K : never;
}[keyof O];

// ConvertLiterals would convert literal types like `1337` to their base type like `number` if set to true 

dcolthorp

/** Used by Flavor to mark a type in a readable way. */
export interface Flavoring<FlavorT> {
  _type?: FlavorT;
}
/** Create a "flavored" version of a type. TypeScript will disallow mixing flavors, but will allow unflavored values of that type to be passed in where a flavored version is expected. This is a less restrictive form of branding. */
export type Flavor<T, FlavorT> = T & Flavoring<FlavorT>;

/** Used by Brand to mark a type in a readable way. */
export interface Branding<BrandT> {
  _type: BrandT;