uql-orm 0.20.2 → 0.22.0

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

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

package/dist/migrate/builder/splitSqlStatements.js

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

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;
     /**
@@ -48,4 +58,3 @@ export declare class TableBuilder implements ITableBuilder {
      */
     build(): TableDefinition;
 }
-//# sourceMappingURL=tableBuilder.d.ts.map

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,
                     });
                 }
@@ -288,4 +240,3 @@ export class TableBuilder {
         };
     }
 }
-//# sourceMappingURL=tableBuilder.js.map

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

@@ -4,7 +4,8 @@
  * Type definitions for the fluent migration builder API.
  * Enables type-safe migrations without raw SQL.
  */
-import type { CanonicalType, ForeignKeyAction, IndexType } from '../../schema/types.js';
+import type { CanonicalType, ForeignKeyAction } from '../../schema/types.js';
+import type { IndexColumnInput, IndexOptions, IndexSchema } from '../../type/index.js';
 /**
  * Foreign key reference options.
  */
@@ -110,21 +111,6 @@ export interface FullColumnDefinition extends ColumnDefinition {
     /** Index name (if indexed) */
     index?: string | boolean;
 }
-/**
- * Index definition.
- */
-export interface IndexDefinition {
-    /** Index name */
-    name: string;
-    /** Column names */
-    columns: string[];
-    /** Whether unique */
-    unique: boolean;
-    /** Index type (btree, hash, etc.) */
-    type?: IndexType;
-    /** Partial index WHERE clause */
-    where?: string;
-}
 /**
  * Complete table definition.
  */
