okmodel 0.3.0 → 0.5.0

package/dist/tooling/migrate/safe.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Safe DDL for a table that already exists (D193).
+ *
+ * A new table keeps the plain statements from `ddl.ts`. These shapes are only
+ * for a table in the before-catalog: concurrent indexes, `NOT VALID` plus
+ * `VALIDATE`, `SET NOT NULL` through a validated check, a volatile default
+ * split from column creation, and a unique or primary key built from a
+ * concurrent unique index.
+ *
+ * The volatile-default fill is a backfill: one idempotent `UPDATE` per batch,
+ * limited to rows where the new column is still null (D195).
+ */
+import type { Catalog, CatalogObject, ColumnObject } from "../../contracts/catalog/types.js";
+import { type BackfillSpec } from "./backfill.js";
+import type { StepKind } from "./classify.js";
+/** One statement the planner emits instead of the plain form. */
+export type SafeStep = {
+    readonly sql: string;
+    readonly kind: StepKind;
+    readonly action: "ddl" | "backfill";
+    readonly lock: string;
+    readonly transactional: boolean;
+    /** Set on the volatile-default fill. The statement is one batch. */
+    readonly backfill?: BackfillSpec;
+};
+/**
+ * Safe steps for one object on a table that already exists.
+ *
+ * Returns `undefined` when the plain statement is already safe: a stable or
+ * constant column default, or an object this rewrite does not cover.
+ *
+ * @param object - Object the plan is creating
+ * @param schema - Concrete schema name
+ * @param catalogs - Before and after catalogs, for volatility and name clashes
+ * @param batchSize - Rows per batch written on a volatile-default fill
+ * @returns The replacement steps, or `undefined` to keep the plain statement
+ */
+export declare function stepsForExistingTable(object: CatalogObject, schema: string, catalogs: readonly Catalog[], batchSize: number): readonly SafeStep[] | undefined;
+/**
+ * `SET NOT NULL` through a validated check (Postgres 12+, always on the floor of 15).
+ *
+ * Postgres skips the table scan when a validated `CHECK (col IS NOT NULL)`
+ * already exists. The temporary check is dropped after `SET NOT NULL`.
+ *
+ * @param column - Column that must become `NOT NULL`
+ * @param schema - Concrete schema name
+ * @param setKind - `set-not-null` when the column already existed; `add-column` when this finishes a new column and the plan stays expand
+ * @param catalogs - Catalogs whose constraint names the temporary check must not reuse
+ * @returns Add `NOT VALID`, validate, set not null, drop the check
+ */
+export declare function notNullSteps(column: ColumnObject, schema: string, setKind: "set-not-null" | "add-column", catalogs: readonly Catalog[]): readonly SafeStep[];
+/**
+ * Inserts `CONCURRENTLY` into a `CREATE INDEX` statement.
+ *
+ * @param sql - Plain `create index` or `create unique index` from `ddl.ts`
+ * @returns The same statement, concurrent
+ */
+export declare function concurrentIndexSql(sql: string): string;
+/**
+ * Inserts `CONCURRENTLY` into a `DROP INDEX` statement.
+ *
+ * @param sql - Plain `drop index` from `ddl.ts`
+ * @returns The same statement, concurrent
+ */
+export declare function concurrentDropIndexSql(sql: string): string;
+/**
+ * Reports whether a default expression is volatile.
+ *
+ * A constant has no call. `now()` and the other stable builtins stay plain.
+ * `gen_random_uuid()`, `uuidv7()`, and any other call the catalog marks
+ * volatile are split. A call the catalog does not know is left plain.
+ *
+ * @param expression - Column `defaultExpression`, when the column has one
+ * @param catalogs - Catalogs that may hold the called function
+ * @returns `true` when adding the column with this default would rewrite existing rows
+ */
+export declare function volatileDefault(expression: string | undefined, catalogs: readonly Catalog[]): boolean;

