turbine-orm 0.12.0 → 0.13.1

package/dist/cli/migrate.js

@@ -16,27 +16,21 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from
 import { join } from 'node:path';
 import pg from 'pg';
 import { postgresql } from '../adapters/index.js';
+import { postgresDialect } from '../dialect.js';
 import { MigrationError } from '../errors.js';
-import { quoteIdent } from '../query/index.js';
 // ---------------------------------------------------------------------------
 // Tracking table management
 // ---------------------------------------------------------------------------
 const TRACKING_TABLE = '_turbine_migrations';
-const QUOTED_TRACKING_TABLE = quoteIdent(TRACKING_TABLE);
-const CREATE_TRACKING_TABLE = `
-  CREATE TABLE IF NOT EXISTS ${QUOTED_TRACKING_TABLE} (
-    id SERIAL PRIMARY KEY,
-    name TEXT NOT NULL UNIQUE,
-    checksum TEXT NOT NULL,
-    applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-  );
-`;
-async function ensureTrackingTable(client) {
-    await client.query(CREATE_TRACKING_TABLE);
+function quotedTrackingTable(dialect) {
+    return dialect.quoteIdentifier(TRACKING_TABLE);
+}
+async function ensureTrackingTable(client, dialect = postgresDialect) {
+    await client.query(dialect.buildMigrationTrackingTable(quotedTrackingTable(dialect)));
 }
-async function getAppliedMigrations(client) {
-    await ensureTrackingTable(client);
-    const result = await client.query(`SELECT id, name, applied_at, checksum FROM ${QUOTED_TRACKING_TABLE} ORDER BY id ASC`);
+async function getAppliedMigrations(client, dialect = postgresDialect) {
+    await ensureTrackingTable(client, dialect);
+    const result = await client.query(dialect.buildMigrationSelectApplied(quotedTrackingTable(dialect)));
     return result.rows;
 }
 // ---------------------------------------------------------------------------
@@ -248,8 +242,8 @@ async function releaseLock(client, lockId, adapter) {
  * Validate that applied migration files have not been modified or deleted since they were run.
  * Returns an array of mismatched migrations (empty if all are clean).
  */
-async function validateChecksums(client, migrationsDir) {
-    const applied = await getAppliedMigrations(client);
+async function validateChecksums(client, migrationsDir, dialect = postgresDialect) {
+    const applied = await getAppliedMigrations(client, dialect);
     const allFiles = listMigrationFiles(migrationsDir);
     const fileMap = new Map(allFiles.map((f) => [f.name, f]));
     const mismatches = [];
@@ -269,7 +263,7 @@ async function validateChecksums(client, migrationsDir) {
         if (currentHash !== migration.checksum) {
             // Auto-upgrade legacy djb2 checksums to SHA-256 without flagging as modified
             if (isLegacyChecksum(migration.checksum)) {
-                await client.query(`UPDATE ${QUOTED_TRACKING_TABLE} SET checksum = $1 WHERE name = $2`, [
+                await client.query(dialect.buildMigrationUpdateChecksum(quotedTrackingTable(dialect)), [
                     currentHash,
                     migration.name,
                 ]);
@@ -304,6 +298,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
     await client.connect();
     // Treat `force` as an alias for `allowDrift` for backwards compatibility.
     const allowDrift = options?.allowDrift === true || options?.force === true;
+    const dialect = options?.dialect ?? postgresDialect;
     try {
         // Derive an advisory lock ID per-database so concurrent migrations in
         // sibling databases on the same Postgres cluster do not contend.
@@ -317,7 +312,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
             throw new MigrationError('[turbine] Could not acquire migration lock — another migration is already running');
         }
         try {
-            await ensureTrackingTable(client);
+            await ensureTrackingTable(client, dialect);
             // Validate checksums of already-applied migrations.
             // Drift = an APPLIED migration's on-disk file has changed (or been deleted)
             // since it was run. Either situation means the database state and the
@@ -325,7 +320,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
             // Users can pass `allowDrift: true` (CLI: `--allow-drift`) to force past
             // the block when they are intentionally rewriting history.
             if (!allowDrift) {
-                const mismatches = await validateChecksums(client, migrationsDir);
+                const mismatches = await validateChecksums(client, migrationsDir, dialect);
                 if (mismatches.length > 0) {
                     const modified = mismatches.filter((m) => m.type === 'modified');
                     const missing = mismatches.filter((m) => m.type === 'missing');
@@ -349,7 +344,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
                     throw new MigrationError(lines.join('\n'));
                 }
             }
-            const applied = await getAppliedMigrations(client);
+            const applied = await getAppliedMigrations(client, dialect);
             const appliedNames = new Set(applied.map((m) => m.name));
             const allFiles = listMigrationFiles(migrationsDir);
             let pending = allFiles.filter((f) => !appliedNames.has(f.name));
@@ -369,7 +364,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
                 try {
                     await client.query('BEGIN');
                     await client.query(up);
-                    await client.query(`INSERT INTO ${QUOTED_TRACKING_TABLE} (name, checksum) VALUES ($1, $2) ON CONFLICT (name) DO NOTHING`, [file.name, hash]);
+                    await client.query(dialect.buildMigrationInsertApplied(quotedTrackingTable(dialect)), [file.name, hash]);
                     await client.query('COMMIT');
                     results.push(file);
                 }
@@ -402,6 +397,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
 export async function migrateDown(connectionString, migrationsDir, options) {
     const client = new pg.Client({ connectionString });
     await client.connect();
+    const dialect = options?.dialect ?? postgresDialect;
     try {
         // Derive a per-database advisory lock ID so concurrent migrations in
         // sibling databases on the same cluster do not contend.
@@ -413,8 +409,8 @@ export async function migrateDown(connectionString, migrationsDir, options) {
             throw new MigrationError('[turbine] Could not acquire migration lock — another migration is already running');
         }
         try {
-            await ensureTrackingTable(client);
-            const applied = await getAppliedMigrations(client);
+            await ensureTrackingTable(client, dialect);
+            const applied = await getAppliedMigrations(client, dialect);
             if (applied.length === 0) {
                 return { rolledBack: [], errors: [] };
             }
@@ -441,7 +437,7 @@ export async function migrateDown(connectionString, migrationsDir, options) {
                 try {
                     await client.query('BEGIN');
                     await client.query(down);
-                    await client.query(`DELETE FROM ${QUOTED_TRACKING_TABLE} WHERE name = $1`, [migration.name]);
+                    await client.query(dialect.buildMigrationDeleteApplied(quotedTrackingTable(dialect)), [migration.name]);
                     await client.query('COMMIT');
                     results.push(file);
                 }
@@ -466,12 +462,13 @@ export async function migrateDown(connectionString, migrationsDir, options) {
  * Get the status of all migrations (applied vs pending).
  * Includes checksum validation for applied migrations.
  */
-export async function migrateStatus(connectionString, migrationsDir) {
+export async function migrateStatus(connectionString, migrationsDir, options) {
     const client = new pg.Client({ connectionString });
     await client.connect();
+    const dialect = options?.dialect ?? postgresDialect;
     try {
-        await ensureTrackingTable(client);
-        const applied = await getAppliedMigrations(client);
+        await ensureTrackingTable(client, dialect);
+        const applied = await getAppliedMigrations(client, dialect);
         const appliedMap = new Map(applied.map((m) => [m.name, m]));
         const allFiles = listMigrationFiles(migrationsDir);
         return allFiles.map((file) => {

package/dist/dialect.d.ts

@@ -49,6 +49,43 @@ export interface UpsertStatementInput {
     /** Optional SQL-ready RETURNING selection. */
     returning?: string;
 }
+export interface ColumnTypeInput {
+    /** Schema-builder column type name (PostgreSQL-native in the root package). */
+    type: string;
+    /** Optional VARCHAR length. */
+    maxLength?: number | null;
+}
+export interface ColumnDefinitionInput extends ColumnTypeInput {
+    /** SQL-ready quoted column name. */
+    name: string;
+    /** Whether this column is a single-column primary key. */
+    primaryKey?: boolean;
+    /** Whether this column is unique. Ignored when primaryKey is true. */
+    unique?: boolean;
+    /** Whether this column is NOT NULL. */
+    notNull?: boolean;
+    /** SQL-ready default expression. */
+    defaultValue?: string;
+    /** SQL-ready REFERENCES clause without the leading REFERENCES keyword. */
+    references?: {
+        table: string;
+        column: string;
+    };
+}
+export interface CreateTableStatementInput {
+    /** SQL-ready quoted table name. */
+    table: string;
+    /** SQL-ready column and table constraints. */
+    definitions: string[];
+}
+export interface CreateIndexStatementInput {
+    /** SQL-ready quoted index name. */
+    name: string;
+    /** SQL-ready quoted table name. */
+    table: string;
+    /** SQL-ready quoted index columns. */
+    columns: string[];
+}
 export interface Dialect {
     /** Dialect identifier. */
     readonly name: DialectName;
@@ -92,6 +129,26 @@ export interface Dialect {
     typeToTypeScript(dialectType: string, nullable: boolean): string;
     /** Optional array-cast hook for bulk insert implementations. */
     arrayType?(baseType: string): string;
+    /** Map a schema-builder column type to dialect DDL. */
+    buildColumnType(input: ColumnTypeInput): string;
+    /** Build a column definition line for CREATE/ALTER TABLE. */
+    buildColumnDefinition(input: ColumnDefinitionInput): string;
+    /** Build a table-level PRIMARY KEY constraint. */
+    buildPrimaryKeyConstraint(columns: string[]): string;
+    /** Build a CREATE TABLE statement from SQL-ready definitions. */
+    buildCreateTableStatement(input: CreateTableStatementInput): string;
+    /** Build a CREATE INDEX statement. */
+    buildCreateIndexStatement(input: CreateIndexStatementInput): string;
+    /** Build the migration tracking table DDL. */
+    buildMigrationTrackingTable(table: string): string;
+    /** Build the query that reads applied migrations. */
+    buildMigrationSelectApplied(table: string): string;
+    /** Build the query that updates an applied migration checksum. */
+    buildMigrationUpdateChecksum(table: string): string;
+    /** Build the query that records an applied migration. */
+    buildMigrationInsertApplied(table: string): string;
+    /** Build the query that deletes a rolled-back migration record. */
+    buildMigrationDeleteApplied(table: string): string;
 }
 export interface DialectIntrospector {
     introspect(options: IntrospectOptions): Promise<SchemaMetadata>;

package/dist/dialect.js

@@ -5,6 +5,7 @@
  * PostgreSQL-native by default, but query generation now depends on this
  * contract for the SQL primitives that vary across MySQL and SQLite.
  */
+import { ValidationError } from './errors.js';
 /** PostgreSQL implementation of the dialect contract. */
 export const postgresDialect = {
     name: 'postgresql',
@@ -38,7 +39,7 @@ export const postgresDialect = {
     },
     buildBulkInsertStatement(input) {
         if (!input.columnArrayTypes || input.columnArrayTypes.length !== input.columns.length) {
-            throw new Error('PostgreSQL bulk insert requires one array type per column');
+            throw new ValidationError('PostgreSQL bulk insert requires one array type per column');
         }
         const columnArrays = input.columns.map((_, columnIndex) => input.rowValues.map((row) => row[columnIndex]));
         const unnestArgs = input.columns.map((_, i) => `${this.paramPlaceholder(i + 1)}::${input.columnArrayTypes[i]}`);
@@ -73,5 +74,57 @@ export const postgresDialect = {
         // This hook is the package boundary MySQL/SQLite implementations will fill.
         return 'unknown';
     },
+    buildColumnType(input) {
+        if (input.type === 'VARCHAR' && input.maxLength != null) {
+            return `VARCHAR(${input.maxLength})`;
+        }
+        return input.type;
+    },
+    buildColumnDefinition(input) {
+        const parts = [input.name, this.buildColumnType(input)];
+        if (input.primaryKey)
+            parts.push('PRIMARY KEY');
+        if (input.unique && !input.primaryKey)
+            parts.push('UNIQUE');
+        if (input.notNull)
+            parts.push('NOT NULL');
+        if (input.defaultValue != null)
+            parts.push(`DEFAULT ${input.defaultValue}`);
+        if (input.references)
+            parts.push(`REFERENCES ${input.references.table}(${input.references.column})`);
+        return parts.join(' ');
+    },
+    buildPrimaryKeyConstraint(columns) {
+        return `PRIMARY KEY (${columns.join(', ')})`;
+    },
+    buildCreateTableStatement(input) {
+        const body = input.definitions.map((d) => `    ${d}`).join(',\n');
+        return `CREATE TABLE ${input.table} (\n${body}\n);`;
+    },
+    buildCreateIndexStatement(input) {
+        return `CREATE INDEX ${input.name} ON ${input.table}(${input.columns.join(', ')});`;
+    },
+    buildMigrationTrackingTable(table) {
+        return `
+  CREATE TABLE IF NOT EXISTS ${table} (
+    id SERIAL PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    checksum TEXT NOT NULL,
+    applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+`;
+    },
+    buildMigrationSelectApplied(table) {
+        return `SELECT id, name, applied_at, checksum FROM ${table} ORDER BY id ASC`;
+    },
+    buildMigrationUpdateChecksum(table) {
+        return `UPDATE ${table} SET checksum = ${this.paramPlaceholder(1)} WHERE name = ${this.paramPlaceholder(2)}`;
+    },
+    buildMigrationInsertApplied(table) {
+        return `INSERT INTO ${table} (name, checksum) VALUES (${this.paramPlaceholder(1)}, ${this.paramPlaceholder(2)}) ON CONFLICT (name) DO NOTHING`;
+    },
+    buildMigrationDeleteApplied(table) {
+        return `DELETE FROM ${table} WHERE name = ${this.paramPlaceholder(1)}`;
+    },
 };
 //# sourceMappingURL=dialect.js.map

package/dist/index.d.ts

@@ -35,7 +35,7 @@
 export type { DatabaseAdapter, IntrospectionOverrides } from './adapters/index.js';
 export { alloydb, cockroachdb, postgresql, timescale, yugabytedb } from './adapters/index.js';
 export { type Middleware, type MiddlewareNext, type MiddlewareParams, type PgCompatPool, type PgCompatPoolClient, type PgCompatQueryResult, TransactionClient, type TransactionOptions, TurbineClient, type TurbineConfig, } from './client.js';
-export type { BuiltStatement, BulkInsertStatementInput, Dialect, DialectIntrospector, DialectMigrator, DialectName, InsertStatementInput, IntrospectOptions as DialectIntrospectOptions, UpsertStatementInput, } from './dialect.js';
+export type { BuiltStatement, BulkInsertStatementInput, ColumnDefinitionInput, ColumnTypeInput, CreateIndexStatementInput, CreateTableStatementInput, Dialect, DialectIntrospector, DialectMigrator, DialectName, InsertStatementInput, IntrospectOptions as DialectIntrospectOptions, UpsertStatementInput, } from './dialect.js';
 export { postgresDialect } from './dialect.js';
 export { CheckConstraintError, CircularRelationError, ConnectionError, DeadlockError, type ErrorMessageMode, ForeignKeyError, getErrorMessageMode, MigrationError, NotFoundError, NotNullViolationError, PipelineError, type PipelineResultSlot, RelationError, SerializationFailureError, setErrorMessageMode, TimeoutError, TurbineError, TurbineErrorCode, UniqueConstraintError, ValidationError, wrapPgError, } from './errors.js';
 export { type GenerateOptions, generate } from './generate.js';
@@ -45,6 +45,6 @@ export { type AggregateArgs, type AggregateResult, type ArrayFilter, type CountA
 export type { ColumnMetadata, IndexMetadata, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';
 export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
 export { ColumnBuilder, type ColumnConfig, type ColumnDef, type ColumnType, type ColumnTypeName, column, defineSchema, type SchemaDef, type TableDef, table, } from './schema-builder.js';
-export { type AlterColumnDef, type AlterDef, type DiffResult, type PushResult, schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';
+export { type AlterColumnDef, type AlterDef, type DiffResult, type PushResult, type SchemaSqlOptions, schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';
 export { type TurbineHttpOptions, turbineHttp } from './serverless.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/query/builder.d.ts

@@ -258,6 +258,11 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
      * @internal Exposed as package-private for testing via class access.
      */
     fingerprintWhere(where: Record<string, unknown>): string;
+    /**
+     * Produce a value-invariant fingerprint for array filters while preserving
+     * parameterless boolean operators that change SQL shape.
+     */
+    private fingerprintArrayFilter;
     /**
      * Fingerprint a relation filter sub-where for some/every/none.
      */

package/dist/query/builder.js

@@ -1535,8 +1535,7 @@ export class QueryInterface {
             }
             // Array filter
             if (typeof value === 'object' && !Array.isArray(value) && isArrayFilter(value)) {
-                const aKeys = Object.keys(value).sort();
-                parts.push(`${key}:arr(${aKeys.join(',')})`);
+                parts.push(`${key}:arr(${this.fingerprintArrayFilter(value)})`);
                 continue;
             }
             // Plain equality
@@ -1544,6 +1543,15 @@ export class QueryInterface {
         }
         return parts.join('&');
     }
+    /**
+     * Produce a value-invariant fingerprint for array filters while preserving
+     * parameterless boolean operators that change SQL shape.
+     */
+    fingerprintArrayFilter(filter) {
+        const keys = Object.keys(filter).sort();
+        const suffix = filter.isEmpty === undefined ? '' : `:empty=${filter.isEmpty ? 'true' : 'false'}`;
+        return `${keys.join(',')}${suffix}`;
+    }
     /**
      * Fingerprint a relation filter sub-where for some/every/none.
      */
@@ -2650,12 +2658,12 @@ export class QueryInterface {
             clauses.push(`${column} && ${this.p(params.length)}::${elementType}[]`);
         }
         if (filter.isEmpty === true) {
-            // array_length(column, 1) IS NULL
-            clauses.push(`array_length(${column}, 1) IS NULL`);
+            // Treat NULL and empty arrays as empty for Prisma-compatible ergonomics.
+            clauses.push(`COALESCE(cardinality(${column}), 0) = 0`);
         }
         else if (filter.isEmpty === false) {
-            // array_length(column, 1) IS NOT NULL
-            clauses.push(`array_length(${column}, 1) IS NOT NULL`);
+            // Require at least one element; excludes both NULL and ARRAY[] values.
+            clauses.push(`cardinality(${column}) > 0`);
         }
         return clauses;
     }

package/dist/query/index.d.ts

@@ -6,7 +6,7 @@
  * former monolithic `import { … } from './query.js'`.
  */
 export type { AggregateArgs, AggregateResult, ArrayFilter, CountArgs, CreateArgs, CreateManyArgs, DeleteArgs, DeleteManyArgs, FindManyArgs, FindManyStreamArgs, FindUniqueArgs, GroupByArgs, JsonFilter, OrderDirection, RelationDescriptor, RelationFilter, TypedWithClause, UpdateArgs, UpdateInput, UpdateManyArgs, UpdateOperatorInput, UpsertArgs, WhereClause, WhereOperator, WhereValue, WithClause, WithOptions, WithResult, } from './types.js';
-export type { BuiltStatement, BulkInsertStatementInput, Dialect, InsertStatementInput, UpsertStatementInput, } from '../dialect.js';
+export type { BuiltStatement, BulkInsertStatementInput, ColumnDefinitionInput, ColumnTypeInput, CreateIndexStatementInput, CreateTableStatementInput, Dialect, InsertStatementInput, UpsertStatementInput, } from '../dialect.js';
 export { postgresDialect } from '../dialect.js';
 export type { SqlCacheEntry } from './utils.js';
 export { buildCorrelation, escapeLike, escSingleQuote, fnv1a64Hex, LRUCache, OPERATOR_KEYS, quoteIdent, sqlToPreparedName, } from './utils.js';

package/dist/schema-sql.d.ts

@@ -4,14 +4,19 @@
  * Converts a SchemaDef (from defineSchema) into executable DDL statements.
  * Also provides diff and push commands for syncing schema to a live database.
  */
+import { type Dialect } from './dialect.js';
 import type { SchemaDef, TableDef } from './schema-builder.js';
+export interface SchemaSqlOptions {
+    /** SQL dialect used for DDL generation. Defaults to PostgreSQL. */
+    dialect?: Dialect;
+}
 /**
  * Convert a SchemaDef into an ordered array of SQL DDL statements.
  *
  * Returns CREATE TABLE statements (in dependency order based on references)
  * followed by CREATE INDEX statements for foreign key columns.
  */
-export declare function schemaToSQL(schema: SchemaDef): string[];
+export declare function schemaToSQL(schema: SchemaDef, options?: SchemaSqlOptions): string[];
 export interface AlterColumnDef {
     /** Column name in snake_case */
     column: string;
@@ -71,5 +76,5 @@ export declare function schemaPush(schema: SchemaDef, connectionString: string,
  * Generate the full DDL as a single formatted string.
  * Useful for printing or saving to a .sql file.
  */
-export declare function schemaToSQLString(schema: SchemaDef): string;
+export declare function schemaToSQLString(schema: SchemaDef, options?: SchemaSqlOptions): string;
 //# sourceMappingURL=schema-sql.d.ts.map