@cosmicdrift/kumiko-framework 0.367.0 → 0.368.0

package/src/scripts/codemod/testing-move.ts

@@ -0,0 +1,520 @@
+#!/usr/bin/env bun
+// testing-move — repoints imports of the former framework test subpaths to their new homes:
+// `@cosmicdrift/kumiko-framework/{stack,testing,testing/*}` moved into `@cosmicdrift/kumiko-testing`,
+// while `TestUsers` & co. moved to `/seeding` and `bridgeStub` to `/engine` (production code uses them).
+//
+// Usage:
+//   bun scripts/codemod/testing-move.ts <targetDir...> [--check | --dry-run | --write] [--no-format]
+// Without a mode flag it writes (kumiko-upgrade --apply calls it that way). --check exits 1
+// while any rewritable or manual site is left; --dry-run only reports.
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import {
+  type ExportDeclaration,
+  type ImportDeclaration,
+  type ImportTypeNode,
+  Node,
+  Project,
+  type SourceFile,
+  SyntaxKind,
+} from "ts-morph";
+import { collectSourceFiles } from "./collect-source-files.js";
+import {
+  classifyPackageSpecifier,
+  classifyRelativeSpecifier,
+  hasSplitNames,
+  type MoveTargetId,
+  mainTarget,
+  moduleSpecifierFor,
+  type OldModule,
+  targetForName,
+} from "./testing-move-targets.js";
+
+export interface TestingMoveSite {
+  readonly file: string;
+  readonly line: number;
+  readonly description: string;
+}
+
+export interface TestingMoveResult {
+  readonly output: string;
+  readonly rewrites: TestingMoveSite[];
+  readonly manual: TestingMoveSite[];
+}
+
+interface NamedElement {
+  readonly name: string;
+  readonly alias: string | undefined;
+  readonly isTypeOnly: boolean;
+}
+
+type NamedDeclaration = ImportDeclaration | ExportDeclaration;
+
+const CHEAP_PREFILTER = /\b(stack|testing)\b/;
+const SHIM_PATH_SUFFIXES: readonly string[] = [
+  "packages/framework/src/stack/index.ts",
+  "packages/framework/src/testing/index.ts",
+  "packages/framework/src/testing/handler-context.ts",
+  "packages/framework/src/testing/real-providers.ts",
+  "packages/framework/src/testing/e2e-generator.ts",
+];
+
+function oldModuleOf(specifier: string, filePath: string): OldModule | undefined {
+  return specifier.startsWith(".")
+    ? classifyRelativeSpecifier(specifier, filePath)
+    : classifyPackageSpecifier(specifier);
+}
+
+function groupByTarget(
+  old: OldModule,
+  elements: readonly NamedElement[],
+): Map<MoveTargetId, NamedElement[]> {
+  const groups = new Map<MoveTargetId, NamedElement[]>();
+  for (const element of elements) {
+    const target = targetForName(old, element.name);
+    groups.set(target, [...(groups.get(target) ?? []), element]);
+  }
+  return groups;
+}
+
+function elementsOf(declaration: NamedDeclaration): NamedElement[] {
+  const specifiers = Node.isImportDeclaration(declaration)
+    ? declaration.getNamedImports()
+    : declaration.getNamedExports();
+  return specifiers.map((specifier) => ({
+    name: specifier.getName(),
+    alias: specifier.getAliasNode()?.getText(),
+    isTypeOnly: specifier.isTypeOnly(),
+  }));
+}
+
+function toStructure(element: NamedElement): { name: string; alias?: string; isTypeOnly: boolean } {
+  return element.alias === undefined
+    ? { name: element.name, isTypeOnly: element.isTypeOnly }
+    : { name: element.name, alias: element.alias, isTypeOnly: element.isTypeOnly };
+}
+
+function elementText(element: NamedElement): string {
+  const alias = element.alias === undefined ? "" : ` as ${element.alias}`;
+  return `${element.isTypeOnly ? "type " : ""}${element.name}${alias}`;
+}
+
+function declarationText(
+  original: NamedDeclaration,
+  specifier: string,
+  elements: readonly NamedElement[],
+): string {
+  const keyword = Node.isImportDeclaration(original) ? "import" : "export";
+  const typeOnly = original.isTypeOnly() ? " type" : "";
+  return `${keyword}${typeOnly} { ${elements.map(elementText).join(", ")} } from "${specifier}";`;
+}
+
+function hasElement(existing: readonly NamedElement[], element: NamedElement): boolean {
+  return existing.some(
+    (candidate) => candidate.name === element.name && candidate.alias === element.alias,
+  );
+}
+
+function isMergeTarget(candidate: NamedDeclaration, original: NamedDeclaration): boolean {
+  if (candidate === original || candidate.isTypeOnly() !== original.isTypeOnly()) return false;
+  if (Node.isImportDeclaration(candidate)) {
+    return (
+      candidate.getNamespaceImport() === undefined && candidate.getDefaultImport() === undefined
+    );
+  }
+  return !candidate.isNamespaceExport() && candidate.getNamedExports().length > 0;
+}
+
+function findMergeTarget(
+  sourceFile: SourceFile,
+  original: NamedDeclaration,
+  specifier: string,
+): NamedDeclaration | undefined {
+  const sameKind: readonly NamedDeclaration[] = Node.isImportDeclaration(original)
+    ? sourceFile.getImportDeclarations()
+    : sourceFile.getExportDeclarations();
+  return sameKind.find(
+    (candidate) =>
+      candidate.getModuleSpecifierValue() === specifier && isMergeTarget(candidate, original),
+  );
+}
+
+function mergeInto(target: NamedDeclaration, elements: readonly NamedElement[]): void {
+  const present = elementsOf(target);
+  for (const element of elements) {
+    if (hasElement(present, element)) continue;
+    if (Node.isImportDeclaration(target)) target.addNamedImport(toStructure(element));
+    else target.addNamedExport(toStructure(element));
+  }
+}
+
+function repointDeclaration(
+  sourceFile: SourceFile,
+  declaration: NamedDeclaration,
+  old: OldModule,
+  filePath: string,
+): MoveTargetId[] {
+  const groups = groupByTarget(old, elementsOf(declaration));
+  const replacementLines: string[] = [];
+  for (const [target, elements] of groups) {
+    const specifier = moduleSpecifierFor(target, filePath);
+    const mergeTarget = findMergeTarget(sourceFile, declaration, specifier);
+    if (mergeTarget === undefined)
+      replacementLines.push(declarationText(declaration, specifier, elements));
+    else mergeInto(mergeTarget, elements);
+  }
+  // replaceWithText keeps the blank lines around the declaration, remove() would eat them.
+  declaration.replaceWithText(replacementLines.join("\n"));
+  return [...groups.keys()];
+}
+
+function isWholeModuleReference(declaration: NamedDeclaration): boolean {
+  if (Node.isImportDeclaration(declaration)) {
+    return (
+      declaration.getNamespaceImport() !== undefined || declaration.getDefaultImport() !== undefined
+    );
+  }
+  return declaration.isNamespaceExport() || declaration.getNamedExports().length === 0;
+}
+
+function usesSplitName(
+  sourceFile: SourceFile,
+  declaration: NamedDeclaration,
+  old: OldModule,
+): boolean {
+  const namespaceName = Node.isImportDeclaration(declaration)
+    ? declaration.getNamespaceImport()?.getText()
+    : undefined;
+  if (namespaceName === undefined) return true;
+  return sourceFile
+    .getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)
+    .some(
+      (access) =>
+        access.getExpression().getText() === namespaceName &&
+        targetForName(old, access.getName()) !== mainTarget(old),
+    );
+}
+
+function repointWholeModule(
+  sourceFile: SourceFile,
+  declaration: NamedDeclaration,
+  old: OldModule,
+  filePath: string,
+): MoveTargetId | undefined {
+  if (hasSplitNames(old) && usesSplitName(sourceFile, declaration, old)) return undefined;
+  const target = mainTarget(old);
+  declaration.setModuleSpecifier(moduleSpecifierFor(target, filePath));
+  return target;
+}
+
+function rewriteDeclarations(
+  sourceFile: SourceFile,
+  filePath: string,
+  result: { rewrites: TestingMoveSite[]; manual: TestingMoveSite[] },
+): void {
+  const declarations: NamedDeclaration[] = [
+    ...sourceFile.getImportDeclarations(),
+    ...sourceFile.getExportDeclarations(),
+  ];
+  // Lines are read up front: replacing an earlier declaration shifts everything below it.
+  const linesBefore = new Map(
+    declarations.map((declaration) => [declaration, declaration.getStartLineNumber()]),
+  );
+  for (const declaration of declarations) {
+    const specifier = declaration.getModuleSpecifierValue();
+    const old = specifier === undefined ? undefined : oldModuleOf(specifier, filePath);
+    if (specifier === undefined || old === undefined) continue;
+    const site = { file: filePath, line: linesBefore.get(declaration) ?? 0 };
+    if (!isWholeModuleReference(declaration)) {
+      const targets = repointDeclaration(sourceFile, declaration, old, filePath);
+      result.rewrites.push({ ...site, description: `${specifier} -> ${targets.join(", ")}` });
+      continue;
+    }
+    const target = repointWholeModule(sourceFile, declaration, old, filePath);
+    if (target !== undefined) {
+      result.rewrites.push({ ...site, description: `${specifier} -> ${target}` });
+    } else {
+      result.manual.push({
+        ...site,
+        description: `${specifier}: namespace or default import that uses names which moved to different packages`,
+      });
+    }
+  }
+}
+
+function stringLiteralOf(node: Node | undefined): string | undefined {
+  return node !== undefined && Node.isStringLiteral(node) ? node.getLiteralValue() : undefined;
+}
+
+function importTypeSpecifier(node: ImportTypeNode): string | undefined {
+  const argument = node.getArgument();
+  return Node.isLiteralTypeNode(argument) ? stringLiteralOf(argument.getLiteral()) : undefined;
+}
+
+function destructuredNames(call: Node): string[] | undefined {
+  const awaited = call.getParentIfKind(SyntaxKind.AwaitExpression);
+  const declaration = (awaited ?? call).getParentIfKind(SyntaxKind.VariableDeclaration);
+  const pattern = declaration?.getNameNode();
+  if (pattern === undefined || !Node.isObjectBindingPattern(pattern)) return undefined;
+  return pattern
+    .getElements()
+    .map((element) => element.getPropertyNameNode()?.getText() ?? element.getName());
+}
+
+function singleTargetFor(
+  old: OldModule,
+  names: readonly string[] | undefined,
+): MoveTargetId | undefined {
+  if (names === undefined) return hasSplitNames(old) ? undefined : mainTarget(old);
+  const targets = new Set(names.map((name) => targetForName(old, name)));
+  return targets.size === 1 ? [...targets][0] : undefined;
+}
+
+function isModuleMockCall(call: Node): boolean {
+  return Node.isCallExpression(call) && call.getExpression().getText() === "mock.module";
+}
+
+function isDynamicImportCall(call: Node): boolean {
+  return Node.isCallExpression(call) && call.getExpression().getKind() === SyntaxKind.ImportKeyword;
+}
+
+interface SpecifierSite {
+  readonly specifier: string;
+  readonly line: number;
+  readonly names: readonly string[] | undefined;
+  readonly replace: (next: string) => void;
+}
+
+function importTypeSites(sourceFile: SourceFile): SpecifierSite[] {
+  const sites: SpecifierSite[] = [];
+  for (const node of sourceFile.getDescendantsOfKind(SyntaxKind.ImportType)) {
+    const specifier = importTypeSpecifier(node);
+    if (specifier === undefined) continue;
+    const qualifier = node.getQualifier()?.getText().split(".")[0];
+    sites.push({
+      specifier,
+      line: node.getStartLineNumber(),
+      names: qualifier === undefined ? undefined : [qualifier],
+      replace: (next) => node.setArgument(next),
+    });
+  }
+  return sites;
+}
+
+function callSites(sourceFile: SourceFile): SpecifierSite[] {
+  const sites: SpecifierSite[] = [];
+  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    if (!isDynamicImportCall(call) && !isModuleMockCall(call)) continue;
+    const argument = call.getArguments()[0];
+    const specifier = stringLiteralOf(argument);
+    if (argument === undefined || specifier === undefined) continue;
+    sites.push({
+      specifier,
+      line: call.getStartLineNumber(),
+      // mock.module replaces a whole module, so it never splits by name.
+      names: isModuleMockCall(call) ? [] : destructuredNames(call),
+      replace: (next) => argument.replaceWithText(JSON.stringify(next)),
+    });
+  }
+  return sites;
+}
+
+function rewriteDynamicSites(
+  sourceFile: SourceFile,
+  filePath: string,
+  result: { rewrites: TestingMoveSite[]; manual: TestingMoveSite[] },
+): void {
+  for (const site of [...importTypeSites(sourceFile), ...callSites(sourceFile)]) {
+    const old = oldModuleOf(site.specifier, filePath);
+    if (old === undefined) continue;
+    const names = site.names?.length === 0 ? undefined : site.names;
+    const target = site.names?.length === 0 ? mainTarget(old) : singleTargetFor(old, names);
+    if (target === undefined) {
+      result.manual.push({
+        file: filePath,
+        line: site.line,
+        description: `${site.specifier}: dynamic import whose names moved to different packages`,
+      });
+      continue;
+    }
+    site.replace(moduleSpecifierFor(target, filePath));
+    result.rewrites.push({
+      file: filePath,
+      line: site.line,
+      description: `${site.specifier} -> ${target}`,
+    });
+  }
+}
+
+export function transformTestingMoveSource(
+  source: string,
+  filePath = "source.ts",
+): TestingMoveResult {
+  const result: TestingMoveResult = { output: source, rewrites: [], manual: [] };
+  if (!CHEAP_PREFILTER.test(source)) return result;
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true,
+  });
+  const sourceFile = project.createSourceFile(resolve(filePath), source);
+  rewriteDeclarations(sourceFile, resolve(filePath), result);
+  rewriteDynamicSites(sourceFile, resolve(filePath), result);
+  return { ...result, output: result.rewrites.length > 0 ? sourceFile.getFullText() : source };
+}
+
+type Mode = "write" | "dry-run" | "check";
+
+interface CliOptions {
+  readonly mode: Mode;
+  readonly format: boolean;
+  readonly paths: string[];
+}
+
+class CliError extends Error {}
+
+function parseArgs(argv: readonly string[]): CliOptions {
+  let mode: Mode | undefined;
+  let format = true;
+  const paths: string[] = [];
+  const setMode = (next: Mode): void => {
+    if (mode !== undefined && mode !== next) {
+      throw new CliError("--check, --dry-run and --write are mutually exclusive");
+    }
+    mode = next;
+  };
+  for (const arg of argv) {
+    if (arg === "--check") setMode("check");
+    else if (arg === "--dry-run") setMode("dry-run");
+    else if (arg === "--write") setMode("write");
+    else if (arg === "--no-format") format = false;
+    else if (arg.startsWith("--")) throw new CliError(`unknown flag: ${arg}`);
+    else paths.push(arg);
+  }
+  if (paths.length === 0) throw new CliError("at least one target directory is required");
+  return { mode: mode ?? "write", format, paths };
+}
+
+function isMigratableFile(name: string): boolean {
+  return /\.(ts|tsx)$/.test(name) && !name.endsWith(".d.ts");
+}
+
+function isSkippedPath(file: string): boolean {
+  return (
+    file.includes("/__tests__/fixtures/") ||
+    SHIM_PATH_SUFFIXES.some((suffix) => file.endsWith(suffix))
+  );
+}
+
+function findBiomeBinary(startDir: string): string | undefined {
+  let dir = resolve(startDir);
+  for (;;) {
+    const candidate = join(dir, "node_modules", ".bin", "biome");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+const FORMAT_BATCH_SIZE = 50;
+
+async function formatWithBiome(files: readonly string[], cwd: string): Promise<void> {
+  const biome = findBiomeBinary(cwd);
+  if (biome === undefined) {
+    console.log(
+      "[testing-move] biome not found in node_modules/.bin — format and sort imports of the changed files yourself",
+    );
+    // skip: formatting is a convenience, the rewrite itself is already on disk
+    return;
+  }
+  for (let i = 0; i < files.length; i += FORMAT_BATCH_SIZE) {
+    const batch = files.slice(i, i + FORMAT_BATCH_SIZE);
+    const proc = Bun.spawn({
+      cmd: [
+        biome,
+        "check",
+        "--write",
+        "--linter-enabled=false",
+        "--no-errors-on-unmatched",
+        ...batch,
+      ],
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stderr, exitCode] = await Promise.all([new Response(proc.stderr).text(), proc.exited]);
+    if (exitCode !== 0) {
+      console.log(
+        `[testing-move] biome exited ${exitCode}; run it on the changed files yourself\n${stderr.trim()}`,
+      );
+    }
+  }
+}
+
+function displayPath(file: string): string {
+  const fromCwd = relative(process.cwd(), file);
+  return fromCwd.startsWith("..") ? file : fromCwd;
+}
+
+interface RunSummary {
+  readonly rewrites: TestingMoveSite[];
+  readonly manual: TestingMoveSite[];
+  readonly changedFiles: string[];
+}
+
+function transformFiles(files: readonly string[], mode: Mode): RunSummary {
+  const summary: RunSummary = { rewrites: [], manual: [], changedFiles: [] };
+  for (const file of files) {
+    const before = readFileSync(file, "utf8");
+    const result = transformTestingMoveSource(before, file);
+    const shown = displayPath(file);
+    for (const site of result.rewrites)
+      console.log(`${shown}:${site.line}  rewritten  ${site.description}`);
+    for (const site of result.manual)
+      console.log(`${shown}:${site.line}  manual  ${site.description}`);
+    summary.rewrites.push(...result.rewrites);
+    summary.manual.push(...result.manual);
+    if (mode === "write" && result.output !== before) {
+      writeFileSync(file, result.output);
+      summary.changedFiles.push(file);
+    }
+  }
+  return summary;
+}
+
+function parseArgsOrExit(argv: readonly string[]): CliOptions {
+  try {
+    return parseArgs(argv);
+  } catch (err) {
+    if (err instanceof CliError) {
+      console.error(`[testing-move] ${err.message}`);
+      process.exit(2);
+    }
+    throw err;
+  }
+}
+
+async function main(): Promise<void> {
+  const options = parseArgsOrExit(process.argv.slice(2));
+  const files = collectSourceFiles(options.paths, { isMigratableFile }).filter(
+    (file) => !isSkippedPath(file),
+  );
+  const { rewrites, manual, changedFiles } = transformFiles(files, options.mode);
+
+  console.log(
+    `\n[testing-move] ${options.mode === "write" ? "rewritten" : "rewritable"}: ${rewrites.length} in ${new Set(rewrites.map((site) => site.file)).size} file(s); manual: ${manual.length}`,
+  );
+
+  if (options.mode === "write" && options.format && changedFiles.length > 0) {
+    await formatWithBiome(changedFiles, resolve(options.paths[0] ?? "."));
+  }
+
+  const hasOpenSites = rewrites.length + manual.length > 0;
+  process.exit(options.mode === "check" && hasOpenSites ? 1 : 0);
+}
+
+if (import.meta.main) {
+  await main();
+}

package/dist/bun-db/connection.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="bun-types" preserve="true" />
-import type { PgListenClient } from "@cosmicdrift/kumiko-types/db-connection";
-export type { PgListenClient };
-export type BunDbConnection = InstanceType<typeof Bun.SQL>;
-export type BunDbTx = BunDbConnection;
-export type BunDbRunner = BunDbConnection | BunDbTx;
-export type BunDbConnectionOptions = {
-    readonly maxConnections?: number;
-    readonly idleTimeoutSeconds?: number;
-    readonly connectTimeoutSeconds?: number;
-};
-export declare function createBunDbConnection(url: string, options?: BunDbConnectionOptions): {
-    db: BunDbConnection;
-    listenClient: PgListenClient;
-    close: () => Promise<void>;
-};
-export declare function bunDbConnectionOptionsFromEnv(env?: Readonly<Record<string, string | undefined>>): BunDbConnectionOptions;

package/dist/bun-db/connection.js

@@ -1,40 +0,0 @@
-/// <reference types="bun-types" preserve="true" />
-// Bun.SQL-basierter Connection-Layer (KEIN drizzle). Production-Pfad
-// nach drizzle-removal. Erstellt parallel zum legacy `db/connection.ts`
-// — apps migrieren schritt-für-schritt, alte Datei weg sobald 0 Konsumenten.
-//
-// LISTEN for the event dispatcher uses Bun.SQL's listen() on its own
-// dedicated connection, outside the pool's idleTimeout.
-import { readPositiveIntEnv } from "../utils/env-parse.js";
-export function createBunDbConnection(url, options = {}) {
-    const bunOpts = {};
-    if (options.maxConnections !== undefined)
-        bunOpts.max = options.maxConnections;
-    if (options.idleTimeoutSeconds !== undefined)
-        bunOpts.idleTimeout = options.idleTimeoutSeconds;
-    if (options.connectTimeoutSeconds !== undefined) {
-        bunOpts.connectionTimeout = options.connectTimeoutSeconds;
-    }
-    const db = new Bun.SQL(url, bunOpts);
-    return {
-        db,
-        listenClient: db,
-        close: async () => {
-            await db.end();
-        },
-    };
-}
-// guard:dup-ok — ENV-Reader für BunDB (gibt { db, listenClient } zurück), nicht verwandt mit redisClientOptionsFromEnv
-export function bunDbConnectionOptionsFromEnv(env = process.env) {
-    const opts = {};
-    const max = readPositiveIntEnv(env, "DATABASE_POOL_MAX");
-    const idle = readPositiveIntEnv(env, "DATABASE_POOL_IDLE_TIMEOUT");
-    const connect = readPositiveIntEnv(env, "DATABASE_POOL_CONNECT_TIMEOUT");
-    if (max !== undefined)
-        opts.maxConnections = max;
-    if (idle !== undefined)
-        opts.idleTimeoutSeconds = idle;
-    if (connect !== undefined)
-        opts.connectTimeoutSeconds = connect;
-    return opts;
-}

package/dist/bun-db/index.d.ts

@@ -1,4 +0,0 @@
-export type { BunDbConnection, BunDbConnectionOptions, BunDbRunner, BunDbTx, PgListenClient, } from "./connection.js";
-export { bunDbConnectionOptionsFromEnv, createBunDbConnection } from "./connection.js";
-export type { InnerJoinRow, InnerJoinSpec, InsertOnConflictDoNothingOptions, JoinColumnPair, JsonTextMatch, SelectOptions, TableInfo, WhereObject, WhereOperator, WhereValue, } from "./query.js";
-export { aggregateWhere, asEntityTableMeta, asRawClient, countWhere, type DeleteManyBatchedOptions, type DeleteManyBatchedResult, deleteMany, deleteManyBatched, extractTableInfo, fetchOne, type IncrementCounterOptions, incrementCounter, insertMany, insertOnConflictDoNothing, insertOne, instantToTimestamptzParam, isTimestamptzType, requireEntityTableMeta, runInSavepoint, runInSavepointIfSupported, runnerCanBeginTransaction, selectInnerJoin, selectMany, transaction, type UpsertOnConflictOptions, unsafeReadRetrying, updateMany, upsertByPk, upsertOnConflict, } from "./query.js";

package/dist/bun-db/query.d.ts

@@ -1,106 +0,0 @@
-import type { AggregateRow, AggregateSpec } from "@cosmicdrift/kumiko-types/aggregate-types";
-import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
-import type { SelectOptions, WhereObject } from "@cosmicdrift/kumiko-types/where-clause-types";
-import type { EntityTableMeta } from "../db/entity-table-meta.js";
-import { type NotExecutorOnly } from "../db/table-builder.js";
-import { asEntityTableMeta, requireEntityTableMeta } from "../db/table-introspection.js";
-import type { DbRunner } from "@cosmicdrift/kumiko-types/db-connection";
-import type { BunDbRunner } from "./connection.js";
-export { asEntityTableMeta, requireEntityTableMeta };
-export type ReservedClient = {
-    unsafe: RawClient["unsafe"];
-    release: () => unknown;
-};
-export type RawClient = {
-    unsafe: <TRow = unknown>(sql: string, params?: readonly unknown[]) => Promise<readonly TRow[]>;
-    begin?: <T>(fn: (tx: BunDbRunner) => Promise<T>) => Promise<T>;
-    savepoint?: <T>(fn: (sp: unknown) => Promise<T>) => Promise<T>;
-    release?: unknown;
-    reserve?: () => Promise<ReservedClient>;
-};
-export type RawClientWithBegin = RawClient & {
-    begin: NonNullable<RawClient["begin"]>;
-};
-export declare function hasBegin(client: RawClient): client is RawClientWithBegin;
-export declare function asRawClient(db: unknown): RawClient;
-export declare function runnerCanBeginTransaction(db: unknown): boolean;
-export declare function runInSavepoint<T>(tx: unknown, fn: (sp: unknown) => Promise<T>): Promise<T>;
-export declare function runInSavepointIfSupported<T>(db: unknown, fn: (sp: DbRunner) => Promise<T>): Promise<T>;
-export type AnyDb = BunDbRunner | unknown;
-export type { JsonTextMatch, OrderByClause, SelectOptions, WhereObject, WhereOperator, WhereValue, } from "@cosmicdrift/kumiko-types/where-clause-types";
-type TableLike = EntityTableMeta | any;
-type WritableTable = EntityTableMeta & NotExecutorOnly;
-export type TableInfo = {
-    readonly name: string;
-    readonly columnOf: (field: string) => string;
-    readonly pgTypeOf: (column: string) => string | undefined;
-    readonly bigintJsModeOf: (column: string) => "number" | "bigint" | undefined;
-    readonly fieldOf: (column: string) => string;
-    readonly hasColumn: (fieldOrColumn: string) => boolean;
-};
-export declare function extractTableInfo(table: TableLike): TableInfo;
-export declare function coerceRow<TOut = Record<string, unknown>>(row: Record<string, unknown>, info: TableInfo): TOut;
-export declare function instantToTimestamptzParam(instant: Temporal.Instant): string;
-export declare function isClosedConnectionError(err: unknown): boolean;
-export declare function describeClosedConnectionFailure(raw: unknown, err: unknown, attempts: number): Record<string, unknown> | undefined;
-export declare function unsafeReadRetrying<TRow>(db: AnyDb, sqlText: string, params: readonly unknown[]): Promise<readonly TRow[]>;
-export declare function selectMany<TRow = any>(db: AnyDb, table: TableLike, where?: WhereObject, options?: SelectOptions): Promise<readonly TRow[]>;
-export declare function fetchOne<TRow = any>(db: AnyDb, table: TableLike, where: WhereObject): Promise<TRow | undefined>;
-export type JoinColumnPair = {
-    readonly left: string;
-    readonly right: string;
-};
-export type InnerJoinSpec = {
-    readonly left: TableLike;
-    readonly right: TableLike;
-    readonly on: readonly [JoinColumnPair, ...JoinColumnPair[]];
-    readonly leftWhere?: WhereObject;
-    readonly rightWhere?: WhereObject;
-    /** Fields to return per side; default: all columns of `left`, none of `right`. */
-    readonly leftFields?: readonly string[];
-    readonly rightFields?: readonly string[];
-    readonly limit?: number;
-};
-export type InnerJoinRow<TLeft, TRight> = {
-    readonly left: TLeft;
-    readonly right: TRight;
-};
-export declare function selectInnerJoin<TLeft = Record<string, unknown>, TRight = Record<string, unknown>>(db: AnyDb, spec: InnerJoinSpec): Promise<readonly InnerJoinRow<TLeft, TRight>[]>;
-export declare function insertMany<TRow = any>(db: AnyDb, table: WritableTable, rows: ReadonlyArray<Record<string, unknown>>): Promise<readonly TRow[]>;
-export declare function insertOne<TRow = any>(db: AnyDb, table: WritableTable, values: Record<string, unknown>): Promise<TRow | undefined>;
-export declare function updateMany<TRow = any>(db: AnyDb, table: WritableTable, set: Record<string, unknown>, where: WhereObject): Promise<readonly TRow[]>;
-export declare function deleteMany(db: AnyDb, table: WritableTable, where: WhereObject): Promise<void>;
-export declare function resolveConflictColumns(table: TableLike, info: TableInfo, conflictKeys: readonly string[] | undefined): readonly string[];
-export type UpsertOnConflictOptions = {
-    readonly conflictKeys: readonly string[];
-    /** Columns to set on conflict. Default: EXCLUDED for every inserted non-key column. */
-    readonly update?: Record<string, unknown>;
-};
-export type DeleteManyBatchedOptions = {
-    readonly limit: number;
-    readonly maxBatches?: number;
-    /** Row id field for the LIMIT subquery. Default `id`. */
-    readonly idColumn?: string;
-};
-export type DeleteManyBatchedResult = {
-    readonly deleted: number;
-    readonly batches: number;
-};
-export declare function countWhere(db: AnyDb, table: TableLike, where?: WhereObject): Promise<number>;
-export declare function isTimestamptzType(pgType: string | undefined): boolean;
-export declare function aggregateWhere(db: AnyDb, table: TableLike, spec: AggregateSpec, where?: WhereObject): Promise<readonly AggregateRow[]>;
-export declare function upsertOnConflict<TRow = any>(db: AnyDb, table: WritableTable, values: Record<string, unknown>, options: UpsertOnConflictOptions): Promise<TRow | undefined>;
-export declare function upsertByPk<TRow = any>(db: AnyDb, table: WritableTable, values: Record<string, unknown>, updateOnConflict?: Record<string, unknown>): Promise<TRow | undefined>;
-export type InsertOnConflictDoNothingOptions = {
-    readonly conflictKeys?: readonly string[];
-};
-export declare function insertOnConflictDoNothing<TRow = any>(db: AnyDb, table: WritableTable, values: Record<string, unknown>, options?: InsertOnConflictDoNothingOptions): Promise<TRow | undefined>;
-export type IncrementCounterOptions = {
-    readonly conflictKeys?: readonly string[];
-    /** Extra SET clauses on conflict (e.g. lastUpdatedAt: sql\`NOW()\`). */
-    readonly set?: Record<string, unknown>;
-};
-export declare function incrementCounter<TRow = any>(db: AnyDb, table: WritableTable, values: Record<string, unknown>, increments: Record<string, number>, options?: IncrementCounterOptions): Promise<TRow | undefined>;
-export declare function deleteManyBatched(db: AnyDb, table: WritableTable, where: WhereObject, options: DeleteManyBatchedOptions): Promise<DeleteManyBatchedResult>;
-export declare function transaction<T>(db: AnyDb, fn: (tx: BunDbRunner) => Promise<T>): Promise<T>;
-export declare function runInNewTransaction<T>(db: unknown, fn: (tx: DbRunner) => Promise<T>): Promise<T>;