@@ -136,7 +122,7 @@ export interface TableDefinition {
     /** Primary key columns (for composite keys) */
     primaryKey?: string[];
     /** Index definitions */
-    indexes: IndexDefinition[];
+    indexes: IndexSchema[];
     /** Foreign key definitions at table level */
     foreignKeys: TableForeignKeyDefinition[];
     /** Table comment */
@@ -234,7 +220,7 @@ export interface RenameColumnOperation extends MigrationOperation {
 export interface CreateIndexOperation extends MigrationOperation {
     type: 'createIndex';
     tableName: string;
-    index: IndexDefinition;
+    index: IndexSchema;
     ifNotExists?: boolean;
 }
 /**
@@ -310,9 +296,13 @@ export interface IForeignKeyBuilder extends IColumnBuilder {
     onUpdate(action: ForeignKeyAction): this;
 }
 /**
- * Interface for table builder (fluent API).
+ * The column vocabulary: every column type the builder can declare, name first.
+ *
+ * Split out of {@link ITableBuilder} so `addColumn`/`alterColumn` can hand it to their callback. They
+ * used to take an {@link IColumnBuilder}, which has no way to say what type a column is - so the
+ * builder hard-coded `VARCHAR`, and every column a generated migration added or altered was a string.
  */
-export interface ITableBuilder {
+export interface IColumnFactory {
     /** Add an auto-incrementing primary key */
     id(name?: string, options?: BaseColumnOptions): IColumnBuilder;
     /** Add an integer column */
@@ -353,6 +343,11 @@ export interface ITableBuilder {
     blob(name: string, options?: BaseColumnOptions): IColumnBuilder;
     /** Add a vector column (for embeddings) */
     vector(name: string, options?: VectorColumnOptions): IColumnBuilder;
+}
+/**
+ * Interface for table builder (fluent API).
+ */
+export interface ITableBuilder extends IColumnFactory {
     /** Add createdAt timestamp column */
     createdAt(): IColumnBuilder;
     /** Add updatedAt timestamp column */
@@ -361,10 +356,10 @@ export interface ITableBuilder {
     timestamps(): void;
     /** Add composite primary key */
     primaryKey(columns: string[]): this;
-    /** Add composite unique constraint */
-    unique(columns: string[], name?: string): this;
-    /** Add composite index */
-    index(columns: string[], name?: string): this;
+    /** Add a composite unique index; takes the same options as `@Index`, or just its name. */
+    unique(columns: readonly IndexColumnInput[], options?: string | IndexOptions): this;
+    /** Add a composite index; takes the same options as `@Index`, or just its name. */
+    index(columns: readonly IndexColumnInput[], options?: string | IndexOptions): this;
     /** Add table-level foreign key */
     foreignKey(columns: string[]): ITableForeignKeyBuilder;
     /** Add a comment to the table */
@@ -389,19 +384,16 @@ export interface ITableForeignKeyBuilder {
  * Interface for altering a table.
  */
 export interface IAlterTableBuilder {
-    /** Add a column to the table */
-    addColumn(name: string, callback: (column: IColumnBuilder) => void): this;
+    /** Add a column, declared exactly as in `createTable`: `addColumn((c) => c.timestamp('createdAt'))`. */
+    addColumn(callback: (columns: IColumnFactory) => IColumnBuilder): this;
     /** Drop a column from the table */
     dropColumn(name: string): this;
     /** Rename a column */
     renameColumn(oldName: string, newName: string): this;
-    /** Alter a column definition */
-    alterColumn(name: string, callback: (column: IColumnBuilder) => void): this;
+    /** Redeclare a column, named and typed as it should end up. */
+    alterColumn(callback: (columns: IColumnFactory) => IColumnBuilder): this;
     /** Add an index to the table */
-    addIndex(columns: string[], options?: {
-        name?: string;
-        unique?: boolean;
-    }): this;
+    addIndex(columns: readonly IndexColumnInput[], options?: IndexOptions): this;
     /** Drop an index from the table */
     dropIndex(name: string): this;
     /** Add a foreign key to the table */
@@ -431,19 +423,16 @@ export interface IMigrationBuilder {
     renameTable(oldName: string, newName: string): Promise<void>;
     /** Alter an existing table */
     alterTable(name: string, callback: (table: IAlterTableBuilder) => void): Promise<void>;
-    /** Add a column to an existing table */
-    addColumn(tableName: string, columnName: string, callback: (column: IColumnBuilder) => void): Promise<void>;
+    /** Add a column, declared exactly as in `createTable`: `addColumn('t', (c) => c.timestamp('at'))`. */
+    addColumn(tableName: string, callback: (columns: IColumnFactory) => IColumnBuilder): Promise<void>;
     /** Drop a column from a table */
     dropColumn(tableName: string, columnName: string): Promise<void>;
-    /** Alter a column */
-    alterColumn(tableName: string, columnName: string, callback: (column: IColumnBuilder) => void): Promise<void>;
+    /** Redeclare a column, named and typed as it should end up. */
+    alterColumn(tableName: string, callback: (columns: IColumnFactory) => IColumnBuilder): Promise<void>;
     /** Rename a column */
     renameColumn(tableName: string, oldName: string, newName: string): Promise<void>;
-    /** Create an index */
-    createIndex(tableName: string, columns: string[], options?: {
-        name?: string;
-        unique?: boolean;
-    }): Promise<void>;
+    /** Create an index; takes the same options as `@Index`, so a generated migration can restate them. */
+    createIndex(tableName: string, columns: readonly IndexColumnInput[], options?: IndexOptions): Promise<void>;
     /** Drop an index */
     dropIndex(tableName: string, indexName: string): Promise<void>;
     /** Add a foreign key */
@@ -463,4 +452,3 @@ export interface IMigrationBuilder {
     /** Record an operation synchronously */
     recordOperationSync(operation: AnyMigrationOperation): void;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/migrate/builder/types.js

@@ -5,4 +5,3 @@
  * Enables type-safe migrations without raw SQL.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/migrate/cli-config.d.ts

@@ -1,3 +1,2 @@
 import type { Config } from '../type/index.js';
 export declare function loadConfig(customPath?: string): Promise<Config>;
-//# sourceMappingURL=cli-config.d.ts.map

package/dist/migrate/cli-config.js

@@ -1,8 +1,13 @@
 import { stat } from 'node:fs/promises';
 import { resolve } from 'node:path';
-import { createJiti } from 'jiti';
+/** `jiti` (1.8 MB) makes `uql.config.ts` loadable; imported here so only projects with one pay for it. */
+async function importConfig(path) {
+    const { createJiti } = await import('jiti').catch(() => {
+        throw new Error("Loading a uql config file requires 'jiti'. Run `npm i -D jiti`, or pass the config inline instead of via a config file.");
+    });
+    return createJiti(process.cwd()).import(path, { default: true });
+}
 export async function loadConfig(customPath) {
-    const jiti = createJiti(process.cwd());
     if (customPath) {
         const fullPath = resolve(process.cwd(), customPath);
         const exists = await stat(fullPath)
@@ -12,7 +17,7 @@ export async function loadConfig(customPath) {
             throw new Error(`Could not find uql configuration file at ${customPath}`);
         }
         try {
-            const config = await jiti.import(fullPath, { default: true });
+            const config = await importConfig(fullPath);
             return config;
         }
         catch (error) {
@@ -26,10 +31,9 @@ export async function loadConfig(customPath) {
             .then(() => true)
             .catch(() => false);
         if (exists) {
-            const config = await jiti.import(fullPath, { default: true });
+            const config = await importConfig(fullPath);
             return config;
         }
     }
     throw new Error('Could not find uql configuration file. Create a uql.config.ts or uql.config.js file in your project root.');
 }
-//# sourceMappingURL=cli-config.js.map

package/dist/migrate/cli.d.ts

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import type { AbstractDialect } from '../dialect/index.js';
-import type { Config, NamingStrategy } from '../type/index.js';
+import type { ForeignKeyAction } from '../schema/types.js';
+import type { Config } from '../type/index.js';
 import { Migrator } from './migrator.js';
 import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
 /** Sync helper for SQL dialects only; returns `undefined` for MongoDB - use {@link createSchemaGeneratorAsync}. */
-export declare function getSchemaGenerator(dialect: AbstractDialect, namingStrategy?: NamingStrategy): import("../type/migration.js").SchemaGenerator | undefined;
+export declare function getSchemaGenerator(dialect: AbstractDialect, defaultForeignKeyAction?: ForeignKeyAction): import("./schemaGenerator.js").SqlSchemaGenerator | undefined;
 export { createSchemaGeneratorAsync };
 export declare function main(args?: string[]): Promise<void>;
 export declare function runUp(migrator: Migrator, args: string[]): Promise<void>;
@@ -17,4 +18,3 @@ export declare function runSync(migrator: Migrator, args: string[], config: Part
 export declare function runGenerateFromDb(migrator: Migrator, args: string[], config: Partial<Config>): Promise<void>;
 export declare function runDriftCheck(migrator: Migrator, config: Partial<Config>): Promise<void>;
 export declare function printHelp(): void;
-//# sourceMappingURL=cli.d.ts.map

package/dist/migrate/cli.js

@@ -9,10 +9,9 @@ import { detectDrift } from './drift/driftDetector.js';
 import { Migrator } from './migrator.js';
 import { createSchemaGenerator } from './schemaGenerator.js';
 import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
-import { createSchemaSync } from './sync/schemaSync.js';
 /** Sync helper for SQL dialects only; returns `undefined` for MongoDB - use {@link createSchemaGeneratorAsync}. */
-export function getSchemaGenerator(dialect, namingStrategy) {
-    return createSchemaGenerator(dialect, namingStrategy);
+export function getSchemaGenerator(dialect, defaultForeignKeyAction) {
+    return createSchemaGenerator(dialect, defaultForeignKeyAction);
 }
 export { createSchemaGeneratorAsync };
 export async function main(args = process.argv.slice(2)) {
@@ -40,11 +39,11 @@ export async function main(args = process.argv.slice(2)) {
             tableName: config.tableName,
             logger: console.log,
             entities: config.entities,
-            namingStrategy: config.namingStrategy,
+            defaultForeignKeyAction: config.defaultForeignKeyAction,
         };
         const migrator = new Migrator(config.pool, options);
         if (!migrator.schemaGenerator) {
-            const generator = await createSchemaGeneratorAsync(config.pool.dialect, config.namingStrategy);
+            const generator = await createSchemaGeneratorAsync(config.pool.dialect, config.defaultForeignKeyAction);
             if (!generator) {
                 throw new TypeError(`Could not find a schema generator for dialect: ${dialectName}`);
             }
@@ -191,49 +190,25 @@ export async function runGenerateFromEntities(migrator, args) {
     console.log(`\nCreated migration from entities: ${filePath}`);
 }
 export async function runSync(migrator, args, config) {
-    const force = args.includes('--force');
-    const push = args.includes('--push');
-    const pull = args.includes('--pull');
-    const dryRun = args.includes('--dry-run');
-    // Parse direction
-    let direction = 'bidirectional';
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--direction' && args[i + 1]) {
-            direction = args[++i];
-        }
-    }
-    // Shorthand flags
-    if (push)
-        direction = 'entity-to-db';
-    if (pull)
-        direction = 'db-to-entity';
-    if (force) {
+    if (args.includes('--force')) {
         console.log('\n⚠️  WARNING: This will drop and recreate all tables!');
         console.log('   All data will be lost. This should only be used in development.\n');
-        await migrator.sync({ force });
+        await migrator.sync({ force: true });
         console.log('\nSchema sync completed.');
         return;
     }
-    // Use SchemaSync for direction-aware sync
-    if (config.entities && migrator.schemaIntrospector) {
-        const schemaSync = createSchemaSync({
-            entities: config.entities,
-            introspector: migrator.schemaIntrospector,
-            direction,
-            safe: !args.includes('--unsafe'),
-            dryRun,
-        });
-        const result = await schemaSync.sync();
-        console.log('\n' + result.summary);
-        if (result.conflicts.length > 0) {
-            console.log('\n⚠️  Conflicts require manual resolution.');
-            process.exit(1);
-        }
+    // Pulling the database into entity files is what `generate:from-db` does; one implementation.
+    if (args.includes('--pull')) {
+        return runGenerateFromDb(migrator, args, config);
     }
-    else {
-        await migrator.sync({ force: false });
-        console.log('\nSchema sync completed.');
+    const safe = !args.includes('--unsafe');
+    if (args.includes('--dry-run')) {
+        const statements = await migrator.planSync({ safe, drop: !safe });
+        console.log(statements.length ? `\n${statements.join('\n')}` : '\nSchema is already in sync.');
+        return;
     }
+    await migrator.autoSync({ safe, drop: !safe, logging: true });
+    console.log('\nSchema sync completed.');
 }
 export async function runGenerateFromDb(migrator, args, config) {
     // Parse output directory
@@ -359,13 +334,11 @@ Commands:
   generate:from-db      Generate TypeScript entities from database
     --output, -o <dir>  Output directory (default: ./src/entities)
 
-  sync                  Sync schema with direction support
+  sync                  Apply the entity schema to the database
+    --dry-run           Print the statements instead of running them
+    --unsafe            Allow destructive changes (drops, column alterations)
+    --pull              Go the other way: generate entities from the database
     --force             Drop and recreate all tables (dangerous!)
-    --direction <mode>  Sync direction: bidirectional, entity-to-db, db-to-entity
-    --push              Shorthand for --direction entity-to-db
-    --pull              Shorthand for --direction db-to-entity
-    --dry-run           Preview changes without applying
-    --unsafe            Allow destructive changes
 
   drift:check           Check for schema drift between entities and database
 
@@ -391,9 +364,8 @@ Examples:
   uql-orm/migrate generate add_users_table
   uql-orm/migrate generate:entities initial_schema
   uql-orm/migrate generate:from-db --output ./src/entities
-  uql-orm/migrate sync --push
+  uql-orm/migrate sync --dry-run
   uql-orm/migrate sync --pull
   uql-orm/migrate drift:check
 `);
 }
-//# sourceMappingURL=cli.js.map

package/dist/migrate/codegen/entityCodeGenerator.d.ts

@@ -105,10 +105,6 @@ export declare class EntityCodeGenerator {
      * Format type for description.
      */
     private formatTypeDescription;
-    /**
-     * Format default value for code.
-     */
-    private formatDefaultValue;
     /**
      * Default class name transformer: table_name -> TableName (PascalCase, singular).
      */
@@ -134,4 +130,3 @@ export declare class EntityCodeGenerator {
  * Create an EntityCodeGenerator from SchemaAST.
  */
 export declare function createEntityCodeGenerator(ast: SchemaAST, options?: EntityCodeGeneratorOptions): EntityCodeGenerator;
-//# sourceMappingURL=entityCodeGenerator.d.ts.map