uql-orm 0.21.0 → 0.23.0

package/dist/migrate/codegen/migrationCodeGenerator.js

@@ -1,355 +0,0 @@
-/**
- * Migration Code Generator
- *
- * Generates TypeScript migration code from SchemaDiff.
- * This enables auto-generating migrations from entity changes.
- */
-/**
- * Generates TypeScript migration code from schema diffs.
- */
-export class MigrationCodeGenerator {
-    indent;
-    includeComments;
-    constructor(options = {}) {
-        this.indent = options.indent ?? '  ';
-        this.includeComments = options.includeComments ?? true;
-    }
-    /**
-     * Generate migration code from a single SchemaDiff.
-     */
-    generate(diff) {
-        const description = this.generateDescription(diff);
-        if (diff.type === 'create') {
-            return {
-                up: this.generateCreateTable(diff),
-                down: this.generateDropTable(diff.tableName),
-                description,
-            };
-        }
-        if (diff.type === 'drop') {
-            return {
-                up: this.generateDropTable(diff.tableName),
-                down: '// Cannot auto-generate: original table structure unknown',
-                description,
-            };
-        }
-        // alter
-        return {
-            up: this.generateAlterUp(diff),
-            down: this.generateAlterDown(diff),
-            description,
-        };
-    }
-    /**
-     * Generate migration code from multiple diffs.
-     */
-    generateAll(diffs) {
-        const ups = [];
-        const downs = [];
-        const descriptions = [];
-        for (const diff of diffs) {
-            const result = this.generate(diff);
-            ups.push(result.up);
-            downs.push(result.down);
-            descriptions.push(result.description);
-        }
-        return {
-            up: ups.join('\n\n'),
-            down: downs.reverse().join('\n\n'), // Reverse for correct rollback order
-            description: descriptions.join('; '),
-        };
-    }
-    /**
-     * Generate a complete migration file template.
-     */
-    generateFile(diffs, name) {
-        const { up, down, description } = this.generateAll(diffs);
-        const timestamp = new Date()
-            .toISOString()
-            .replace(/[-:T.Z]/g, '')
-            .slice(0, 14);
-        const migrationName = name ?? `migration_${timestamp}`;
-        return `/**
- * Migration: ${migrationName}
- * ${description}
- *
- * Generated at: ${new Date().toISOString()}
- */
-
-import type { IMigrationBuilder } from 'uql-orm';
-
-export async function up(builder: IMigrationBuilder): Promise<void> {
-${this.indentBlock(up, 1)}
-}
-
-export async function down(builder: IMigrationBuilder): Promise<void> {
-${this.indentBlock(down, 1)}
-}
-`;
-    }
-    // ===========================================================================
-    // Private: Code Generation
-    // ===========================================================================
-    generateCreateTable(diff) {
-        const columns = diff.columnsToAdd ?? [];
-        const lines = [];
-        lines.push(`await builder.createTable('${diff.tableName}', (table) => {`);
-        for (const col of columns) {
-            lines.push(`${this.indent}${this.generateColumnCall(col)};`);
-        }
-        // Add indexes if any
-        for (const idx of diff.indexesToAdd ?? []) {
-            lines.push(`${this.indent}${this.generateIndexCall(idx)};`);
-        }
-        lines.push('});');
-        return lines.join('\n');
-    }
-    generateDropTable(tableName) {
-        return `await builder.dropTable('${tableName}');`;
-    }
-    generateAlterUp(diff) {
-        const lines = [];
-        // Add columns
-        for (const col of diff.columnsToAdd ?? []) {
-            lines.push(this.generateAddColumn(diff.tableName, col));
-        }
-        // Alter columns
-        for (const { to } of diff.columnsToAlter ?? []) {
-            lines.push(this.generateAlterColumn(diff.tableName, to));
-        }
-        // Drop columns
-        for (const colName of diff.columnsToDrop ?? []) {
-            lines.push(`await builder.dropColumn('${diff.tableName}', '${colName}');`);
-        }
-        // Add indexes
-        for (const idx of diff.indexesToAdd ?? []) {
-            lines.push(this.generateCreateIndex(diff.tableName, idx));
-        }
-        // Drop indexes
-        for (const idxName of diff.indexesToDrop ?? []) {
-            lines.push(`await builder.dropIndex('${diff.tableName}', '${idxName}');`);
-        }
-        // Add foreign keys
-        for (const fk of diff.foreignKeysToAdd ?? []) {
-            lines.push(this.generateAddForeignKey(diff.tableName, fk));
-        }
-        // Drop foreign keys
-        for (const fkName of diff.foreignKeysToDrop ?? []) {
-            lines.push(`await builder.dropForeignKey('${diff.tableName}', '${fkName}');`);
-        }
-        return lines.join('\n');
-    }
-    generateAlterDown(diff) {
-        const lines = [];
-        // Reverse: drop added columns
-        for (const col of diff.columnsToAdd ?? []) {
-            lines.push(`await builder.dropColumn('${diff.tableName}', '${col.name}');`);
-        }
-        // Reverse: restore altered columns
-        for (const { from } of diff.columnsToAlter ?? []) {
-            lines.push(this.generateAlterColumn(diff.tableName, from));
-        }
-        // Reverse: re-add dropped columns (if we have the schema)
-        // Note: This requires the original column definition
-        if (diff.columnsToDrop?.length) {
-            lines.push(`// TODO: Re-add dropped columns: ${diff.columnsToDrop.join(', ')}`);
-        }
-        // Reverse: drop added indexes
-        for (const idx of diff.indexesToAdd ?? []) {
-            lines.push(`await builder.dropIndex('${diff.tableName}', '${idx.name}');`);
-        }
-        // Reverse: re-add dropped indexes
-        if (diff.indexesToDrop?.length) {
-            lines.push(`// TODO: Re-add dropped indexes: ${diff.indexesToDrop.join(', ')}`);
-        }
-        // Reverse: drop added foreign keys
-        for (const fk of diff.foreignKeysToAdd ?? []) {
-            if (fk.name) {
-                lines.push(`await builder.dropForeignKey('${diff.tableName}', '${fk.name}');`);
-            }
-        }
-        // Reverse: re-add dropped foreign keys
-        if (diff.foreignKeysToDrop?.length) {
-            lines.push(`// TODO: Re-add dropped foreign keys: ${diff.foreignKeysToDrop.join(', ')}`);
-        }
-        return lines.join('\n');
-    }
-    generateAddColumn(tableName, col) {
-        const options = this.generateColumnOptions(col);
-        return `await builder.addColumn('${tableName}', '${col.name}', (col) => col${options});`;
-    }
-    generateAlterColumn(tableName, col) {
-        const options = this.generateColumnOptions(col);
-        return `await builder.alterColumn('${tableName}', '${col.name}', (col) => col${options});`;
-    }
-    generateCreateIndex(tableName, idx) {
-        const cols = idx.columns.map((c) => `'${c}'`).join(', ');
-        const opts = [];
-        if (idx.name)
-            opts.push(`name: '${idx.name}'`);
-        if (idx.unique)
-            opts.push('unique: true');
-        const optsStr = opts.length ? `, { ${opts.join(', ')} }` : '';
-        return `await builder.createIndex('${tableName}', [${cols}]${optsStr});`;
-    }
-    generateAddForeignKey(tableName, fk) {
-        const cols = fk.columns.map((c) => `'${c}'`).join(', ');
-        const refCols = fk.referencedColumns.map((c) => `'${c}'`).join(', ');
-        const opts = [];
-        if (fk.name)
-            opts.push(`name: '${fk.name}'`);
-        if (fk.onDelete && fk.onDelete !== 'NO ACTION')
-            opts.push(`onDelete: '${fk.onDelete}'`);
-        if (fk.onUpdate && fk.onUpdate !== 'NO ACTION')
-            opts.push(`onUpdate: '${fk.onUpdate}'`);
-        const optsStr = opts.length ? `, { ${opts.join(', ')} }` : '';
-        return `await builder.addForeignKey('${tableName}', [${cols}], { table: '${fk.referencedTable}', columns: [${refCols}] }${optsStr});`;
-    }
-    // ===========================================================================
-    // Private: Column Call Generation
-    // ===========================================================================
-    generateColumnCall(col) {
-        const method = this.getColumnMethod(col);
-        const options = this.generateColumnOptionsObject(col);
-        return `table.${method}('${col.name}'${options})`;
-    }
-    generateIndexCall(idx) {
-        const cols = idx.columns.map((c) => `'${c}'`).join(', ');
-        if (idx.unique) {
-            return `table.unique([${cols}], '${idx.name}')`;
-        }
-        return `table.index([${cols}], '${idx.name}')`;
-    }
-    getColumnMethod(col) {
-        const type = col.type;
-        // Check for auto-increment primary key → id()
-        if (col.isPrimaryKey && col.isAutoIncrement) {
-            return 'id';
-        }
-        // Map type string to method name
-        const typeMap = {
-            integer: 'integer',
-            int: 'integer',
-            bigint: 'bigint',
-            smallint: 'smallint',
-            float: 'float',
-            double: 'double',
-            decimal: 'decimal',
-            numeric: 'decimal',
-            varchar: 'string',
-            char: 'char',
-            text: 'text',
-            boolean: 'boolean',
-            bool: 'boolean',
-            date: 'date',
-            time: 'time',
-            timestamp: 'timestamp',
-            timestamptz: 'timestamptz',
-            json: 'json',
-            jsonb: 'jsonb',
-            uuid: 'uuid',
-            blob: 'blob',
-            bytea: 'blob',
-            vector: 'vector',
-        };
-        const lowerType = type.toLowerCase().replace(/\(.*\)/, ''); // Remove (255) etc
-        return typeMap[lowerType] ?? 'string';
-    }
-    generateColumnOptionsObject(col) {
-        const opts = [];
-        // Type-specific options
-        if (col.length !== undefined && col.length !== 255) {
-            opts.push(`length: ${col.length}`);
-        }
-        if (col.precision !== undefined) {
-            opts.push(`precision: ${col.precision}`);
-        }
-        if (col.scale !== undefined) {
-            opts.push(`scale: ${col.scale}`);
-        }
-        // Common options (only include non-defaults)
-        if (col.nullable) {
-            opts.push('nullable: true');
-        }
-        if (col.isUnique && !col.isPrimaryKey) {
-            opts.push('unique: true');
-        }
-        if (col.isPrimaryKey && !col.isAutoIncrement) {
-            opts.push('primaryKey: true');
-        }
-        if (col.defaultValue !== undefined) {
-            opts.push(`defaultValue: ${this.formatValue(col.defaultValue)}`);
-        }
-        if (opts.length === 0)
-            return '';
-        return `, { ${opts.join(', ')} }`;
-    }
-    generateColumnOptions(col) {
-        const parts = [];
-        if (!col.nullable) {
-            parts.push('.notNullable()');
-        }
-        if (col.isUnique) {
-            parts.push('.unique()');
-        }
-        if (col.defaultValue !== undefined) {
-            parts.push(`.defaultValue(${this.formatValue(col.defaultValue)})`);
-        }
-        return parts.join('');
-    }
-    formatValue(value) {
-        if (value === null)
-            return 'null';
-        if (typeof value === 'string') {
-            // Check for SQL expressions
-            if (value.toUpperCase().includes('CURRENT_TIMESTAMP') ||
-                value.includes('()') ||
-                value.toUpperCase().includes('NOW')) {
-                return `t.raw('${value}')`;
-            }
-            return `'${value.replace(/'/g, "\\'")}'`;
-        }
-        if (typeof value === 'boolean')
-            return String(value);
-        if (typeof value === 'number')
-            return String(value);
-        return JSON.stringify(value);
-    }
-    // ===========================================================================
-    // Private: Utilities
-    // ===========================================================================
-    generateDescription(diff) {
-        const parts = [];
-        if (diff.type === 'create') {
-            parts.push(`Create table '${diff.tableName}'`);
-        }
-        else if (diff.type === 'drop') {
-            parts.push(`Drop table '${diff.tableName}'`);
-        }
-        else {
-            if (diff.columnsToAdd?.length) {
-                parts.push(`Add ${diff.columnsToAdd.length} column(s)`);
-            }
-            if (diff.columnsToAlter?.length) {
-                parts.push(`Alter ${diff.columnsToAlter.length} column(s)`);
-            }
-            if (diff.columnsToDrop?.length) {
-                parts.push(`Drop ${diff.columnsToDrop.length} column(s)`);
-            }
-        }
-        return parts.join(', ') || `Alter table '${diff.tableName}'`;
-    }
-    indentBlock(code, level) {
-        const prefix = this.indent.repeat(level);
-        return code
-            .split('\n')
-            .map((line) => (line.trim() ? prefix + line : line))
-            .join('\n');
-    }
-}
-/**
- * Factory function to create a MigrationCodeGenerator.
- */
-export function createMigrationCodeGenerator(options) {
-    return new MigrationCodeGenerator(options);
-}

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

