@vrplatform/kysely 1.3.20 → 1.3.28

package/src/index.ts

@@ -1,145 +0,0 @@
-import type { Kysely as K, LogConfig } from 'kysely';
-import { PostgresJSDialect } from 'kysely-postgres-js';
-import postgres, { type Sql } from 'postgres';
-import { getKysely } from './plugins';
-
-export type { LogEvent } from 'kysely';
-export * from './error';
-export * from './isomorphic';
-export * from './query';
-
-import type { DB } from './v1.generated';
-
-type KyselyOpts = {
-  repositoryName?: string;
-  log?: true | LogConfig;
-};
-
-type PgOpt = {
-  forceDisableSSL?: boolean;
-  retries?: false | number;
-};
-
-export type Kysely = K<DB>;
-export type Postgres = Sql;
-/**
- * @deprecated This method is deprecated in favor of the useAsyncKysely method.
- */
-export function useKysely(postgres: Sql, options?: KyselyOpts) {
-  console.debug('Creating Kysely instance');
-  const kysely = getKysely(
-    new PostgresJSDialect({
-      postgres,
-    }),
-    {
-      repositoryName: options?.repositoryName,
-      log: options?.log,
-    }
-  );
-  kysely.destroy = async () => {
-    console.debug('Closing Kysely connection');
-    await Promise.race([
-      postgres.end({ timeout: 5000 }).catch(() => undefined),
-      new Promise((res) => setTimeout(res, 6000)),
-    ]);
-    const index = _connections.indexOf(postgres);
-    if (index !== -1) _connections.splice(index, 1);
-  };
-
-  return kysely;
-}
-
-let _connections: postgres.Sql[] = [];
-export async function useAsyncPostgres(connectionString: string, opt?: PgOpt) {
-  const delayMs = 2500;
-  const retries = opt?.retries === false ? 0 : opt?.retries || 3;
-  const ssl = opt?.forceDisableSSL !== true;
-  const url = new URL(connectionString);
-
-  console.debug(
-    `Creating Postgres connection with ${retries} retries and ssl=${ssl} and port=${url.port}`
-  );
-  if (_connections.length > 0)
-    console.warn(`We already have ${_connections.length} Postgres connections`);
-
-  for (let attempt = 1; attempt <= retries; attempt++) {
-    try {
-      const sql = postgres(connectionString, {
-        ssl: ssl ? 'require' : false,
-        // connect_timeout: 10
-        // idle_timeout: 10
-        // enable prepare statements, pgbouncer on crunchy allows for prepared statements
-        prepare: true,
-        connect_timeout: 10,
-        idle_timeout: 60,
-      });
-
-      await sql`select 1`;
-      try {
-        // connect 30s, idle 60s, max lifetime 45min, statement 60s, lock 10s, log_min_duration 20s, log_lock_waits off
-        await sql`set statement_timeout to '30s';`;
-        await sql`set lock_timeout to '10s';`;
-      } catch (e) {
-        console.warn('Failed to set statement timeout, continuing', e);
-      }
-
-      _connections.push(sql);
-      return sql;
-    } catch (err) {
-      if (attempt === retries) throw err;
-      console.warn(
-        `Postgres connection failed (attempt ${attempt}), retrying...`
-      );
-      console.error('error', err);
-      await new Promise((res) => setTimeout(res, delayMs));
-    }
-  }
-  throw new Error('Unable to connect to Postgres');
-}
-
-export async function useAsyncKysely(
-  connectionString: string,
-  opt?: PgOpt & KyselyOpts
-) {
-  const sql = await useAsyncPostgres(connectionString, opt);
-  return useKysely(sql, opt);
-}
-
-/**
- * @deprecated This method is deprecated in favor of the useAsyncKysely method.
- */
-export function usePostgres(
-  connectionString?: string,
-  opt?: Pick<PgOpt, 'forceDisableSSL'>
-) {
-  if (!connectionString) throw new Error('No connection string');
-  const ssl = opt?.forceDisableSSL !== true;
-  const url = new URL(connectionString);
-  console.debug(
-    `Creating sync Postgres connection with ssl=${ssl} and port=${url.port}`
-  );
-  const pg = postgres(connectionString, {
-    ssl: ssl ? 'require' : false,
-  });
-  _connections.push(pg);
-  return pg;
-}
-
-export async function forceCloseAllPostgres(timeoutMs = 5000) {
-  await Promise.race([
-    Promise.all(
-      _connections.map((pg) =>
-        pg.end({ timeout: timeoutMs }).catch(() => undefined)
-      )
-    ),
-    new Promise((res) => setTimeout(res, timeoutMs + 1000)),
-  ]);
-  _connections = [];
-}
-
-export class DatabaseError extends Error {
-  constructor(message: string, cause: any) {
-    super(message);
-    this.cause = cause;
-  }
-}

