uql-orm 0.21.0 → 0.22.0

package/dist/migrate/builder/migrationBuilder.js

@@ -5,14 +5,41 @@
  * - OperationRecorder: Record operations only (for code generation)
  * - MigrationBuilder: Execute DDL operations (for integration tests/runtime)
  */
+import { normalizeIndexColumn } from '../../util/index.js';
 import { createSchemaGenerator } from '../schemaGenerator.js';
-import { ColumnBuilder } from './columnBuilder.js';
-import { splitSqlStatementsOnSemicolons } from './splitSqlStatements.js';
+import { splitSqlStatements } from './splitSqlStatements.js';
 import { TableBuilder } from './tableBuilder.js';
 /**
  * Builder for altering a table.
  * Delegates to parent builder for operation recording.
  */
+/**
+ * One `createIndex` operation. Shared because the alter-table builder, the recorder and the
+ * executing builder all record the same thing, and an entry left unnormalized reaches the generator
+ * as a column literally named `[object Object]`.
+ */
+function createIndexOperation(tableName, columns, options = {}) {
+    const { name, unique, ...index } = options;
+    const entries = columns.map(normalizeIndexColumn);
+    return {
+        type: 'createIndex',
+        tableName,
+        index: {
+            ...index,
+            name: name ?? `idx_${tableName}_${entries.map((entry) => entry.column).join('_')}`,
+            columns: entries,
+            unique: unique ?? false,
+        },
+    };
+}
+/**
+ * Declare one column through the same vocabulary `createTable` uses. A throwaway {@link TableBuilder}
+ * is that vocabulary: `addColumn`/`alterColumn` used to take a bare {@link IColumnBuilder}, which
+ * cannot express a type, so every column they recorded was hard-coded `VARCHAR`.
+ */
+function buildOneColumn(callback) {
+    return callback(new TableBuilder('')).build();
+}
 class AlterTableBuilder {
     tableName;
     parentBuilder;
@@ -20,13 +47,11 @@ class AlterTableBuilder {
         this.tableName = tableName;
         this.parentBuilder = parentBuilder;
     }
-    addColumn(name, callback) {
-        const builder = new ColumnBuilder(name, { category: 'string' });
-        callback(builder);
+    addColumn(callback) {
         this.parentBuilder.recordOperationSync({
             type: 'addColumn',
             tableName: this.tableName,
-            column: builder.build(),
+            column: buildOneColumn(callback),
         });
         return this;
     }
@@ -47,28 +72,18 @@ class AlterTableBuilder {
         });
         return this;
     }