@@ -1,47 +0,0 @@
-/**
- * Smart Relation Detector
- *
- * Uses heuristics and schema analysis to detect relationships between tables:
- * - Explicit foreign keys (highest confidence)
- * - Junction tables for ManyToMany
- * - Unique FK columns for OneToOne
- */
-import type { SchemaAST } from '../../schema/schemaAST.js';
-import type { DetectedRelation } from '../../schema/types.js';
-/**
- * Configuration for relation detection.
- */
-export interface RelationDetectorOptions {
-    /** Minimum confidence threshold (0-1) to include in results */
-    minConfidence?: number;
-    /** Custom singularize function */
-    singularize?: (name: string) => string;
-}
-/**
- * Detects relationships in a SchemaAST using multiple heuristics.
- */
-export declare class SmartRelationDetector {
-    private readonly ast;
-    private readonly options;
-    constructor(ast: SchemaAST, options?: RelationDetectorOptions);
-    /**
-     * Detect all relationships in the schema.
-     */
-    detectAll(): DetectedRelation[];
-    /**
-     * Detect junction tables that represent ManyToMany relationships.
-     */
-    private detectJunctionTables;
-    /**
-     * Detect relations where unique FK should upgrade to OneToOne.
-     */
-    private detectOneToOneRelations;
-    /**
-     * Default singularize function (delegates to shared utility).
-     */
-    private defaultSingularize;
-}
-/**
- * Create a SmartRelationDetector for the given AST.
- */
-export declare function createRelationDetector(ast: SchemaAST, options?: RelationDetectorOptions): SmartRelationDetector;