package/dist/tooling/migrate/seed.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `okm seed <file>` (spec §20, D199).
+ *
+ * The file's default export receives the testing harness for the selected
+ * target. Protection is `assertTargetPolicy`, the same gate as every other
+ * command. The target is already migrated: this command does not apply DDL.
+ */
+import { type InvokeFlags } from "./policy.js";
+/**
+ * Runs a seed file against the selected target.
+ *
+ * Policy and target selection run before the pool opens, so a protected
+ * target is refused without a connection.
+ *
+ * @param cwd - Project directory
+ * @param file - Seed module, relative to `cwd`
+ * @param flags - `--target`, `--allow-protected`, and `--allow-pooler`
+ * @returns Text for stdout
+ */
+export declare function seedProject(cwd: string, file: string, flags: InvokeFlags): Promise<string>;

package/dist/tooling/migrate/snapshot.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Head snapshot install and the comparison with a replayed history (D198).
+ *
+ * Provision plans the head catalog from an empty catalog and runs that SQL.
+ * It does not replay migration files. OKM1521 is the difference between that
+ * result and a full replay, after {@link canonicalTypeName} (D191).
+ */
+import type { Catalog } from "../../contracts/catalog/types.js";
+import type { DriverConnection } from "../../contracts/driver.js";
+import type { ReferenceTable } from "./reference.js";
+/** History id prefix for a target installed from the head snapshot. */
+export declare const PROVISION_PREFIX = "provisioned@";
+/**
+ * History id written when a target is provisioned at `migrationId`.
+ *
+ * @param migrationId - Head migration id
+ * @returns `provisioned@` plus that id
+ */
+export declare function provisionMark(migrationId: string): string;
+/**
+ * Migration id stored inside a provision mark.
+ *
+ * @param migrationId - A history migration id
+ * @returns The id after the prefix, or `undefined` when it is not a mark
+ */
+export declare function provisionedMigrationId(migrationId: string): string | undefined;
+/**
+ * Marks every step up through a provisioned migration as done.
+ *
+ * A later file stays pending. A mark whose id is not in `migrations` is left
+ * for the caller to treat as history this project does not contain.
+ *
+ * @param migrations - Files in apply order
+ * @param done - Keys `${id}:${step}` already in history
+ * @param historyIds - `migration_id` values in history
+ * @returns A set the applier can skip
+ */
+export declare function expandProvisioned(migrations: readonly {
+    readonly id: string;
+    readonly steps: readonly unknown[];
+}[], done: ReadonlySet<string>, historyIds: readonly string[]): Set<string>;
+/**
+ * Reports whether a history id belongs to this project's files.
+ *
+ * A `provisioned@` mark belongs when the id after the prefix is a file.
+ *
+ * @param migrationId - History migration id
+ * @param known - File ids
+ * @returns `true` when status should not call the row ahead
+ */
+export declare function provisionHistoryIsKnown(migrationId: string, known: ReadonlySet<string>): boolean;
+/**
+ * Installs `head` into an empty schema and inserts reference rows.
+ *
+ * The plan is from an empty catalog, so no expand, backfill, or contract
+ * file is replayed. An existing role is left in place. The caller records
+ * history.
+ *
+ * @param connection - Reserved connection, after the advisory lock
+ * @param head - Head snapshot
+ * @param schema - Schema that receives the objects
+ * @param reference - Rows to insert if missing
+ * @param migrationRole - Role assumed after this run creates it
+ */
+export declare function installSnapshot(connection: DriverConnection, head: Catalog, schema: string, reference: readonly ReferenceTable[], session: {
+    setRole?: string;
+}, migrationRole?: string): Promise<void>;
+/**
+ * Names the first object that differs between two introspected catalogs.
+ *
+ * Type names are compared with {@link canonicalTypeName}. Managed history
+ * tables are omitted. `undefined` means the catalogs match.
+ *
+ * @param left - One introspection
+ * @param right - The other introspection
+ * @returns The object, and the statement that would change it, when they differ
+ */
+export declare function snapshotDifference(left: Catalog, right: Catalog): string | undefined;

package/dist/tooling/migrate/status.d.ts

@@ -2,8 +2,10 @@
  * `okm migrate status`.
  *
  * One row per target: version, catalog hash, state, and a separate protected