package/src/isomorphic.ts

@@ -1,33 +0,0 @@
-import type { Kysely as K, Transaction as T } from 'kysely';
-
-export type {
-  ColumnType,
-  Expression,
-  ExpressionBuilder,
-  ExpressionOrFactory,
-  Generated,
-  Insertable,
-  JSONColumnType,
-  Nullable,
-  OperandExpression,
-  Selectable,
-  SelectQueryBuilder,
-  SqlBool,
-  Updateable,
-} from 'kysely';
-export { jsonArrayFrom } from 'kysely/helpers/postgres';
-export * from './v1.generated';
-
-import type { DB } from './v1.generated';
-
-export type Transaction = T<DB>;
-export { sql } from 'kysely';
-
-export type Kysely = K<DB>;
-
-export class DatabaseError extends Error {
-  constructor(message: string, cause: any) {
-    super(message);
-    this.cause = cause;
-  }
-}

package/src/local/digest.ts

@@ -1,44 +0,0 @@
-import { type Kysely, sql } from '../isomorphic';
-
-export async function ensureDigestFunction(kysely: Kysely) {
-  try {
-    await sql`select digest('', 'sha256')`.execute(kysely);
-  } catch {
-    await sql`
-      create or replace function digest(input text, algo text)
-      returns bytea
-      language sql
-      immutable
-      strict
-      as $$
-        select '\\x0000000000000000000000000000000000000000000000000000000000000000'::bytea;
-      $$;
-    `.execute(kysely);
-  }
-}
-
-export async function ensureGenRandomBytesFunction(kysely: Kysely) {
-  try {
-    await sql`select gen_random_bytes(1)`.execute(kysely);
-  } catch {
-    await sql`
-      create or replace function gen_random_bytes(p_len integer)
-      returns bytea
-      language sql
-      stable
-      strict
-      as $$
-        select substring(
-          decode(
-            repeat(
-              md5(random()::text || now()::text),
-              ((p_len + 15) / 16)
-            ),
-            'hex'
-          )
-          from 1 for p_len
-        );
-      $$;
-    `.execute(kysely);
-  }
-}

package/src/local/generate.ts