package/dist/migrate/codegen/smartRelationDetector.js

@@ -1,134 +0,0 @@
-/**
- * Smart Relation Detector
- *
- * Uses heuristics and schema analysis to detect relationships between tables:
- * - Explicit foreign keys (highest confidence)
- * - Junction tables for ManyToMany
- * - Unique FK columns for OneToOne
- */
-import { singularize } from '../../util/string.util.js';
-/**
- * Detects relationships in a SchemaAST using multiple heuristics.
- */
-export class SmartRelationDetector {
-    ast;
-    options;
-    constructor(ast, options = {}) {
-        this.ast = ast;
-        this.options = {
-            minConfidence: options.minConfidence ?? 0.5,
-            singularize: options.singularize ?? this.defaultSingularize.bind(this),
-        };
-    }
-    /**
-     * Detect all relationships in the schema.
-     */
-    detectAll() {
-        const relations = [];
-        // 1. Add explicit FK relationships (confidence: 1.0)
-        for (const rel of this.ast.relationships) {
-            relations.push({
-                type: rel.type,
-                from: {
-                    table: rel.from.table,
-                    columns: rel.from.columns,
-                },
-                to: {
-                    table: rel.to.table,
-                    columns: rel.to.columns,
-                },
-                through: rel.through,
-                confidence: 1.0,
-                source: 'explicit_fk',
-            });
-        }
-        // 2. Detect junction tables (ManyToMany)
-        const junctionRelations = this.detectJunctionTables();
-        relations.push(...junctionRelations);
-        // 3. Detect unique FK -> OneToOne upgrades
-        const oneToOneUpgrades = this.detectOneToOneRelations(relations);
-        relations.push(...oneToOneUpgrades);
-        // Filter by confidence
-        return relations.filter((r) => r.confidence >= this.options.minConfidence);
-    }
-    /**
-     * Detect junction tables that represent ManyToMany relationships.
-     */
-    detectJunctionTables() {
-        const relations = [];
-        for (const table of this.ast.tables.values()) {
-            if (!this.ast.isJunctionTable(table))
-                continue;
-            const outgoingRels = table.outgoingRelations;
-            if (outgoingRels.length !== 2)
-                continue;
-            const [rel1, rel2] = outgoingRels;
-            // Create ManyToMany relation
-            relations.push({
-                type: 'ManyToMany',
-                from: {
-                    table: rel1.to.table,
-                    columns: rel1.to.columns,
-                },
-                to: {
-                    table: rel2.to.table,
-                    columns: rel2.to.columns,
-                },
-                through: table,
-                confidence: 0.95,
-                source: 'junction_table',
-            });
-            // Also create inverse relation
-            relations.push({
-                type: 'ManyToMany',
-                from: {
-                    table: rel2.to.table,
-                    columns: rel2.to.columns,
-                },
-                to: {
-                    table: rel1.to.table,
-                    columns: rel1.to.columns,
-                },
-                through: table,
-                confidence: 0.95,
-                source: 'junction_table',
-            });
-        }
-        return relations;
-    }
-    /**
-     * Detect relations where unique FK should upgrade to OneToOne.
-     */
-    detectOneToOneRelations(existingRelations) {
-        const upgrades = [];
-        for (const rel of existingRelations) {
-            if (rel.source !== 'explicit_fk')
-                continue;
-            const fromCol = rel.from.columns[0];
-            if (fromCol?.isUnique && rel.type === 'ManyToOne') {
-                // Upgrade to OneToOne
-                upgrades.push({
-                    type: 'OneToOne',
-                    from: rel.from,
-                    to: rel.to,
-                    through: rel.through,
-                    confidence: 0.9,
-                    source: 'unique_fk',
-                });
-            }
-        }
-        return upgrades;
-    }
-    /**
-     * Default singularize function (delegates to shared utility).
-     */
-    defaultSingularize(name) {
-        return singularize(name);
-    }
-}
-/**
- * Create a SmartRelationDetector for the given AST.
- */
-export function createRelationDetector(ast, options) {
-    return new SmartRelationDetector(ast, options);
-}

