turbine-orm 0.49.0 → 0.50.0

package/dist/cjs/schema-sql.js

@@ -75,14 +75,23 @@ function generateCreateEnumType(enumName, labels, dialect) {
 /**
  * Resolve the DDL type token for a column: an enum type name, a `vector(n)`
  * literal, or the dialect's scalar type — with a trailing `[]` for arrays.
+ *
+ * `vectorDimensions` is the one number interpolated into the type token, so it
+ * is validated here as a positive integer within pgvector's limit rather than
+ * being trusted to be numeric.
  */
-function resolveDdlType(config, dialect) {
+function resolveDdlType(config, dialect, columnName) {
     let base;
     if (config.enumName) {
         base = dialect.quoteIdentifier(config.enumName);
     }
     else if (config.vectorDimensions != null) {
-        base = `vector(${config.vectorDimensions})`;
+        const dims = config.vectorDimensions;
+        // pgvector caps a `vector` column at 16000 dimensions.
+        if (typeof dims !== 'number' || !Number.isInteger(dims) || dims < 1 || dims > 16000) {
+            throw new errors_js_1.ValidationError(`[turbine] Column "${columnName}": vector dimensions must be an integer between 1 and 16000, got ${String(dims)}.`);
+        }
+        base = `vector(${dims})`;
     }
     else {
         base = dialect.buildColumnType({ type: config.type, maxLength: config.maxLength });
@@ -241,6 +250,9 @@ function generateCreateTable(table, resolveRef, dialect = dialect_js_1.postgresD
         columnDefs.push(dialect.buildPrimaryKeyConstraint(cols));
     }
     // Table-level CHECK constraints (named → CONSTRAINT "name" CHECK (...)).
+    // The constraint NAME is quoted; the EXPRESSION is raw SQL emitted verbatim
+    // by design (see the CheckSpec.expression contract) and must never be built
+    // from untrusted input.
     for (const chk of table.checks ?? []) {
         columnDefs.push(chk.name
             ? `CONSTRAINT ${dialect.quoteIdentifier(chk.name)} CHECK (${chk.expression})`
@@ -287,7 +299,7 @@ function generateColumnDef(fieldName, config, resolveRef, dialect = dialect_js_1
     // Resolve the DDL type (enum name / vector(n) / scalar, plus [] for arrays).
     // Passed as a fully-formed `type` token with no maxLength so the dialect
     // doesn't re-apply VARCHAR(n) on top of it.
-    const ddlType = resolveDdlType(config, dialect);
+    const ddlType = resolveDdlType(config, dialect, snakeName);
     let def = dialect.buildColumnDefinition({
         name: dialect.quoteIdentifier(snakeName),
         type: ddlType,
@@ -306,7 +318,9 @@ function generateColumnDef(fieldName, config, resolveRef, dialect = dialect_js_1
         if (config.onUpdate)
             def += ` ON UPDATE ${referentialActionToSql(config.onUpdate)}`;
     }
-    // Column-level CHECK constraint (raw SQL expression, user-authored).
+    // Column-level CHECK constraint. The expression is RAW SQL authored in the
+    // schema and is emitted verbatim by design (a DDL builder cannot parse or
+    // parameterize a boolean expression); never build it from untrusted input.
     if (config.check) {
         def += ` CHECK (${config.check})`;
     }
@@ -547,6 +561,8 @@ function diffCheckConstraints(table, schemaChecks, dbChecks, dialect = dialect_j
     const dbByName = new Map(dbChecks.map((c) => [c.name, c]));
     const schemaByName = new Map(schemaChecks.map((c) => [c.name, c]));
     const norm = (e) => e.replace(/\s+/g, ' ').trim();
+    // `c.expression` is raw SQL emitted verbatim by design (see CheckSpec):
+    // schema-authored only, never untrusted input.
     const addStmt = (c) => `ALTER TABLE ${q(table)} ADD CONSTRAINT ${q(c.name)} CHECK (${c.expression});`;
     const dropStmt = (name) => `ALTER TABLE ${q(table)} DROP CONSTRAINT ${q(name)};`;
     for (const sc of schemaChecks) {
@@ -759,7 +775,7 @@ async function schemaDiff(schema, connectionString) {
                 if (expectedUdt && !isSerialType(config.type) && dbCol.udtName !== expectedUdt) {
                     // resolveDdlType handles enum names, vector(n), arrays, and VARCHAR(n) —
                     // config.type alone would emit the internal ENUM/VECTOR sentinels here.
-                    const sqlType = resolveDdlType(config, dialect);
+                    const sqlType = resolveDdlType(config, dialect, snakeName);
                     const oldSqlType = udtToSqlType(dbCol.udtName, dbCol.maxLength);
                     const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} TYPE ${sqlType} USING ${dialect.quoteIdentifier(snakeName)}::${sqlType};`;
                     const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} TYPE ${oldSqlType} USING ${dialect.quoteIdentifier(snakeName)}::${oldSqlType};`;
@@ -897,6 +913,8 @@ async function schemaDiff(schema, connectionString) {
             const normExpr = (e) => e.replace(/\s+/g, ' ').trim();
             for (const sc of namedSchemaChecks) {
                 const existing = dbCheckByName.get(sc.name);
+                // The constraint name is quoted; `sc.expression` is raw SQL emitted
+                // verbatim by design (see CheckSpec) and must be schema-authored.
                 const addSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ADD CONSTRAINT ${dialect.quoteIdentifier(sc.name)} CHECK (${sc.expression});`;
                 const dropSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} DROP CONSTRAINT ${dialect.quoteIdentifier(sc.name)};`;
                 if (!existing) {

package/dist/cjs/schema.d.ts

@@ -0,0 +1,356 @@
+/**
+ * turbine-orm — Schema metadata types
+ *
+ * These types represent the introspected database schema at runtime.
+ * They're used by the query builder, code generator, and CLI.
+ */
+export interface SchemaMetadata {
+    /** All discovered tables, keyed by table name */
+    tables: Record<string, TableMetadata>;
+    /** Database-level enums (typname → labels) */
+    enums: Record<string, string[]>;
+}
+export interface TableMetadata {
+    /** Table name in the database (snake_case) */
+    name: string;
+    /** All columns in ordinal order */
+    columns: ColumnMetadata[];
+    /** camelCase field name → snake_case column name */
+    columnMap: Record<string, string>;
+    /** snake_case column name → camelCase field name */
+    reverseColumnMap: Record<string, string>;
+    /** snake_case columns that are timestamp/date types (need Date parsing) */
+    dateColumns: Set<string>;
+    /** snake_case column → dialect-native database type. */
+    dialectTypes?: Record<string, string>;
+    /** snake_case column → Postgres type for UNNEST casts. Back-compat alias for dialectTypes. */
+    pgTypes: Record<string, string>;
+    /** All snake_case column names in ordinal order */
+    allColumns: string[];
+    /** Primary key column(s) in snake_case */
+    primaryKey: string[];
+    /** Unique constraint columns */
+    uniqueColumns: string[][];
+    /** Relations defined on this table */
+    relations: Record<string, RelationDef>;
+    /** Indexes on this table */
+    indexes: IndexMetadata[];
+    /**
+     * Named `CHECK` constraints on this table (introspected from
+     * `pg_constraint` where `contype = 'c'`, excluding NOT NULL artifacts).
+     * Optional / defaults to `[]` for back-compat.
+     */
+    checks?: readonly CheckMetadata[];
+    /**
+     * True when this metadata entry describes a database **view** or
+     * **materialized view** rather than a base table (introspected with the
+     * `includeViews` option). Views are read-only: every write builder
+     * (`create`/`update`/`upsert`/`delete` + their `*Many` forms) throws a
+     * `ValidationError` (E003). A view without a primary key is additionally
+     * excluded from the `findUnique`-family generated accessor types.
+     * Optional / defaults to `false` for back-compat.
+     */
+    isView?: boolean;
+}
+export interface CheckMetadata {
+    /** Constraint name (system-generated or user-supplied). */
+    name: string;
+    /** The check expression source (`pg_get_constraintdef` inner text). */
+    expression: string;
+}
+export interface ColumnMetadata {
+    /** snake_case column name */
+    name: string;
+    /** camelCase field name for TypeScript */
+    field: string;
+    /** Dialect-native database type (e.g. PostgreSQL 'int8', MySQL 'bigint', SQLite 'INTEGER'). */
+    dialectType?: string;
+    /** Postgres base type (e.g. 'int8', 'text', 'timestamptz'). Back-compat alias for dialectType. */
+    pgType: string;
+    /**
+     * Schema the column's Postgres type lives in, recorded by introspection
+     * ONLY when it differs from the introspected schema (and isn't a
+     * `pg_catalog` builtin) — e.g. an enum or domain owned by another schema.
+     * Consumers use it as a cross-schema guard: a same-named enum in another
+     * schema must not receive this schema's `::"enum"` cast (search_path would
+     * resolve it to the wrong type). Absent for same-schema types, builtins,
+     * `defineSchema()` output, and legacy generated metadata.
+     */
+    pgTypeSchema?: string;
+    /** TypeScript type string (e.g. 'number', 'string', 'Date') */
+    tsType: string;
+    /** Whether the column allows NULL */
+    nullable: boolean;
+    /** Whether the column has a DEFAULT, is serial, or is generated */
+    hasDefault: boolean;
+    /**
+     * Whether the **database server** generates this column's value on insert —
+     * a `serial`/`BIGSERIAL` sequence, an `IDENTITY` column, or PowDB's `auto`
+     * modifier. This is a strict subset of {@link hasDefault} (a server-generated
+     * column always reports `hasDefault: true`), but unlike a client-side default
+     * expression (`gen_random_uuid()`, `now()`) the value is assigned by the
+     * engine, so Turbine must NOT synthesize one client-side and the PowDB DDL
+     * emits the `auto` modifier. Optional / defaults to `false` for back-compat.
+     */
+    isGenerated?: boolean;
+    /**
+     * True when this is a Postgres **`GENERATED ALWAYS AS (expr) STORED`** column
+     * (`information_schema.columns.is_generated = 'ALWAYS'`). Distinct from
+     * {@link isGenerated} — which flags a server-*assigned* identity/serial value
+     * that a client MAY still override — a STORED generated column's value is
+     * *computed from other columns* and can NEVER be supplied on insert/update
+     * (Postgres rejects it). Codegen therefore omits it from `*Create`/`*Update`
+     * input types, and the write builders reject any `data` containing it with a
+     * {@link ValidationError} (E003). Optional / defaults to `false`.
+     */
+    isGeneratedStored?: boolean;
+    /**
+     * The generation expression for a {@link isGeneratedStored} column
+     * (`information_schema.columns.generation_expression`), e.g. `price * qty`.
+     * Present only when `isGeneratedStored` is true and the catalog exposed it.
+     */
+    generationExpression?: string;
+    /**
+     * True when this column holds personally identifiable information (PII).
+     * Tagged in `defineSchema` (`pii: true`) and carried through generated
+     * metadata. A PII column is EXCLUDED from default projections: it comes back
+     * only when explicitly named in `select` or when the query passes
+     * `includePii: true` (full opt-in). Studio redacts PII cells by default.
+     * Optional / defaults to `false`; untagged schemas behave exactly as before.
+     * Introspection never auto-tags PII (it is a code-first declaration).
+     */
+    pii?: boolean;
+    /** Whether this is an array column */
+    isArray: boolean;
+    /** Dialect-specific array/bulk-insert type token when needed. */
+    arrayType?: string;
+    /** Postgres array type for UNNEST (e.g. 'bigint[]'). Back-compat alias for arrayType. */
+    pgArrayType: string;
+    /** Max character length (for varchar) */
+    maxLength?: number;
+}
+/**
+ * PostgreSQL referential action for a foreign key's `ON DELETE` / `ON UPDATE`
+ * clause. `'no action'` is the implicit default (matches Postgres) and is
+ * omitted from emitted DDL.
+ */
+export type ReferentialAction = 'cascade' | 'restrict' | 'set null' | 'set default' | 'no action';
+export interface RelationDef {
+    type: 'hasMany' | 'hasOne' | 'belongsTo' | 'manyToMany';
+    /**
+     * FK `ON DELETE` action (introspected from `pg_constraint.confdeltype`).
+     * Present on `belongsTo`/`hasMany` relations derived from a real FK; omitted
+     * when unknown (e.g. `defineSchema`-only metadata) or `'no action'`.
+     */
+    onDelete?: ReferentialAction;
+    /** FK `ON UPDATE` action (introspected from `pg_constraint.confupdtype`). */
+    onUpdate?: ReferentialAction;
+    /** Relation name (camelCase, used as the field name) */
+    name: string;
+    /** Source table */
+    from: string;
+    /** Target table */
+    to: string;
+    /** FK column(s) on the "many" / "child" side (snake_case). Array for composite FKs. */
+    foreignKey: string | string[];
+    /** Referenced column(s) on the "one" / "parent" side (snake_case). Array for composite FKs. */
+    referenceKey: string | string[];
+    /**
+     * For `manyToMany` relations only: the junction (join) table that links the
+     * source and target tables. The subquery JOINs the target through this table.
+     *
+     *   - `table`     — junction table name (snake_case).
+     *   - `sourceKey` — junction column(s) referencing the SOURCE table's
+     *                   {@link referenceKey} (typically the source PK).
+     *   - `targetKey` — junction column(s) referencing the TARGET table's PK.
+     *
+     * Array forms support composite keys (paired positionally with the
+     * referenced columns). Omitted for non-m2m relations.
+     */
+    through?: {
+        table: string;
+        sourceKey: string | string[];
+        targetKey: string | string[];
+    };
+}
+/** Normalize foreignKey/referenceKey to always be an array for uniform processing */
+export declare function normalizeKeyColumns(key: string | string[]): string[];
+export interface IndexMetadata {
+    name: string;
+    columns: string[];
+    unique: boolean;
+    definition: string;
+    /**
+     * True when the index carries a top-level `WHERE` predicate (a Postgres
+     * PARTIAL index). A partial UNIQUE index only guarantees uniqueness over the
+     * rows matching its predicate, NOT over the whole table, so it must be
+     * EXCLUDED from compound-unique selector derivation (both the runtime
+     * `where` expansion and the generated `*WhereUnique` selector branches):
+     * addressing a row by it could match zero or many rows. Introspection sets
+     * it from the `indexdef`; absent / `false` means a full (table-wide) index.
+     */
+    partial?: boolean;
+    /**
+     * Set only for a PowDB doc-field expression index: the JSON path (string keys
+     * and integer array indexes) into the single json document column named by
+     * `columns[0]`. When present, `columns` is `[<json column>]` and the index
+     * targets `columns[0]-><segments>` rather than the raw column.
+     *
+     * Consumed by the PowDB DDL generator (`powqlSchemaDDL` emits
+     * `alter T add index (.col->"seg")`). The missing-FK index advisor ignores
+     * doc-field indexes entirely (a JSON expression index never covers an
+     * equality probe on the raw column). Doc-field indexes are invisible to
+     * `describe`-based introspection, so they do NOT round-trip through
+     * introspection.
+     */
+    docPath?: (string | number)[];
+    /**
+     * Set for indexes DECLARED in a code-first `defineSchema` (`TableDef.indexes`)
+     * rather than read from a live database by introspection. The SQL DDL
+     * generators (`schema-sql.ts` / `schemaDiff`) do NOT emit these yet, so a
+     * declared index does not reflect a real database index on the SQL engines.
+     * The missing-FK index advisor therefore treats declared indexes as
+     * "index-info unknown" (same as an index-less schema): counting them would
+     * both arm blanket FK false positives and suppress warnings for indexes that
+     * were never created. Introspected metadata never sets this.
+     */
+    declared?: boolean;
+}
+/** Map a Postgres type to its TypeScript equivalent */
+export declare function pgTypeToTs(pgType: string, nullable: boolean): string;
+/** Check if a Postgres type is a date/timestamp that needs Date parsing */
+export declare function isDateType(pgType: string): boolean;
+/**
+ * Classify a column type as a TIME-OF-DAY type (`time` / `timetz`), or `null`
+ * for anything else.
+ *
+ * These are deliberately NOT part of {@link isDateType}/`dateColumns`: a
+ * time-of-day value has no date part, so it is never coerced to a JS `Date` on
+ * read (Postgres hands back `09:00:00` and that is what the row carries). They
+ * still need their own classification on the WRITE path, because a JS `Date`
+ * bound straight through serializes as a full ISO timestamp
+ * (`1970-01-01T04:00:00.000-05:00`), which Postgres rejects for a `time`
+ * column with `22007 invalid input syntax for type time`.
+ *
+ * Recognizes the `udt_name` spellings introspection records (`time`, `timetz`),
+ * the SQL-standard long spellings, and a trailing precision suffix
+ * (`time(6)`), so MySQL and SQL Server `TIME` columns classify from their
+ * dialect type as well.
+ */
+export declare function timeOfDayKind(dbType: string | undefined): 'time' | 'timetz' | null;
+/**
+ * Classify a column type as a ZONE-LESS date/timestamp type (`date`,
+ * `timestamp` = `timestamp without time zone`), or `null` for anything else.
+ *
+ * `timestamptz` is deliberately excluded: it carries a real instant, and the
+ * driver's local-offset serialization is CORRECT for it (Postgres converts the
+ * offset away). The two types here store the literal wall-clock fields they
+ * are given, so binding a JS `Date` through the driver stores the process's
+ * LOCAL calendar fields — in `America/Los_Angeles`, `2026-07-25T00:00:00Z`
+ * lands as `2026-07-24 17:00:00`. The read path already interprets an
+ * offset-less value as UTC (see `parseDbDate`), so the write path has to bind
+ * the UTC components for the round trip to be stable.
+ *
+ * Recognizes the `udt_name` spellings introspection records, the SQL-standard
+ * long spellings, and a trailing precision suffix (`timestamp(3)`).
+ * Deliberately does NOT recognize `datetime`: MySQL's `TIMESTAMP`/`DATETIME`
+ * are converted by the session time zone, so a UTC-component literal would be
+ * misread there. The callers additionally gate on the PostgreSQL dialect.
+ */
+export declare function localDateTimeKind(dbType: string | undefined): 'date' | 'timestamp' | null;
+/** Get the Postgres array cast type for UNNEST batch inserts */
+export declare function pgArrayType(pgType: string): string;
+/** snake_case → camelCase */
+export declare function snakeToCamel(s: string): string;
+/** camelCase → snake_case */
+export declare function camelToSnake(s: string): string;
+/** snake_case → PascalCase (for type names) */
+export declare function snakeToPascal(s: string): string;
+/** Naive singularize: "posts" → "post", "categories" → "category" */
+export declare function singularize(s: string): string;
+/**
+ * Return a copy of `schema` in which every column's TypeScript **field** name is
+ * the raw database column name (snake_case) instead of the camelCased default,
+ * i.e. `user_id` stays `user_id` rather than becoming `userId`.
+ *
+ * This is a PURE, generate-time transform with ZERO runtime changes: it only
+ * rewrites `column.field` and rebuilds each table's `columnMap` /
+ * `reverseColumnMap` as IDENTITY maps (`user_id → user_id`). Because every
+ * runtime surface resolves column names through those maps (`toColumn`,
+ * `parseRow`, relation `json_build_object` keys, batched-loader stitching,
+ * positional decoding, aggregate/groupBy naming), the generated client returns
+ * rows keyed by DB column names and accepts DB column names in
+ * `where`/`orderBy`/`select` with no code path aware of the difference.
+ *
+ * Deliberately left untouched (the flag is literally about column names):
+ *   - `name`, `allColumns`, `dateColumns`, `dialectTypes`, `pgTypes`,
+ *     `primaryKey`, `uniqueColumns`, `indexes`, `checks`, `isView` (all already
+ *     keyed by snake_case column names);
+ *   - `relations` (relation PROPERTY names are synthetic introspection names
+ *     with no DB column equivalent, and `foreignKey`/`referenceKey`/`through`
+ *     already hold DB column names);
+ *   - entity type names, table accessors, and `enums`.
+ *
+ * Every non-PII field of each {@link ColumnMetadata} (`pii`, `pgType`,
+ * `dialectType`, `nullable`, …) is preserved. Exported from the package root so
+ * runtime-introspection and serverless users can apply the same identity mapping
+ * to a schema they build at runtime, e.g. `turbineHttp(pool,
+ * withDbFieldNames(schema))`.
+ */
+export declare function withDbFieldNames(schema: SchemaMetadata): SchemaMetadata;
+/**
+ * A typed name map from a Prisma schema onto a Turbine client, produced by
+ * `turbine migrate-from-prisma` (`generatePrismaMap` writes it as a
+ * `prisma-map.ts` module next to the generated client). It is library-side so
+ * the phase-2 `turbine-orm/prisma-compat` runtime adapter can consume the same
+ * shape to translate Prisma model/field/relation/compound-unique names onto the
+ * Turbine surface without re-parsing anything.
+ *
+ * Every name it carries was RESOLVED against live introspected metadata: a model
+ * or field that could not be matched is omitted from the map and listed in the
+ * migration report instead, so the map only ever contains verified mappings.
+ */
+export interface PrismaCompatMap {
+    /** Prisma model name → its resolved mapping. */
+    models: Record<string, PrismaModelMap>;
+    /** Prisma enum name → resolved database enum-type name. */
+    enums: Record<string, string>;
+}
+/** One Prisma model's resolved mapping onto a Turbine table + client accessor. */
+export interface PrismaModelMap {
+    /** Resolved snake_case database table name. */
+    table: string;
+    /** camelCase `TurbineClient` accessor (`db.<accessor>`). */
+    accessor: string;
+    /** Prisma field name → Turbine field name (camelCase). Relation fields excluded. */
+    fields: Record<string, string>;
+    /** Prisma relation-field name → resolved Turbine relation + cardinality. */
+    relations: Record<string, PrismaRelationMap>;
+    /**
+     * Prisma compound-unique/compound-id selector name → the Turbine field names
+     * (in declared order). The selector name is Prisma's: the explicit
+     * `@@unique(name:)` / `@@id(name:)` argument, else the field names joined with
+     * `_`. Consumed by the phase-2 client to translate
+     * `where: { <selector>: { ... } }`, including custom `@@unique(name:)` names
+     * the core `findUnique`-family derivation cannot know.
+     */
+    compoundUniques: Record<string, string[]>;
+    /**
+     * Prisma CLIENT-side default per Prisma field name. Prisma's
+     * `@default(uuid())` / `@default(cuid())` / `@updatedAt` (and `@default(now())`
+     * when the migration left no database default) are filled by the Prisma
+     * client, not the database, so the columns commonly have NO db default and a
+     * Prisma call site omits them. The compat adapter fills these on create
+     * (`uuid` / `cuid` / `now`) and touches `updatedAt` fields on
+     * update/updateMany/upsert, exactly like Prisma. Emitted by
+     * `migrate-from-prisma` only for columns the database does not default.
+     */
+    clientDefaults?: Record<string, 'uuid' | 'cuid' | 'now' | 'updatedAt'>;
+}
+/** A resolved Prisma relation field → Turbine relation. */
+export interface PrismaRelationMap {
+    /** Turbine relation name (the `with` clause key). */
+    name: string;
+    /** `'one'` (to-one) or `'many'` (to-many, including m2m). */
+    cardinality: 'one' | 'many';
+}

package/dist/cjs/schema.js

@@ -9,6 +9,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeKeyColumns = normalizeKeyColumns;
 exports.pgTypeToTs = pgTypeToTs;
 exports.isDateType = isDateType;
+exports.timeOfDayKind = timeOfDayKind;
+exports.localDateTimeKind = localDateTimeKind;
 exports.pgArrayType = pgArrayType;
 exports.snakeToCamel = snakeToCamel;
 exports.camelToSnake = camelToSnake;
@@ -89,26 +91,81 @@ const PG_TO_TS = {
     vector: 'number[]',
 };
 const DATE_TYPES = new Set(['timestamptz', 'timestamp', 'date']);
+/**
+ * Postgres type → the array cast `createMany`'s `UNNEST(ARRAY[...]::<type>)`
+ * applies to that column's value list.
+ *
+ * Every entry must be present for a type that has NO assignment cast from
+ * `text`: the `text[]` fallback below then produces text-typed UNNEST output
+ * and Postgres refuses the insert with `42804 column "x" is of type <t> but
+ * expression is of type text`. `varchar` / `char` / `bpchar` deliberately keep
+ * the `text[]` cast — `text` assignment-casts to all three, and pinning them
+ * would change already-emitted SQL for no behavioral gain.
+ */
 const PG_TO_ARRAY = {
+    // Numeric
     int2: 'smallint[]',
     int4: 'integer[]',
     int8: 'bigint[]',
     float4: 'real[]',
     float8: 'double precision[]',
     numeric: 'numeric[]',
+    money: 'money[]',
+    oid: 'oid[]',
     bool: 'boolean[]',
+    // Character
     text: 'text[]',
     varchar: 'text[]',
     char: 'text[]',
     bpchar: 'text[]',
+    name: 'name[]',
+    citext: 'citext[]',
+    xml: 'xml[]',
     uuid: 'uuid[]',
+    // Date / time. `time` and `timetz` were missing, so a `createMany` on a
+    // time-of-day column cast its values `text[]` and failed 42804 even though
+    // the per-value narrowing produced a valid `'09:00:00'` literal.
     timestamptz: 'timestamptz[]',
     timestamp: 'timestamp[]',
     date: 'date[]',
+    time: 'time[]',
+    timetz: 'timetz[]',
+    interval: 'interval[]',
+    // JSON / binary
     json: 'json[]',
     jsonb: 'jsonb[]',
     bytea: 'bytea[]',
+    // Network
     inet: 'inet[]',
+    cidr: 'cidr[]',
+    macaddr: 'macaddr[]',
+    macaddr8: 'macaddr8[]',
+    // Geometric
+    point: 'point[]',
+    line: 'line[]',
+    lseg: 'lseg[]',
+    box: 'box[]',
+    path: 'path[]',
+    polygon: 'polygon[]',
+    circle: 'circle[]',
+    // Text search
+    tsvector: 'tsvector[]',
+    tsquery: 'tsquery[]',
+    // Ranges / multiranges
+    int4range: 'int4range[]',
+    int8range: 'int8range[]',
+    numrange: 'numrange[]',
+    tsrange: 'tsrange[]',
+    tstzrange: 'tstzrange[]',
+    daterange: 'daterange[]',
+    int4multirange: 'int4multirange[]',
+    int8multirange: 'int8multirange[]',
+    nummultirange: 'nummultirange[]',
+    tsmultirange: 'tsmultirange[]',
+    tstzmultirange: 'tstzmultirange[]',
+    datemultirange: 'datemultirange[]',
+    // pgvector
+    vector: 'vector[]',
 };
 /** Map a Postgres type to its TypeScript equivalent */
 function pgTypeToTs(pgType, nullable) {
@@ -125,6 +182,74 @@ function pgTypeToTs(pgType, nullable) {
 function isDateType(pgType) {
     return DATE_TYPES.has(pgType);
 }
+/**
+ * Classify a column type as a TIME-OF-DAY type (`time` / `timetz`), or `null`
+ * for anything else.
+ *
+ * These are deliberately NOT part of {@link isDateType}/`dateColumns`: a
+ * time-of-day value has no date part, so it is never coerced to a JS `Date` on
+ * read (Postgres hands back `09:00:00` and that is what the row carries). They
+ * still need their own classification on the WRITE path, because a JS `Date`
+ * bound straight through serializes as a full ISO timestamp
+ * (`1970-01-01T04:00:00.000-05:00`), which Postgres rejects for a `time`
+ * column with `22007 invalid input syntax for type time`.
+ *
+ * Recognizes the `udt_name` spellings introspection records (`time`, `timetz`),
+ * the SQL-standard long spellings, and a trailing precision suffix
+ * (`time(6)`), so MySQL and SQL Server `TIME` columns classify from their
+ * dialect type as well.
+ */
+function timeOfDayKind(dbType) {
+    if (!dbType)
+        return null;
+    const t = dbType
+        .trim()
+        .toLowerCase()
+        // Precision can sit at the end (`time(6)`) or mid-spelling
+        // (`time(6) with time zone`), so strip it wherever it appears.
+        .replace(/\s*\(\s*\d+\s*\)\s*/, ' ')
+        .trim();
+    if (t === 'time' || t === 'time without time zone')
+        return 'time';
+    if (t === 'timetz' || t === 'time with time zone')
+        return 'timetz';
+    return null;
+}
+/**
+ * Classify a column type as a ZONE-LESS date/timestamp type (`date`,
+ * `timestamp` = `timestamp without time zone`), or `null` for anything else.
+ *
+ * `timestamptz` is deliberately excluded: it carries a real instant, and the
+ * driver's local-offset serialization is CORRECT for it (Postgres converts the
+ * offset away). The two types here store the literal wall-clock fields they
+ * are given, so binding a JS `Date` through the driver stores the process's
+ * LOCAL calendar fields — in `America/Los_Angeles`, `2026-07-25T00:00:00Z`
+ * lands as `2026-07-24 17:00:00`. The read path already interprets an
+ * offset-less value as UTC (see `parseDbDate`), so the write path has to bind
+ * the UTC components for the round trip to be stable.
+ *
+ * Recognizes the `udt_name` spellings introspection records, the SQL-standard
+ * long spellings, and a trailing precision suffix (`timestamp(3)`).
+ * Deliberately does NOT recognize `datetime`: MySQL's `TIMESTAMP`/`DATETIME`
+ * are converted by the session time zone, so a UTC-component literal would be
+ * misread there. The callers additionally gate on the PostgreSQL dialect.
+ */
+function localDateTimeKind(dbType) {
+    if (!dbType)
+        return null;
+    const t = dbType
+        .trim()
+        .toLowerCase()
+        // Precision can sit at the end (`timestamp(3)`) or mid-spelling
+        // (`timestamp(3) without time zone`), so strip it wherever it appears.
+        .replace(/\s*\(\s*\d+\s*\)\s*/, ' ')
+        .trim();
+    if (t === 'date')
+        return 'date';
+    if (t === 'timestamp' || t === 'timestamp without time zone')
+        return 'timestamp';
+    return null;
+}
 /** Get the Postgres array cast type for UNNEST batch inserts */
 function pgArrayType(pgType) {
     return PG_TO_ARRAY[pgType] ?? 'text[]';

package/dist/cjs/seed.d.ts

@@ -0,0 +1,15 @@
+import { TurbineClient } from './client.js';
+export type SeedFunction = (db: TurbineClient) => Promise<void> | void;
+export type DefinedSeed = () => Promise<void>;
+/**
+ * Extract the filesystem path from a single V8 stack-trace line, regardless of
+ * whether the frame is a `file://` URL (ESM), a bare absolute path (CJS / tsx),
+ * or a wrapped `(… )` location. The trailing `:line:col` (and any surrounding
+ * parens) are peeled from the END so a Windows drive colon or a URL scheme colon
+ * inside the path never confuses the match. Non-file frames (`node:internal/…`,
+ * `<anonymous>`) return null.
+ *
+ * Exported for unit testing the frame parser in isolation.
+ */
+export declare function parseStackFramePath(line: string): string | null;
+export declare function defineSeed(fn: SeedFunction): DefinedSeed;