-    alterColumn(name, callback) {
-        const builder = new ColumnBuilder(name, { category: 'string' });
-        callback(builder);
+    alterColumn(callback) {
+        const column = buildOneColumn(callback);
         this.parentBuilder.recordOperationSync({
             type: 'alterColumn',
             tableName: this.tableName,
-            columnName: name,
-            changes: builder.build(),
+            columnName: column.name,
+            changes: column,
         });
         return this;
     }
     addIndex(columns, options) {
-        const indexName = options?.name ?? `idx_${this.tableName}_${columns.join('_')}`;
-        this.parentBuilder.recordOperationSync({
-            type: 'createIndex',
-            tableName: this.tableName,
-            index: {
-                name: indexName,
-                columns,
-                unique: options?.unique ?? false,
-            },
-        });
+        this.parentBuilder.recordOperationSync(createIndexOperation(this.tableName, columns, options));
         return this;
     }
     dropIndex(name) {
@@ -142,13 +157,11 @@ export class OperationRecorder {
     // ============================================================================
     // Column Operations
     // ============================================================================
-    async addColumn(tableName, columnName, callback) {
-        const builder = new ColumnBuilder(columnName, { category: 'string' });
-        callback(builder);
+    async addColumn(tableName, callback) {
         this.recordOperationSync({
             type: 'addColumn',
             tableName,
-            column: builder.build(),
+            column: buildOneColumn(callback),
         });
     }
     async dropColumn(tableName, columnName) {
@@ -158,14 +171,13 @@ export class OperationRecorder {
             columnName,
         });
     }
-    async alterColumn(tableName, columnName, callback) {
-        const builder = new ColumnBuilder(columnName, { category: 'string' });
-        callback(builder);
+    async alterColumn(tableName, callback) {
+        const column = buildOneColumn(callback);
         this.recordOperationSync({
             type: 'alterColumn',
             tableName,
-            columnName,
-            changes: builder.build(),
+            columnName: column.name,
+            changes: column,
         });
     }
     async renameColumn(tableName, oldName, newName) {
@@ -179,18 +191,8 @@ export class OperationRecorder {
     // ============================================================================
     // Index Operations
     // ============================================================================
-    async createIndex(tableName, columns, options = {}) {
-        const indexName = options.name ?? `idx_${tableName}_${columns.join('_')}`;
-        this.recordOperationSync({
-            type: 'createIndex',
-            tableName,
-            index: {
-                name: indexName,
-                columns,
-                unique: options.unique ?? false,
-                where: options.where,
-            },
-        });
+    async createIndex(tableName, columns, options) {
+        this.recordOperationSync(createIndexOperation(tableName, columns, options));
     }
     async dropIndex(tableName, indexName) {
         this.recordOperationSync({
@@ -260,10 +262,10 @@ export class OperationRecorder {
 export class MigrationBuilder extends OperationRecorder {
     querier;
     sqlGenerator;
-    constructor(querier, options = {}) {
+    constructor(querier) {
         super();
         this.querier = querier;
-        const generator = createSchemaGenerator(querier.dialect, options.namingStrategy);
+        const generator = createSchemaGenerator(querier.dialect);
         if (!generator) {
             throw new TypeError(`Could not find a schema generator for dialect: ${querier.dialect.dialectName}`);
         }
@@ -314,13 +316,11 @@ export class MigrationBuilder extends OperationRecorder {
         this.operations.push(operation);
         await this.execute(operation);
     }
-    async addColumn(tableName, columnName, callback) {
-        const builder = new ColumnBuilder(columnName, { category: 'string' });
-        callback(builder);
+    async addColumn(tableName, callback) {
         const operation = {
             type: 'addColumn',
             tableName,
-            column: builder.build(),
+            column: buildOneColumn(callback),
         };
         this.operations.push(operation);
         await this.execute(operation);
@@ -334,14 +334,13 @@ export class MigrationBuilder extends OperationRecorder {
         this.operations.push(operation);
         await this.execute(operation);
     }
-    async alterColumn(tableName, columnName, callback) {
-        const builder = new ColumnBuilder(columnName, { category: 'string' });
-        callback(builder);
+    async alterColumn(tableName, callback) {
+        const column = buildOneColumn(callback);
         const operation = {
             type: 'alterColumn',
             tableName,
-            columnName,
-            changes: builder.build(),
+            columnName: column.name,
+            changes: column,
         };
         this.operations.push(operation);
         await this.execute(operation);
@@ -356,18 +355,8 @@ export class MigrationBuilder extends OperationRecorder {
         this.operations.push(operation);
         await this.execute(operation);
     }
-    async createIndex(tableName, columns, options = {}) {
-        const indexName = options.name ?? `idx_${tableName}_${columns.join('_')}`;
-        const operation = {
-            type: 'createIndex',
-            tableName,
-            index: {
-                name: indexName,
-                columns,
-                unique: options.unique ?? false,
-                where: options.where,
-            },
-        };
+    async createIndex(tableName, columns, options) {
+        const operation = createIndexOperation(tableName, columns, options);
         this.operations.push(operation);
         await this.execute(operation);
     }
@@ -420,7 +409,7 @@ export class MigrationBuilder extends OperationRecorder {
         }
         const sql = this.operationToSql(operation);
         if (sql) {
-            for (const statement of splitSqlStatementsOnSemicolons(sql)) {
+            for (const statement of splitSqlStatements(sql)) {
                 await this.querier.run(statement);
             }
         }
@@ -431,7 +420,7 @@ export class MigrationBuilder extends OperationRecorder {
                 // One line per statement in preview; execute() runs each separately (#87).
                 return this.getCreateTableStatements(operation).join('\n');
             case 'dropTable':
-                return this.sqlGenerator.generateDropTableSql(operation.tableName, {
+                return this.sqlGenerator.generateDropTable(operation.tableName, {
                     ifExists: operation.ifExists,
                     cascade: operation.cascade,
                 });
@@ -446,9 +435,9 @@ export class MigrationBuilder extends OperationRecorder {
             case 'alterColumn':
                 return this.sqlGenerator.generateAlterColumnSql(operation.tableName, operation.columnName, operation.changes);
             case 'createIndex':
-                return this.sqlGenerator.generateCreateIndexSql(operation.tableName, operation.index);
+                return this.sqlGenerator.generateCreateIndex(operation.tableName, operation.index);
             case 'dropIndex':
-                return this.sqlGenerator.generateDropIndexSql(operation.tableName, operation.indexName);
+                return this.sqlGenerator.generateDropIndex(operation.tableName, operation.indexName);
             case 'addForeignKey':
                 return this.sqlGenerator.generateAddForeignKeySql(operation.tableName, operation.foreignKey);
             case 'dropForeignKey':
@@ -460,10 +449,3 @@ export class MigrationBuilder extends OperationRecorder {
         }
     }
 }
-/**
- * Create an operation recorder for dry-run (recording only).
- * @deprecated Use `new OperationRecorder()` directly
- */
-export function createDryRunBuilder() {
-    return new OperationRecorder();
-}

package/dist/migrate/builder/splitSqlStatements.d.ts

@@ -13,5 +13,3 @@
  * - Comments: -- and /* ... *\/
  */
 export declare function splitSqlStatements(sql: string): string[];
-/** Legacy alias kept for backward compatibility. */
-export declare const splitSqlStatementsOnSemicolons: typeof splitSqlStatements;

package/dist/migrate/builder/splitSqlStatements.js

@@ -39,5 +39,3 @@ export function splitSqlStatements(sql) {
     }
     return statements;
 }
-/** Legacy alias kept for backward compatibility. */
-export const splitSqlStatementsOnSemicolons = splitSqlStatements;

package/dist/migrate/builder/tableBuilder.d.ts

@@ -3,6 +3,7 @@
  *
  * Fluent API for defining tables in migrations.
  */
+import type { IndexColumnInput, IndexOptions } from '../../type/index.js';
 import type { BaseColumnOptions, DecimalColumnOptions, IColumnBuilder, ITableBuilder, ITableForeignKeyBuilder, StringColumnOptions, TableDefinition, VectorColumnOptions } from './types.js';
 /**
  * Builder for table definitions with a fluent API.
@@ -31,16 +32,25 @@ export declare class TableBuilder implements ITableBuilder {
     timestamp(name: string, options?: BaseColumnOptions): IColumnBuilder;
     timestamptz(name: string, options?: BaseColumnOptions): IColumnBuilder;
     json(name: string, options?: BaseColumnOptions): IColumnBuilder;
+    /** One canonical json category; the dialect decides between `JSON` and `JSONB`. */
     jsonb(name: string, options?: BaseColumnOptions): IColumnBuilder;
     uuid(name: string, options?: BaseColumnOptions): IColumnBuilder;
     blob(name: string, options?: BaseColumnOptions): IColumnBuilder;
     vector(name: string, options?: VectorColumnOptions): IColumnBuilder;
+    private add;
     createdAt(): IColumnBuilder;
     updatedAt(): IColumnBuilder;
     timestamps(): void;
     primaryKey(columns: string[]): this;
-    unique(columns: string[], name?: string): this;
-    index(columns: string[], name?: string): this;
+    unique(columns: readonly IndexColumnInput[], options?: string | IndexOptions): this;
+    index(columns: readonly IndexColumnInput[], options?: string | IndexOptions): this;
+    /**
+     * `@Index` and `table.index(...)` differ only in how the name is defaulted, so both normalize their
+     * entries here: the generator renders expressions and per-column modifiers from the normalized
+     * form, and anything left as a bare string would reach it as a column literally named `[object
+     * Object]`.
+     */
+    private addIndex;
     foreignKey(columns: string[]): ITableForeignKeyBuilder;
     comment(text: string): this;
     /**

package/dist/migrate/builder/tableBuilder.js

@@ -3,6 +3,7 @@
  *
  * Fluent API for defining tables in migrations.
  */
+import { normalizeIndexColumn } from '../../util/index.js';
 import { ColumnBuilder } from './columnBuilder.js';
 import { t } from './expressions.js';
 /**
@@ -68,137 +69,83 @@ export class TableBuilder {
     // Numeric Types
     // ============================================================================
     id(name = 'id', options = {}) {
-        const col = new ColumnBuilder(name, { category: 'integer' }, { ...options, primaryKey: true, autoIncrement: true });
-        this._columnBuilders.push(col);
-        return col;
-    }
-    integer(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'integer' }, options);
-        this._columnBuilders.push(col);
-        return col;
-    }
-    smallint(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'integer', size: 'small' }, options);
-        this._columnBuilders.push(col);
-        return col;
-    }
-    bigint(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'integer', size: 'big' }, options);
-        this._columnBuilders.push(col);
-        return col;
-    }
-    float(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'float' }, options);
-        this._columnBuilders.push(col);
-        return col;
-    }
-    double(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'float', size: 'big' }, options);
-        this._columnBuilders.push(col);
-        return col;
+        return this.add(name, { category: 'integer' }, { ...options, primaryKey: true, autoIncrement: true });
+    }
+    integer(name, options) {
+        return this.add(name, { category: 'integer' }, options);
+    }
+    smallint(name, options) {
+        return this.add(name, { category: 'integer', size: 'small' }, options);
+    }
+    bigint(name, options) {
+        return this.add(name, { category: 'integer', size: 'big' }, options);
+    }
+    float(name, options) {
+        return this.add(name, { category: 'float' }, options);
+    }
+    double(name, options) {
+        return this.add(name, { category: 'float', size: 'big' }, options);
     }
     decimal(name, options = {}) {
         const { precision, scale, ...rest } = options;
-        const col = new ColumnBuilder(name, { category: 'decimal', precision, scale }, rest);
-        this._columnBuilders.push(col);
-        return col;
+        return this.add(name, { category: 'decimal', precision, scale }, rest);
     }
-    // ============================================================================
-    // String Types
-    // ============================================================================
     string(name, options = {}) {
         const { length = 255, ...rest } = options;
-        const col = new ColumnBuilder(name, { category: 'string', length }, rest);
-        this._columnBuilders.push(col);
-        return col;
+        return this.add(name, { category: 'string', length }, rest);
     }
     char(name, options = {}) {
         const { length = 1, ...rest } = options;
-        const col = new ColumnBuilder(name, { category: 'string', length }, rest);
-        this._columnBuilders.push(col);
-        return col;
+        return this.add(name, { category: 'string', length }, rest);
     }
-    text(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'string' }, options);
-        this._columnBuilders.push(col);
-        return col;
+    text(name, options) {
+        return this.add(name, { category: 'string' }, options);
     }
-    // ============================================================================
-    // Boolean
-    // ============================================================================
-    boolean(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'boolean' }, options);
-        this._columnBuilders.push(col);
-        return col;
+    boolean(name, options) {
+        return this.add(name, { category: 'boolean' }, options);
     }
-    // ============================================================================
-    // Date/Time Types
-    // ============================================================================
-    date(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'date' }, options);
-        this._columnBuilders.push(col);
-        return col;
-    }
-    time(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'time' }, options);
-        this._columnBuilders.push(col);
-        return col;
-    }
-    timestamp(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'timestamp' }, options);
-        this._columnBuilders.push(col);
-        return col;
-    }
-    timestamptz(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'timestamp', withTimezone: true }, options);
-        this._columnBuilders.push(col);
-        return col;
+    date(name, options) {
+        return this.add(name, { category: 'date' }, options);
     }
-    // ============================================================================
-    // JSON Types
-    // ============================================================================
-    json(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'json' }, options);
-        this._columnBuilders.push(col);
-        return col;
+    time(name, options) {
+        return this.add(name, { category: 'time' }, options);
     }
-    jsonb(name, options = {}) {
-        // JSONB is the same category, dialect handles the difference
-        const col = new ColumnBuilder(name, { category: 'json' }, options);
-        this._columnBuilders.push(col);
-        return col;
+    timestamp(name, options) {
+        return this.add(name, { category: 'timestamp' }, options);
     }
-    // ============================================================================
-    // Other Types
-    // ============================================================================
-    uuid(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'uuid' }, options);
-        this._columnBuilders.push(col);
-        return col;
+    timestamptz(name, options) {
+        return this.add(name, { category: 'timestamp', withTimezone: true }, options);
+    }
+    json(name, options) {
+        return this.add(name, { category: 'json' }, options);
+    }
+    /** One canonical json category; the dialect decides between `JSON` and `JSONB`. */
+    jsonb(name, options) {
+        return this.add(name, { category: 'json' }, options);
+    }
+    uuid(name, options) {
+        return this.add(name, { category: 'uuid' }, options);
     }
-    blob(name, options = {}) {
-        const col = new ColumnBuilder(name, { category: 'blob' }, options);
-        this._columnBuilders.push(col);
-        return col;
+    blob(name, options) {
+        return this.add(name, { category: 'blob' }, options);
     }
     vector(name, options = {}) {
         const { dimensions, ...rest } = options;
-        const col = new ColumnBuilder(name, { category: 'vector', length: dimensions }, rest);
-        this._columnBuilders.push(col);
-        return col;
+        return this.add(name, { category: 'vector', length: dimensions }, rest);
+    }
+    add(name, type, options = {}) {
+        const column = new ColumnBuilder(name, type, options);
+        this._columnBuilders.push(column);
+        return column;
     }
     // ============================================================================
     // Convenience Methods
     // ============================================================================
     createdAt() {
-        const col = new ColumnBuilder('createdAt', { category: 'timestamp' }, { defaultValue: t.now() });
-        this._columnBuilders.push(col);
-        return col;
+        return this.add('createdAt', { category: 'timestamp' }, { defaultValue: t.now() });
     }
     updatedAt() {
-        const col = new ColumnBuilder('updatedAt', { category: 'timestamp' }, { defaultValue: t.now() });
-        this._columnBuilders.push(col);
-        return col;
+        return this.add('updatedAt', { category: 'timestamp' }, { defaultValue: t.now() });
     }
     timestamps() {
         this.createdAt();
@@ -211,21 +158,26 @@ export class TableBuilder {
         this._primaryKey = columns;
         return this;
     }
-    unique(columns, name) {
-        const indexName = name ?? `uq_${this._name}_${columns.join('_')}`;
-        this._indexes.push({
-            name: indexName,
-            columns,
-            unique: true,
-        });
-        return this;
+    unique(columns, options) {
+        return this.addIndex('uq', columns, options, true);
+    }
+    index(columns, options) {
+        return this.addIndex('idx', columns, options, false);
     }
-    index(columns, name) {
-        const indexName = name ?? `idx_${this._name}_${columns.join('_')}`;
+    /**
+     * `@Index` and `table.index(...)` differ only in how the name is defaulted, so both normalize their
+     * entries here: the generator renders expressions and per-column modifiers from the normalized
+     * form, and anything left as a bare string would reach it as a column literally named `[object
+     * Object]`.
+     */
+    addIndex(prefix, columns, options, unique) {
+        const { name, ...rest } = typeof options === 'string' ? { name: options } : (options ?? {});
+        const entries = columns.map(normalizeIndexColumn);
         this._indexes.push({
-            name: indexName,
-            columns,
-            unique: false,
+            ...rest,
+            name: name ?? `${prefix}_${this._name}_${entries.map((entry) => entry.column).join('_')}`,
+            columns: entries,
+            unique,
         });
         return this;
     }
@@ -255,7 +207,7 @@ export class TableBuilder {
                 if (!this._indexes.some((idx) => idx.name === indexName)) {
                     this._indexes.push({
                         name: indexName,
-                        columns: [col.name],
+                        columns: [{ column: col.name }],
                         unique: col.unique,
                     });
                 }