@@ -1,137 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { exists } from 'node:fs/promises';
-import * as path from 'node:path';
-import { join } from 'node:path';
-import { PGlite } from '@electric-sql/pglite';
-import { FileMigrationProvider, type Kysely, Migrator } from 'kysely';
-import codegen from 'kysely-codegen';
-import { KyselyPGlite } from 'kysely-pglite';
-import { getKysely } from '../plugins';
-import type { DB } from '../v1.generated';
-
-async function migrate(root: string, client: PGlite) {
-  console.log('migrating pglite ....');
-  const glob = new Bun.Glob('initial/*.sql');
-  for await (const migration of glob.scan(root)) {
-    const raw = await Bun.file(join(root, migration)).text();
-    // `pg_dump` (v17+) prepends `\restrict`/`\unrestrict` psql meta commands
-    // which PostgreSQL-compatible parsers (like PGlite) cannot execute.
-    const sanitized = raw.replace(/^\s*\\(?:un)?restrict.*$/gim, '');
-    await client.exec(sanitized);
-  }
-}
-
-async function migrateKysely(root: string, kysely: Kysely<DB>) {
-  console.log('init migrating kysely ....');
-  const migrator = new Migrator({
-    db: kysely,
-    migrationTableSchema: 'core',
-    migrationTableName: 'kysely_migration',
-    migrationLockTableName: 'kysely_migration_lock',
-    provider: new FileMigrationProvider({
-      fs,
-      path,
-      // This needs to be an absolute path.
-      migrationFolder: path.join(root, 'migrations'),
-    }),
-  });
-
-  console.log('migrating kysely ....');
-  const { error, results } = await migrator.migrateToLatest().catch(() => {
-    console.error('failed to migrate');
-    process.exit(1);
-  });
-
-  for (const it of results ?? []) {
-    if (it.status === 'Success') {
-      console.log(`migration "${it.migrationName}" was executed successfully`);
-    } else if (it.status === 'Error') {
-      console.error(`failed to execute migration "${it.migrationName}"`);
-    }
-  }
-
-  if (error) {
-    console.error('failed to migrate');
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-async function generateDump(root: string, dumpPath: string) {
-  const dataExists = await exists(dumpPath).catch(() => false);
-  if (!dataExists) {
-    console.log('Creating initial dump');
-    const main = new PGlite();
-    await migrate(root, main).catch(async (err) => {
-      console.error('failed to migrate initial dump');
-      await Bun.write(
-        '../logs/migrate-initial-dump.json',
-        JSON.stringify(err as any, null, 2)
-      );
-      process.exit(1);
-    });
-    const { dialect } = new KyselyPGlite(main);
-    const kysely = getKysely(dialect, {
-      repositoryName: 'localTesting',
-      log: undefined,
-    });
-    await migrateKysely(root, kysely).catch(() => {
-      console.error('failed to migrate kysely');
-      process.exit(1);
-    });
-    await codegen
-      .generate({
-        db: kysely,
-        outFile: path.join(root, 'src/v1.generated.ts'),
-        defaultSchemas: ['xxx'],
-        camelCase: true,
-        dialect: codegen.getDialect('postgres'),
-      })
-      .catch(() => {
-        console.error('failed to generate kysely');
-        process.exit(1);
-      });
-    const content = await main.dumpDataDir('none').catch(() => {
-      console.error('failed to dump data');
-      process.exit(1);
-    });
-    await Bun.write(dumpPath, content).catch(() => {
-      console.error('failed to write dump');
-      process.exit(1);
-    });
-    return content;
-  }
-  return Bun.file(dumpPath);
-}
-
-export async function createLocalKysely(root: string, dumpPath: string) {
-  let isDestroyed = false;
-  //const now = performance.now();
-
-  const dump = await generateDump(root, dumpPath);
-
-  const pglite = new PGlite({ loadDataDir: dump });
-  // warm up
-  await pglite.sql`SELECT 1`;
-  const { dialect } = new KyselyPGlite(pglite);
-  const kysely = getKysely(dialect, {
-    repositoryName: 'localTesting',
-    log: undefined,
-  });
-
-  const originalDestroy = kysely.destroy.bind(kysely);
-  kysely.destroy = async () => {
-    if (isDestroyed) return;
-    isDestroyed = true;
-    // const destroyTime = performance.now();
-    await originalDestroy().catch(() => undefined);
-    await pglite.close().catch(() => undefined);
-    //console.log(
-    //  `Database destroyed: ${Math.round(performance.now() - destroyTime)}ms`
-    //);
-  };
-
-  // console.log(`Database initialized: ${Math.round(performance.now() - now)}ms`);
-
-  return kysely;
-}

package/src/local/index.ts

@@ -1,48 +0,0 @@
-import { join } from 'node:path';
-import { PGlite } from '@electric-sql/pglite';
-import type { LogConfig } from 'kysely';
-import { PGliteDialect } from 'kysely-pglite-dialect';
-import { getKysely } from '../plugins';
-import { ensureDigestFunction, ensureGenRandomBytesFunction } from './digest';
-
-export const root = join(__dirname, '../..');
-export const dumpPath = join(root, '.data.tar');
-
-export type UseLocalKyselyOptions = {
-  repositoryName?: string;
-  log?: true | LogConfig;
-};
-export async function useLocalKysely(args: UseLocalKyselyOptions = {}) {
-  let isDestroyed = false;
-  // const now = performance.now();
-
-  const dump = Bun.file(dumpPath);
-
-  const pglite = new PGlite({
-    loadDataDir: dump,
-  });
-  // warm up
-  const dialect = new PGliteDialect(pglite);
-  const kysely = getKysely(dialect, {
-    repositoryName: args?.repositoryName ?? 'localTesting',
-    log: args?.log,
-  });
-  await ensureDigestFunction(kysely);
-  await ensureGenRandomBytesFunction(kysely);
-
-  const originalDestroy = kysely.destroy.bind(kysely);
-  kysely.destroy = async () => {
-    if (isDestroyed) return;
-    isDestroyed = true;
-    //const destroyTime = performance.now();
-    await originalDestroy().catch(() => undefined);
-    await pglite.close().catch(() => undefined);
-    //console.log(
-    //  `Database destroyed: ${Math.round(performance.now() - destroyTime)}ms`
-    //);
-  };
-
-  // console.log(`Database initialized: ${Math.round(performance.now() - now)}ms`);
-
-  return kysely;
-}

package/src/pganalyze-comment-plugin/comment-transformer.ts

@@ -1,117 +0,0 @@
-import {
-  type DeleteQueryNode,
-  type InsertQueryNode,
-  OperationNodeTransformer,
-  type RootOperationNode,
-  SelectModifierNode,
-  type SelectQueryNode,
-  sql,
-  type UpdateQueryNode,
-} from 'kysely';
-
-function createCommentNode(repositoryName: string): SelectModifierNode {
-  return SelectModifierNode.createWithExpression(
-    sql.raw(`/* repository: ${repositoryName} */`).toOperationNode()
-  );
-}
-/**
- * Transformer that adds a SQL comment to queries for pganalyze tracking.
- * The comment format is: repository: REPOSITORY_NAME
- *
- * This works by appending the comment to queries using the endModifiers property,
- * similar to how modifyEnd works.
- */
-export class CommentTransformer extends OperationNodeTransformer {
-  constructor(readonly _repositoryName: string) {
-    super();
-  }
-
-  transformRootNode(node: RootOperationNode): RootOperationNode {
-    if (node.kind === 'SelectQueryNode') {
-      return this.transformSelectQuery(node);
-    }
-    if (node.kind === 'InsertQueryNode') {
-      return this.transformInsertQuery(node);
-    }
-    if (node.kind === 'UpdateQueryNode') {
-      return this.transformUpdateQuery(node);
-    }
-    if (node.kind === 'DeleteQueryNode') {
-      return this.transformDeleteQuery(node);
-    }
-    return node;
-  }
-
-  protected override transformSelectQuery(
-    node: SelectQueryNode
-  ): SelectQueryNode {
-    const transformed = super.transformSelectQuery(node);
-    return this.addCommentToSelectQuery(transformed);
-  }
-
-  protected override transformInsertQuery(
-    node: InsertQueryNode
-  ): InsertQueryNode {
-    const transformed = super.transformInsertQuery(node);
-    return this.addCommentToInsertQuery(transformed);
-  }
-
-  protected override transformUpdateQuery(
-    node: UpdateQueryNode
-  ): UpdateQueryNode {
-    const transformed = super.transformUpdateQuery(node);
-    return this.addCommentToUpdateQuery(transformed);
-  }
-
-  protected override transformDeleteQuery(
-    node: DeleteQueryNode
-  ): DeleteQueryNode {
-    const transformed = super.transformDeleteQuery(node);
-    return this.addCommentToDeleteQuery(transformed);
-  }
-
-  private addCommentToSelectQuery(node: SelectQueryNode): SelectQueryNode {
-    // Append comment using endModifiers property, similar to modifyEnd
-    const commentNode = createCommentNode(this._repositoryName);
-
-    return {
-      ...node,
-      endModifiers: node.endModifiers
-        ? [...node.endModifiers, commentNode]
-        : [commentNode],
-    };
-  }
-
-  private addCommentToInsertQuery(node: InsertQueryNode): InsertQueryNode {
-    const commentNode = createCommentNode(this._repositoryName);
-
-    return {
-      ...node,
-      endModifiers: node.endModifiers
-        ? [...node.endModifiers, commentNode]
-        : [commentNode],
-    };
-  }
-
-  private addCommentToUpdateQuery(node: UpdateQueryNode): UpdateQueryNode {
-    const commentNode = createCommentNode(this._repositoryName);
-
-    return {
-      ...node,
-      endModifiers: node.endModifiers
-        ? [...node.endModifiers, commentNode]
-        : [commentNode],
-    };
-  }
-
-  private addCommentToDeleteQuery(node: DeleteQueryNode): DeleteQueryNode {
-    const commentNode = createCommentNode(this._repositoryName);
-
-    return {
-      ...node,
-      endModifiers: node.endModifiers
-        ? [...node.endModifiers, commentNode]
-        : [commentNode],
-    };
-  }
-}

package/src/pganalyze-comment-plugin/index.ts

@@ -1,27 +0,0 @@
-import type {
-  KyselyPlugin,
-  PluginTransformQueryArgs,
-  PluginTransformResultArgs,
-  QueryResult,
-  RootOperationNode,
-  UnknownRow,
-} from 'kysely';
-import { CommentTransformer } from './comment-transformer';
-
-export class KyselyPganalyzeCommentPlugin implements KyselyPlugin {
-  readonly #transformer: CommentTransformer;
-
-  constructor(options: { repository: string }) {
-    this.#transformer = new CommentTransformer(options.repository);
-  }
-
-  transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-    return this.#transformer.transformRootNode(args.node);
-  }
-
-  async transformResult(
-    args: PluginTransformResultArgs
-  ): Promise<QueryResult<UnknownRow>> {
-    return args.result;
-  }
-}

package/src/plugins.ts

@@ -1,30 +0,0 @@
-import {
-  type Dialect,
-  Kysely as K,
-  type KyselyPlugin,
-  type LogConfig,
-} from 'kysely';
-import { CustomCasePlugin } from './camel-case';
-import { KyselyPganalyzeCommentPlugin } from './pganalyze-comment-plugin';
-import type { DB } from './v1.generated';
-
-export function getKysely(
-  dialect: Dialect,
-  options: { repositoryName?: string; log?: true | LogConfig }
-) {
-  const plugins: KyselyPlugin[] = [new CustomCasePlugin()];
-
-  if (options?.repositoryName) {
-    plugins.push(
-      new KyselyPganalyzeCommentPlugin({
-        repository: options.repositoryName,
-      })
-    );
-  }
-  const kysely = new K<DB>({
-    dialect,
-    plugins,
-    log: options?.log === true ? ['query', 'error'] : options?.log,
-  });
-  return kysely;
-}

package/src/query/index.ts

@@ -1 +0,0 @@
-export * from './listing';

package/src/query/listing/index.ts

@@ -1 +0,0 @@
-export * from './is-active-or-at-least-one-ownership-period-active';

package/src/query/listing/is-active-or-at-least-one-ownership-period-active.ts

@@ -1,29 +0,0 @@
-import type { DB, ExpressionBuilder, PublicListing } from '../../isomorphic';
-
-export function isActiveOrAtLeastOneOwnershipPeriodActive(
-  eb: ExpressionBuilder<DB & { listing: PublicListing }, 'listing'>,
-  today: string
-) {
-  return eb.or([
-    eb('listing.status', '=', 'active'),
-    eb.exists(
-      eb
-        .selectFrom('public.listingOwnershipPeriod as period')
-        .select(eb.lit(1).as('one'))
-        .whereRef('period.listingId', '=', 'listing.id')
-        .where('period.setListingInactive', '=', false)
-        .where((eb2) =>
-          eb2.or([
-            eb2.and([
-              eb2('period.startAt', '<=', today),
-              eb2('period.endAt', '>=', today),
-            ]),
-            eb2.and([
-              eb2('period.startAt', '<=', today),
-              eb2('period.endAt', 'is', null),
-            ]),
-          ])
-        )
-    ),
-  ]);
-}

package/src/test/index.ts

@@ -1,64 +0,0 @@
-import { afterAll } from 'bun:test';
-import type { Kysely } from 'kysely';
-import { type UseLocalKyselyOptions, useLocalKysely } from '../local';
-import type { DB } from '../v1.generated';
-
-/**
- * @deprecated Use `useLocalKyselyResource` instead.
- */
-export async function useTestKysely(
-  cleanupStrategy: 'afterAll',
-  args?: UseLocalKyselyOptions
-) {
-  const kysely = await useLocalKysely(args);
-
-  if (cleanupStrategy === 'afterAll')
-    afterAll(async () => {
-      await kysely.destroy();
-    });
-
-  return {
-    kysely,
-  };
-}
-
-export async function useTestAutoCleanupKysely(args?: UseLocalKyselyOptions) {
-  const kysely = await useLocalKysely(args);
-
-  afterAll(async () => {
-    await kysely.destroy();
-  });
-
-  return kysely;
-}
-
-type ReturnType = Kysely<DB> & {
-  [Symbol.dispose]: () => Promise<void>;
-};
-
-export async function useLocalKyselyResource(
-  args?: UseLocalKyselyOptions
-): Promise<ReturnType> {
-  const kysely = await useLocalKysely(args);
-
-  return new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        // somehow not working if using Symbol.dispose
-        if (prop === Symbol.asyncDispose) {
-          return async () => {
-            await kysely.destroy();
-          };
-        }
-        if (prop === 'kysely') {
-          return kysely;
-        }
-        if (typeof kysely[prop] === 'function') {
-          return kysely[prop].bind(kysely);
-        }
-        return kysely[prop];
-      },
-    }
-  ) as ReturnType;
-}