- * column. The state is current, behind by expand, behind by contract, ahead,
- * or failed at a step.
+ * column. The state is current, behind by expand, behind by contract, ahead
+ * by expand, ahead by contract, or failed at a step with a resume hint. An
+ * unfinished backfill is a later section: migration, step, rows so far, last
+ * key, and state.
  */
 import type { MigrationClass } from "./plan.js";
 import type { StoredMigration } from "./files.js";
@@ -15,6 +17,18 @@ export type TargetStatus = {
     readonly catalogHash: string;
     readonly state: string;
     readonly protected: boolean;
+    /** Unfinished `okm_backfill` rows for this target. A finished step is absent. */
+    readonly backfills: readonly BackfillProgress[];
+};
+/** One backfill that has committed at least one batch and is not done. */
+export type BackfillProgress = {
+    readonly migrationId: string;
+    readonly stepIndex: number;
+    /** Rows the committed batches changed. */
+    readonly rows: string;
+    /** Last committed boundary, or `-` when the first batch is still open. */
+    readonly lastKey: string;
+    readonly state: string;
 };
 /** A checkpoint row the state function reads. */
 export type StatusHistory = {
@@ -25,9 +39,11 @@ export type StatusHistory = {
 /**
  * Decides the status state from files and history.
  *
- * A partial migration is `failed at step`. History the files do not contain
- * is `ahead`. Pending files are behind by expand, or by contract when any
- * pending step is not expand.
+ * A partial migration is `failed at step` plus the resume hint. History the
+ * files do not contain is ahead by expand, or ahead by contract when a stored
+ * class is not expand. Pending files are behind by expand, or by contract
+ * when any pending step is not expand. The class is the one stored on the
+ * file or in `okm_history`.
  *
  * @param migrations - Files in apply order
  * @param history - Checkpoint rows
@@ -68,7 +84,10 @@ export declare function statusProject(cwd: string, flags: InvokeFlags): Promise<
 /**
  * Prints status rows.
  *
+ * The target columns stay `target`, `version`, `catalog`, `state`, and
+ * `protected`. Unfinished backfills follow as their own section.
+ *
  * @param rows - One per target
- * @returns Header plus one line per target
+ * @returns Header plus one line per target, then unfinished backfills
  */
 export declare function formatStatus(rows: readonly TargetStatus[]): string;

package/dist/tooling/testing/factories.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Factories: `create`, `createMany`, `with({ child: n })`, and `x.ref`.
+ *
+ * A required column the definition leaves out is filled from its type (D199).
+ * `x.ref` reuses the latest row of that table in the same tenant, or creates one.
+ */
+import type { Connected } from "../../runtime/types.js";
+import { type TableFacts, type TestingSchema } from "./facts.js";
+import type { Rng } from "./random.js";
+declare const REF: unique symbol;
+/** A `x.ref("table")` marker. Resolved when the row is inserted. */
+type FactoryRef = {
+    readonly [REF]: string;
+};
+/** Values a factory definition may return. */
+export type FactoryContext = {
+    /** `userN@example.com`. N increases for each call. */
+    email(): string;
+    /** A first and last name from a fixed list. */
+    name(): string;
+    /** `count` words from a fixed list. */
+    words(count: number): string;
+    /** An integer in `[0, bound)`. `bound` defaults to 10_000. */
+    int(bound?: number): number;
+    /** A number in `[0, 1)`. */
+    float(): number;
+    /** A boolean. */
+    boolean(): boolean;
+    /** An ISO date `YYYY-MM-DD` in January 2020. */
+    date(): string;
+    /** A UUID from the seed. */
+    uuid(): string;
+    /** One entry of `list`. */
+    pick<T>(list: readonly T[]): T;
+    /**
+     * The primary key of `table`.
+     *
+     * The first call creates the row. A later call in the same tenant reuses it.
+     * A `create` of that table replaces the reused row.
+     */
+    ref(table: string): FactoryRef;
+};
+/** One table's factory. */
+export type TableFactory = {
+    /**
+     * Inserts one row.
+     *
+     * @param overrides - Column values. A tenant key here is the scope, not a column.
+     * @returns The inserted row
+     */
+    create(overrides?: Readonly<Record<string, unknown>>): Promise<Record<string, unknown>>;
+    /**
+     * Inserts `count` rows. Each row draws new generated values.
+     *
+     * @param count - How many rows
+     * @param overrides - Column values applied to every row
+     * @returns The inserted rows
+     */
+    createMany(count: number, overrides?: Readonly<Record<string, unknown>>): Promise<readonly Record<string, unknown>[]>;
+    /**
+     * Creates `count` rows of `child` after the parent, linked by the foreign key.
+     *
+     * @param children - Child table name to how many rows
+     * @returns A factory that still inserts this table
+     */
+    with(children: Readonly<Record<string, number>>): TableFactory;
+};
+/**
+ * Remembers `host` for the harness object `okm seed` prints from.
+ *
+ * @param harness - The object returned by `testing()`
+ * @param host - Its factory state
+ */
+export declare function attachHost(harness: object, host: FactoryHost): void;
+/**
+ * Rows inserted through factories, summed by table name.
+ *
+ * @param harness - The object returned by `testing()`
+ * @returns Counts in table-name order
+ */
+export declare function createdOf(harness: object): readonly {
+    readonly table: string;
+    readonly count: number;
+}[];
+/** Shared state for one harness. */
+export type FactoryHost = {
+    readonly schema: TestingSchema;
+    readonly db: Connected<TestingSchema>;
+    readonly facts: ReadonlyMap<string, TableFacts>;
+    readonly rng: Rng;
+    /** Latest row of a table in one tenant. Isolation uses its own map. */
+    cache: Map<string, Record<string, unknown>>;
+    /** Tables currently being inserted. A repeat is a factory cycle. */
+    readonly creating: Set<string>;
+    readonly created: Map<string, number>;
+    readonly definitions: Map<string, (context: FactoryContext) => Readonly<Record<string, unknown>>>;
+};
+/**
+ * Builds the factory object for `definitions`.
+ *
+ * @param host - Schema, client, and seed
+ * @param definitions - One function per table
+ * @returns A factory per definition
+ */
+export declare function bindFactories(host: FactoryHost, definitions: Readonly<Record<string, (context: FactoryContext) => Readonly<Record<string, unknown>>>>): Record<string, TableFactory>;
+/**
+ * Inserts one row, filling required columns. Used by factories and by isolation.
+ *
+ * @param host - Schema, client, and seed
+ * @param table - Table name
+ * @param overrides - Column values and the tenant key
+ * @param children - Child counts from `with`
+ * @param inherited - Tenant from the parent row, when this row is a child
+ * @returns The inserted row
+ */
+export declare function insertRow(host: FactoryHost, table: string, overrides: Readonly<Record<string, unknown>> | undefined, children: Readonly<Record<string, number>> | undefined, inherited: string | undefined): Promise<Record<string, unknown>>;
+export {};

package/dist/tooling/testing/facts.d.ts

@@ -0,0 +1,75 @@
+/**
+ * What a factory needs from a compiled schema: required columns, foreign keys,
+ * and which tables are tenant or global.
+ *
+ * Column tenancy is the only strategy in this version. A table is tenant when
+ * its predicate binds a scope, and global when `global("reason")` opted it out.
+ * `schemaPerTenant` and `databasePerTenant` are not in 0.4.
+ */
+import type { Catalog } from "../../contracts/catalog/types.js";
+import type { QuerySchema, RelationModel } from "../../dialects/pg/model.js";
+/** A schema `testing()` can open. `schema()` returns this shape. */
+export type TestingSchema = QuerySchema & {
+    readonly catalog: Catalog;
+};
+/** One foreign key, SQL names, child columns aligned with the target columns. */
+export type ForeignKey = {
+    readonly columns: readonly string[];
+    readonly target: string;
+    readonly targetColumns: readonly string[];
+};
+/** One column, with the catalog facts the factory uses to fill a default. */
+export type ColumnFacts = {
+    readonly field: string;
+    readonly sql: string;
+    readonly dataType: string;
+    readonly nullable: boolean;
+    readonly databaseDefault: boolean;
+    readonly identity: boolean;
+    readonly generated: boolean;
+    readonly guarded: boolean;
+    readonly writable: boolean;
+    readonly fill: boolean;
+    readonly accepts: readonly string[] | undefined;
+    readonly encode: (value: unknown) => string;
+};
+/** One table. */
+export type TableFacts = {
+    readonly name: string;
+    readonly sql: string;
+    readonly primary: readonly string[];
+    readonly columns: readonly ColumnFacts[];
+    readonly relations: readonly RelationModel[];
+    readonly foreignKeys: readonly ForeignKey[];
+    /** Column tenancy applies a predicate. */
+    readonly tenant: boolean;
+    /** `global("reason")`. Absent on a tenant table and on a schema with no tenancy. */
+    readonly globalReason: string | undefined;
+};
+/**
+ * Scope value used to ask a tenancy object whether a table is tenant.
+ *
+ * A test tenancy can recognise this probe and still omit the predicate on a
+ * real query. That is how the isolation check is shown to fail.
+ */
+export declare const tenantProbe = "00000000-0000-4000-8000-000000000001";
+/**
+ * Reads every table in declaration order.
+ *
+ * Views and materialized views are in the query model too. They have no rows
+ * of their own to insert, so they are left out.
+ *
+ * @param schema - Compiled schema
+ * @returns One facts object per table
+ */
+export declare function readFacts(schema: TestingSchema): readonly TableFacts[];
+/**
+ * A column the factory must set when the definition and the overrides omit it.
+ *
+ * Nullable, a database default, identity, a generated expression, a client
+ * fill, and a guarded column are left to the database or the scope (D199).
+ *
+ * @param column - Column facts
+ * @returns Whether the factory fills it
+ */
+export declare function isRequired(column: ColumnFacts): boolean;

package/dist/tooling/testing/index.d.ts

@@ -0,0 +1,89 @@
+/**
+ * `okmodel/testing`: a real database, factories, query counts, and the
+ * isolation check (spec §20, D199).
+ *
+ * The database is never mocked. Pass a driver pool from `open()`.
+ */
+import type { DriverPool } from "../../contracts/driver.js";
+import type { Connected } from "../../runtime/types.js";
+import { type TableFactory } from "./factories.js";
+import { type TestingSchema } from "./facts.js";
+import { type IsolationReport } from "./isolation.js";
+/** Options for {@link testing}. */
+export type TestingOptions = {
+    /**
+     * A driver pool, or a promise of one.
+     *
+     * `open()` from `okmodel/pg/pglite` and `open({ url })` from
+     * `okmodel/pg/postgresjs` both satisfy this.
+     */
+    readonly driver: DriverPool | Promise<DriverPool>;
+    /**
+     * Seed for factory generators.
+     *
+     * The default is `1`. The same seed replays the same values.
+     */
+    readonly seed?: number;
+    /**
+     * Apply the schema's catalog before connecting.
+     *
+     * The default is true, for an empty test database. `okm seed` passes false:
+     * the target already has its schema.
+     */
+    readonly migrate?: boolean;
+};
+/**
+ * What a factory definition may call.
+ *
+ * Re-exported so a seed file can name the argument.
+ */
+export type { FactoryContext, TableFactory } from "./factories.js";
+export type { IsolationReport } from "./isolation.js";
+/** Definitions passed to {@link Testing.factories}. */
+export type FactoryDefinitions = {
+    readonly [table: string]: (context: import("./factories.js").FactoryContext) => Readonly<Record<string, unknown>>;
+};
+/**
+ * A connected test database.
+ *
+ * @typeParam S - Schema passed to {@link testing}
+ */
+export type Testing<S extends TestingSchema = TestingSchema> = {
+    /** The client. `close` on the harness closes this pool. */
+    readonly db: Connected<S>;
+    /**
+     * Builds factories for the named tables.
+     *
+     * @param definitions - One function per table
+     * @returns `create`, `createMany`, and `with` for each table
+     */
+    factories<const D extends FactoryDefinitions>(definitions: D): {
+        readonly [K in keyof D]: TableFactory;
+    };
+    /**
+     * Fails when `run` sends a different number of statements than `count`.
+     *
+     * Transaction control is not counted. The error lists the statements that were.
+     *
+     * @param count - Expected statements
+     * @param run - The work to count
+     */
+    expectQueries(count: number, run: () => Promise<unknown>): Promise<void>;
+    /**
+     * Runs the cross-tenant check.
+     *
+     * @returns Checked tenant tables and skipped global tables
+     */
+    isolation(): Promise<IsolationReport>;
+    /** Closes the client and the pool. */
+    close(): Promise<void>;
+};
+/**
+ * Opens `schema` on `driver` and returns the test harness.
+ *
+ * @typeParam S - Schema
+ * @param schema - A `schema()` value
+ * @param options - Driver, seed, and whether to apply the catalog
+ * @returns The harness
+ */
+export declare function testing<const S extends TestingSchema>(schema: S, options: TestingOptions): Promise<Testing<S>>;

package/dist/tooling/testing/index.js

@@ -0,0 +1,8 @@
+import {
+  testing2
+} from "../../shared/g516zdsb.js";
+import"../../shared/8xsbagad.js";
+import"../../shared/8bwbwy8h.js";
+export {
+  testing2 as testing
+};

package/dist/tooling/testing/isolation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Cross-tenant isolation check.
+ *
+ * For every tenant table, insert one row as tenant B and run the basic reads
+ * and writes as tenant A. A returned row, a count above zero, or an update or
+ * delete that touches a row is a leak. Global tables are skipped and listed.
+ * Column tenancy is the strategy this version has. A table is tenant when its
+ * predicate says so (D199).
+ */
+import { type FactoryHost } from "./factories.js";
+/** What {@link isolation} checked, and the global tables it skipped. */
+export type IsolationReport = {
+    /** Tenant tables whose queries stayed inside tenant A. */
+    readonly checked: readonly string[];
+    /** Global tables, with the reason from `global("reason")`. */
+    readonly skipped: readonly {
+        readonly table: string;
+        readonly reason: string;
+    }[];
+};
+/**
+ * Runs the check on `host`.
+ *
+ * The cache used for `x.ref` is set aside for the run, so a row the test
+ * already inserted is not reused as tenant B's row.
+ *
+ * @param host - The open harness
+ * @returns The tables that were checked and the global tables that were not
+ */
+export declare function isolation(host: FactoryHost): Promise<IsolationReport>;

package/dist/tooling/testing/random.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Seeded generators for factories.
+ *
+ * Mulberry32, a fixed word list, and a counter. No runtime dependency.
+ * The same seed replays the same sequence (D199).
+ */
+/** A seeded sequence and the values factories ask for. */
+export type Rng = {
+    /** Next unit interval, `[0, 1)`. */
+    next(): number;
+    /** Integer in `[0, bound)`. */
+    int(bound: number): number;
+    /** A version-4 UUID. The bits come from this sequence. */
+    uuid(): string;
+    /** `local@example.com`, unique for this sequence. */
+    email(): string;
+    /** A first and last name from the fixed lists. */
+    name(): string;
+    /** `count` words from the fixed list. */
+    words(count: number): string;
+    /** A boolean. */
+    boolean(): boolean;
+    /** A number in `[0, 1)`. */
+    float(): number;
+    /** An ISO date `YYYY-MM-DD` in 2020. */
+    date(): string;
+    /** One value from `list`. */
+    pick<T>(list: readonly T[]): T;
+    /** The next counter value, starting at 1. Text defaults append it. */
+    counter(): number;
+};
+/**
+ * Builds the sequence for `seed`.
+ *
+ * Seed `1` is the default. `0` is shifted so the first step is not a fixed point.
+ *
+ * @param seed - Integer seed
+ * @returns The sequence
+ */
+export declare function rng(seed: number): Rng;

package/dist/tooling/testing/record.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A pool that records every statement sent to the driver.
+ *
+ * `expectQueries` counts this log. Transaction control is left out (D199).
+ * The runtime logger records errors only, and `hookm` records notices and
+ * transaction phases, not statement text, so the count wraps the pool.
+ */
+import type { DriverPool, WireValue } from "../../contracts/driver.js";
+/** One statement that reached the driver. */
+export type Recorded = {
+    readonly text: string;
+    readonly params: readonly WireValue[];
+};
+/** A recording pool and its log. */
+export type Recording = {
+    readonly pool: DriverPool;
+    /** Every statement since the pool was wrapped, in the order sent. */
+    readonly log: Recorded[];
+};
+/**
+ * Reports whether `text` only frames a transaction.
+ *
+ * Not counted: `BEGIN`, `START TRANSACTION`, `COMMIT`, `END`, `ROLLBACK`,
+ * `ROLLBACK TO`, `SAVEPOINT`, `RELEASE SAVEPOINT`, `SET TRANSACTION`,
+ * `SET LOCAL`, and `SET SESSION CHARACTERISTICS`. A data statement is counted,
+ * including one that runs inside a transaction.
+ *
+ * @param text - Statement text
+ * @returns Whether the statement is transaction control
+ */
+export declare function isTransactionControl(text: string): boolean;
+/**
+ * Wraps a pool so each statement is logged.
+ *
+ * @param pool - The real pool
+ * @returns The wrapped pool and its log
+ */
+export declare function record(pool: DriverPool): Recording;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okmodel",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "okmodel is a catalog-first TypeScript ORM, PostgreSQL first.",
   "keywords": [
     "migrations",
@@ -82,6 +82,10 @@
       "types": "./dist/runtime/tenancy/index.d.ts",
       "import": "./dist/runtime/tenancy/index.js"
     },
+    "./testing": {
+      "types": "./dist/tooling/testing/index.d.ts",
+      "import": "./dist/tooling/testing/index.js"
+    },
     "./validate": {
       "types": "./dist/runtime/validate/index.d.ts",
       "import": "./dist/runtime/validate/index.js"
@@ -108,7 +112,7 @@
     }
   },
   "scripts": {
-    "build": "rm -rf dist && bun build ./src/contracts/index.ts ./src/contracts/internal.ts ./src/dialects/pg/index.ts ./src/runtime/pg/postgresjs.ts ./src/runtime/pg/pglite.ts ./src/runtime/pg/pg.ts ./src/runtime/pg/bun.ts ./src/runtime/ids/index.ts ./src/runtime/safety/index.ts ./src/runtime/traits/index.ts ./src/runtime/tenancy/index.ts ./src/runtime/validate/index.ts ./src/dialects/pg/ext/index.ts ./src/dialects/pg/fn/index.ts ./src/dialects/pg/view/index.ts ./src/dialects/pg/ext/citext.ts ./src/dialects/pg/ext/pg-trgm.ts ./src/tooling/migrate/index.ts ./src/tooling/cli.ts --outdir ./dist --root ./src --format esm --target node --splitting --chunk-naming=shared/[hash].js --external postgres --external @electric-sql/pglite --external pg --external bun && bunx tsc -p tsconfig.build.json && bun ./scripts/write-bin-wrappers.ts",
+    "build": "rm -rf dist && bun build ./src/contracts/index.ts ./src/contracts/internal.ts ./src/dialects/pg/index.ts ./src/runtime/pg/postgresjs.ts ./src/runtime/pg/pglite.ts ./src/runtime/pg/pg.ts ./src/runtime/pg/bun.ts ./src/runtime/ids/index.ts ./src/runtime/safety/index.ts ./src/runtime/traits/index.ts ./src/runtime/tenancy/index.ts ./src/runtime/validate/index.ts ./src/dialects/pg/ext/index.ts ./src/dialects/pg/fn/index.ts ./src/dialects/pg/view/index.ts ./src/dialects/pg/ext/citext.ts ./src/dialects/pg/ext/pg-trgm.ts ./src/tooling/migrate/index.ts ./src/tooling/testing/index.ts ./src/tooling/cli.ts --outdir ./dist --root ./src --format esm --target node --splitting --chunk-naming=shared/[hash].js --external postgres --external @electric-sql/pglite --external pg --external bun && bunx tsc -p tsconfig.build.json && bun ./scripts/write-bin-wrappers.ts",
     "driver-bench": "bun ./scripts/driver-bench.ts",
     "typecheck": "bunx tsc --noEmit -p tsconfig.json",
     "editor-check": "bun ./scripts/editor-check.ts",