package/dist/migrate/generator/index.d.ts

@@ -1,2 +0,0 @@
-export { createSchemaGenerator, SqlSchemaGenerator } from '../schemaGenerator.js';
-export { createSchemaGeneratorAsync } from '../schemaGeneratorAsync.js';

package/dist/migrate/generator/index.js

@@ -1,2 +0,0 @@
-export { createSchemaGenerator, SqlSchemaGenerator } from '../schemaGenerator.js';
-export { createSchemaGeneratorAsync } from '../schemaGeneratorAsync.js';

package/dist/migrate/sync/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Schema Sync Module
- *
- * Orchestrates schema synchronization with configurable direction modes.
- */
-export { createSchemaSync, SchemaSync, type SchemaSyncOptions, type SchemaSyncResult, type SyncConflict, } from './schemaSync.js';

package/dist/migrate/sync/index.js

@@ -1,6 +0,0 @@
-/**
- * Schema Sync Module
- *
- * Orchestrates schema synchronization with configurable direction modes.
- */
-export { createSchemaSync, SchemaSync, } from './schemaSync.js';

package/dist/migrate/sync/schemaSync.d.ts

@@ -1,131 +0,0 @@
-/**
- * Schema Sync
- *
- * Orchestrates schema synchronization between entities and database
- * with configurable direction modes.
- */
-import type { SchemaDiffResult, SyncDirection, SyncOptions } from '../../schema/types.js';
-import type { SchemaIntrospector, Type } from '../../type/index.js';
-/**
- * Result of a schema sync operation.
- */
-export interface SchemaSyncResult {
-    /** Direction of the sync */
-    direction: SyncDirection;
-    /** Whether the sync was successful */
-    success: boolean;
-    /** Changes applied to database */
-    dbChanges: SchemaDiffResult | undefined;
-    /** Changes applied to entities */
-    entityChanges: SchemaDiffResult | undefined;
-    /** Conflicts that need manual resolution */
-    conflicts: SyncConflict[];
-    /** Human-readable summary */
-    summary: string;
-    /** Structured summary of changes */
-    details: {
-        db: {
-            created: number;
-            dropped: number;
-            altered: number;
-        };
-        entity: {
-            created: number;
-            dropped: number;
-            altered: number;
-        };
-    };
-}
-/**
- * A conflict between entity and database schemas.
- */
-export interface SyncConflict {
-    /** Type of conflict */
-    type: 'type_mismatch' | 'constraint_mismatch' | 'column_mismatch' | 'relation_mismatch';
-    /** Table name */
-    table: string;
-    /** Column name (if applicable) */
-    column?: string;
-    /** What entity expects */
-    entityValue: unknown;
-    /** What database has */
-    dbValue: unknown;
-    /** Suggested resolution */
-    suggestion: string;
-}
-/**
- * Options for schema sync operation.
- */
-export interface SchemaSyncOptions extends SyncOptions {
-    /** Entities to sync */
-    entities: Type<unknown>[];
-    /** Schema introspector for database */
-    introspector: SchemaIntrospector;
-    /** Output directory for generated entities (db-to-entity mode) */
-    entityOutputDir?: string;
-    /** Dry run - don't apply changes */
-    dryRun?: boolean;
-}
-/**
- * Service for synchronizing schemas between entities and database.
- */
-export declare class SchemaSync {
-    private readonly options;
-    constructor(options: SchemaSyncOptions);
-    /**
-     * Execute schema synchronization.
-     */
-    sync(): Promise<SchemaSyncResult>;
-    /**
-     * Sync from entities to database (push).
-     */
-    private syncEntityToDb;
-    /**
-     * Sync from database to entities (pull).
-     */
-    private syncDbToEntity;
-    /**
-     * Bidirectional sync with conflict detection.
-     */
-    private syncBidirectional;
-    /**
-     * Build SchemaAST from entities.
-     */
-    private buildEntityAST;
-    /**
-     * Build SchemaAST from database.
-     */
-    private buildDatabaseAST;
-    /**
-     * Filter destructive changes for safe mode.
-     */
-    private filterDestructiveChanges;
-    /**
-     * Detect conflicts between bidirectional changes.
-     */
-    private detectConflicts;
-    /**
-     * Filter out conflicting changes.
-     */
-    private filterConflictingChanges;
-    /**
-     * Get counts of changes from a diff.
-     */
-    private getDiffCounts;
-    /**
-     * Format summary for single-direction sync.
-     */
-    private formatSummary;
-    /**
-     * Format summary for bidirectional sync.
-     */
-    private formatBidirectionalSummary;
-    /**
-     * Format type for display.
-     */
-    private formatType;
-}
-/**
- * Create a SchemaSync instance.
- */
-export declare function createSchemaSync(options: SchemaSyncOptions): SchemaSync;