@uql/core 3.7.14 → 3.8.2

package/dist/schema/index.js

@@ -0,0 +1,29 @@
+/**
+ * Schema AST Module
+ *
+ * Provides a unified graph representation of database schema for:
+ * - Schema diffing and migration generation
+ * - Entity code generation from database
+ * - Drift detection
+ * - Smart relation inference
+ */
+// Dialect configuration
+export { DIALECT_CONFIG, getDialectConfig } from '../dialect/index.js';
+// Canonical type utilities
+export { areTypesEqual, canonicalToColumnType, canonicalToSql, canonicalToTypeScript, fieldOptionsToCanonical, isBreakingTypeChange, sqlToCanonical, } from './canonicalType.js';
+/**
+ * Introspect the database and build a SchemaAST from it.
+ *
+ * @param introspector - The schema introspector to use
+ * @returns The SchemaAST representing the database schema
+ */
+export async function introspectSchema(introspector) {
+    return introspector.introspect();
+}
+// SchemaAST class
+export { SchemaAST } from './schemaAST.js';
+// Builder
+export { SchemaASTBuilder } from './schemaASTBuilder.js';
+// Differ
+export { diffSchemas, SchemaASTDiffer } from './schemaASTDiffer.js';
+//# sourceMappingURL=index.js.map

package/dist/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,wBAAwB;AACxB,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvE,2BAA2B;AAC3B,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,cAAc,GACf,MAAM,oBAAoB,CAAC;AAE5B;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,YAAgC;IACrE,OAAO,YAAY,CAAC,UAAU,EAAE,CAAC;AACnC,CAAC;AACD,kBAAkB;AAClB,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,UAAU;AACV,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGzD,SAAS;AACT,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/schema/schemaAST.d.ts

@@ -0,0 +1,155 @@
+/**
+ * SchemaAST Class
+ *
+ * The main class for working with schema graphs.
+ * Provides graph operations like navigation, validation, and topological sorting.
+ */
+import type { ColumnNode, IndexNode, SchemaAST as ISchemaAST, RelationshipNode, RelationshipType, TableNode, ValidationError } from './types.js';
+/**
+ * Schema AST - A graph representation of a database schema.
+ *
+ * Enables:
+ * - Graph navigation (dependencies, dependents)
+ * - Circular dependency detection
+ * - Topological sorting for correct DDL order
+ * - Smart relation inference
+ * - Schema validation
+ */
+export declare class SchemaAST implements ISchemaAST {
+    readonly tables: Map<string, TableNode>;
+    readonly relationships: RelationshipNode[];
+    readonly indexes: IndexNode[];
+    /**
+     * Get a table by name.
+     */
+    getTable(name: string): TableNode | undefined;
+    /**
+     * Add a table to the schema.
+     */
+    addTable(table: TableNode): void;
+    /**
+     * Remove a table from the schema.
+     */
+    removeTable(name: string): boolean;
+    /**
+     * Get all table nodes.
+     */
+    getTables(): TableNode[];
+    /**
+     * Get all table names.
+     */
+    getTableNames(): string[];
+    /**
+     * Get all tables that depend on this table (have FKs pointing to it).
+     * These are tables that reference this table's primary key.
+     */
+    getDependentTables(table: TableNode): TableNode[];
+    /**
+     * Get all tables this table depends on (has FKs to).
+     * These are tables that this table references.
+     */
+    getDependencies(table: TableNode): TableNode[];
+    /**
+     * Get the relationship between two tables (if any).
+     */
+    getRelationship(from: TableNode, to: TableNode): RelationshipNode | undefined;
+    /**
+     * Get all relationships for a table.
+     */
+    getTableRelationships(table: TableNode): RelationshipNode[];
+    /**
+     * Get the column that a foreign key column references.
+     */
+    getReferencedColumn(fkColumn: ColumnNode): ColumnNode | undefined;
+    /**
+     * Detect circular foreign key dependencies.
+     * Returns arrays of tables that form cycles.
+     */
+    detectCircularDependencies(): TableNode[][];
+    /**
+     * Check if there are any circular dependencies.
+     */
+    hasCircularDependencies(): boolean;
+    /**
+     * Get tables in correct order for CREATE (dependencies first).
+     * Tables with no dependencies come first, then tables that depend on them, etc.
+     */
+    getCreateOrder(): TableNode[];
+    /**
+     * Get tables in correct order for DROP (dependents first).
+     * Tables that depend on others come first, then the tables they depend on.
+     */
+    getDropOrder(): TableNode[];
+    /**
+     * Topological sort respecting FK dependencies.
+     * Uses Kahn's algorithm for stable ordering.
+     */
+    private topologicalSort;
+    /**
+     * Validate schema integrity.
+     * Checks for:
+     * - Missing FK targets
+     * - Circular dependencies
+     * - Orphan columns
+     * - Duplicate indexes
+     */
+    validate(): ValidationError[];
+    /**
+     * Check if the schema is valid (no validation errors).
+     */
+    isValid(): boolean;
+    /**
+     * Check if a table looks like a junction table (ManyToMany through).
+     * Junction tables typically have:
+     * - Exactly 2 foreign keys
+     * - Few other columns (id, maybe timestamps)
+     * - Primary key might be composite of the FKs
+     */
+    isJunctionTable(table: TableNode): boolean;
+    /**
+     * Infer relation type from schema structure.
+     */
+    inferRelationType(rel: RelationshipNode): RelationshipType;
+    /**
+     * Get the inverse relation type.
+     */
+    getInverseRelationType(type: RelationshipType): RelationshipType;
+    /**
+     * Add an index to the schema.
+     */
+    addIndex(index: IndexNode): void;
+    /**
+     * Get all indexes for a table.
+     */
+    getTableIndexes(tableName: string): IndexNode[];
+    /**
+     * Find an index by name.
+     */
+    getIndex(name: string): IndexNode | undefined;
+    /**
+     * Add a relationship to the schema.
+     */
+    addRelationship(rel: RelationshipNode): void;
+    /**
+     * Remove a relationship from the schema.
+     */
+    removeRelationship(name: string): boolean;
+    /**
+     * Create a deep clone of this schema.
+     */
+    clone(): SchemaAST;
+    /**
+     * Get statistics about the schema.
+     */
+    getStats(): {
+        tableCount: number;
+        columnCount: number;
+        relationshipCount: number;
+        indexCount: number;
+    };
+    /**
+     * Convert schema to a plain object for serialization/debugging.
+     */
+    toJSON(): object;
+}
+//# sourceMappingURL=schemaAST.d.ts.map

package/dist/schema/schemaAST.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaAST.d.ts","sourceRoot":"","sources":["../../src/schema/schemaAST.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,SAAS,EACT,SAAS,IAAI,UAAU,EACvB,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;GASG;AACH,qBAAa,SAAU,YAAW,UAAU;IAC1C,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAa;IACpD,QAAQ,CAAC,aAAa,EAAE,gBAAgB,EAAE,CAAM;IAChD,QAAQ,CAAC,OAAO,EAAE,SAAS,EAAE,CAAM;IAMnC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI7C;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAKhC;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAsBlC;;OAEG;IACH,SAAS,IAAI,SAAS,EAAE;IAIxB;;OAEG;IACH,aAAa,IAAI,MAAM,EAAE;IAQzB;;;OAGG;IACH,kBAAkB,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,EAAE;IAIjD;;;OAGG;IACH,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,EAAE;IAI9C;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,GAAG,gBAAgB,GAAG,SAAS;IAI7E;;OAEG;IACH,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,gBAAgB,EAAE;IAI3D;;OAEG;IACH,mBAAmB,CAAC,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS;IAQjE;;;OAGG;IACH,0BAA0B,IAAI,SAAS,EAAE,EAAE;IAgC3C;;OAEG;IACH,uBAAuB,IAAI,OAAO;IAIlC;;;OAGG;IACH,cAAc,IAAI,SAAS,EAAE;IAI7B;;;OAGG;IACH,YAAY,IAAI,SAAS,EAAE;IAI3B;;;OAGG;IACH,OAAO,CAAC,eAAe;IA4BvB;;;;;;;OAOG;IACH,QAAQ,IAAI,eAAe,EAAE;IA0C7B;;OAEG;IACH,OAAO,IAAI,OAAO;IAQlB;;;;;;OAMG;IACH,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IA0B1C;;OAEG;IACH,iBAAiB,CAAC,GAAG,EAAE,gBAAgB,GAAG,gBAAgB;IAiB1D;;OAEG;IACH,sBAAsB,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB;IAiBhE;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAOhC;;OAEG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE;IAK/C;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAQ7C;;OAEG;IACH,eAAe,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI;IAgB5C;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAgCzC;;OAEG;IACH,KAAK,IAAI,SAAS;IAyFlB;;OAEG;IACH,QAAQ,IAAI;QACV,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,UAAU,EAAE,MAAM,CAAC;KACpB;IAcD;;OAEG;IACH,MAAM,IAAI,MAAM;CA4BjB"}

package/dist/schema/schemaAST.js

@@ -0,0 +1,496 @@
+/**
+ * SchemaAST Class
+ *
+ * The main class for working with schema graphs.
+ * Provides graph operations like navigation, validation, and topological sorting.
+ */
+/**
+ * Schema AST - A graph representation of a database schema.
+ *
+ * Enables:
+ * - Graph navigation (dependencies, dependents)
+ * - Circular dependency detection
+ * - Topological sorting for correct DDL order
+ * - Smart relation inference
+ * - Schema validation
+ */
+export class SchemaAST {
+    tables = new Map();
+    relationships = [];
+    indexes = [];
+    // ============================================================================
+    // Table Operations
+    // ============================================================================
+    /**
+     * Get a table by name.
+     */
+    getTable(name) {
+        return this.tables.get(name);
+    }
+    /**
+     * Add a table to the schema.
+     */
+    addTable(table) {
+        table.schema = this;
+        this.tables.set(table.name, table);
+    }
+    /**
+     * Remove a table from the schema.
+     */
+    removeTable(name) {
+        const table = this.tables.get(name);
+        if (!table)
+            return false;
+        // Remove all relationships involving this table
+        for (let i = this.relationships.length - 1; i >= 0; i--) {
+            const rel = this.relationships[i];
+            if (rel.from.table === table || rel.to.table === table) {
+                this.relationships.splice(i, 1);
+            }
+        }
+        // Remove all indexes for this table
+        for (let i = this.indexes.length - 1; i >= 0; i--) {
+            if (this.indexes[i].table === table) {
+                this.indexes.splice(i, 1);
+            }
+        }
+        return this.tables.delete(name);
+    }
+    /**
+     * Get all table nodes.
+     */
+    getTables() {
+        return Array.from(this.tables.values());
+    }
+    /**
+     * Get all table names.
+     */
+    getTableNames() {
+        return Array.from(this.tables.keys());
+    }
+    // ============================================================================
+    // Graph Navigation
+    // ============================================================================
+    /**
+     * Get all tables that depend on this table (have FKs pointing to it).
+     * These are tables that reference this table's primary key.
+     */
+    getDependentTables(table) {
+        return table.incomingRelations.map((r) => r.from.table);
+    }
+    /**
+     * Get all tables this table depends on (has FKs to).
+     * These are tables that this table references.
+     */
+    getDependencies(table) {
+        return table.outgoingRelations.map((r) => r.to.table);
+    }
+    /**
+     * Get the relationship between two tables (if any).
+     */
+    getRelationship(from, to) {
+        return this.relationships.find((r) => r.from.table === from && r.to.table === to);
+    }
+    /**
+     * Get all relationships for a table.
+     */
+    getTableRelationships(table) {
+        return this.relationships.filter((r) => r.from.table === table || r.to.table === table);
+    }
+    /**
+     * Get the column that a foreign key column references.
+     */
+    getReferencedColumn(fkColumn) {
+        return fkColumn.references?.to.columns[0];
+    }
+    // ============================================================================
+    // Graph Analysis
+    // ============================================================================
+    /**
+     * Detect circular foreign key dependencies.
+     * Returns arrays of tables that form cycles.
+     */
+    detectCircularDependencies() {
+        const cycles = [];
+        const visited = new Set();
+        const stack = new Set();
+        const dfs = (table, path) => {
+            if (stack.has(table)) {
+                const cycleStart = path.indexOf(table);
+                if (cycleStart !== -1) {
+                    cycles.push(path.slice(cycleStart));
+                }
+                return;
+            }
+            if (visited.has(table))
+                return;
+            visited.add(table);
+            stack.add(table);
+            for (const dep of this.getDependencies(table)) {
+                dfs(dep, [...path, table]);
+            }
+            stack.delete(table);
+        };
+        for (const table of this.tables.values()) {
+            dfs(table, []);
+        }
+        return cycles;
+    }
+    /**
+     * Check if there are any circular dependencies.
+     */
+    hasCircularDependencies() {
+        return this.detectCircularDependencies().length > 0;
+    }
+    /**
+     * Get tables in correct order for CREATE (dependencies first).
+     * Tables with no dependencies come first, then tables that depend on them, etc.
+     */
+    getCreateOrder() {
+        return this.topologicalSort();
+    }
+    /**
+     * Get tables in correct order for DROP (dependents first).
+     * Tables that depend on others come first, then the tables they depend on.
+     */
+    getDropOrder() {
+        return this.topologicalSort().reverse();
+    }
+    /**
+     * Topological sort respecting FK dependencies.
+     * Uses Kahn's algorithm for stable ordering.
+     */
+    topologicalSort() {
+        const result = [];
+        const visited = new Set();
+        const visit = (table) => {
+            if (visited.has(table))
+                return;
+            visited.add(table);
+            // Visit dependencies first (tables this table references)
+            for (const dep of this.getDependencies(table)) {
+                visit(dep);
+            }
+            result.push(table);
+        };
+        // Visit all tables
+        for (const table of this.tables.values()) {
+            visit(table);
+        }
+        return result;
+    }
+    // ============================================================================
+    // Validation
+    // ============================================================================
+    /**
+     * Validate schema integrity.
+     * Checks for:
+     * - Missing FK targets
+     * - Circular dependencies
+     * - Orphan columns
+     * - Duplicate indexes
+     */
+    validate() {
+        const errors = [];
+        // Check all FK targets exist
+        for (const rel of this.relationships) {
+            if (!this.tables.has(rel.to.table.name)) {
+                errors.push({
+                    type: 'missing_fk_target',
+                    message: `FK target table "${rel.to.table.name}" does not exist`,
+                    relationship: rel,
+                });
+            }
+        }
+        // Check for circular dependencies
+        const cycles = this.detectCircularDependencies();
+        for (const cycle of cycles) {
+            errors.push({
+                type: 'circular_dependency',
+                message: `Circular FK: ${cycle.map((t) => t.name).join(' -> ')}`,
+                tables: cycle,
+            });
+        }
+        // Check for duplicate index names within same table
+        for (const table of this.tables.values()) {
+            const indexNames = new Set();
+            for (const index of table.indexes) {
+                if (indexNames.has(index.name)) {
+                    errors.push({
+                        type: 'duplicate_index',
+                        message: `Duplicate index name "${index.name}" in table "${table.name}"`,
+                        table,
+                    });
+                }
+                indexNames.add(index.name);
+            }
+        }
+        return errors;
+    }
+    /**
+     * Check if the schema is valid (no validation errors).
+     */
+    isValid() {
+        return this.validate().length === 0;
+    }
+    // ============================================================================
+    // Smart Relation Detection
+    // ============================================================================
+    /**
+     * Check if a table looks like a junction table (ManyToMany through).
+     * Junction tables typically have:
+     * - Exactly 2 foreign keys
+     * - Few other columns (id, maybe timestamps)
+     * - Primary key might be composite of the FKs
+     */
+    isJunctionTable(table) {
+        const fkCount = table.outgoingRelations.length;
+        const columnCount = table.columns.size;
+        // Must have exactly 2 FKs
+        if (fkCount !== 2) {
+            return false;
+        }
+        // Should have few columns (typically: id + 2 FKs + maybe timestamps)
+        if (columnCount > 6) {
+            return false;
+        }
+        // Check if name suggests a junction (contains both related table names)
+        const relatedTables = table.outgoingRelations.map((r) => r.to.table.name.toLowerCase());
+        const tableName = table.name.toLowerCase();
+        // Common patterns: user_roles, post_tags, etc.
+        const containsBothNames = relatedTables.every((name) => tableName.includes(name.replace(/s$/, '')) || tableName.includes(name));
+        return containsBothNames || columnCount <= 5;
+    }
+    /**
+     * Infer relation type from schema structure.
+     */
+    inferRelationType(rel) {
+        const fromCol = rel.from.columns[0];
+        // Check if source is junction table -> ManyToMany
+        if (this.isJunctionTable(rel.from.table)) {
+            return 'ManyToMany';
+        }
+        // Unique FK -> OneToOne
+        if (fromCol?.isUnique) {
+            return 'OneToOne';
+        }
+        // Default: ManyToOne (many rows can reference same target)
+        return 'ManyToOne';
+    }
+    /**
+     * Get the inverse relation type.
+     */
+    getInverseRelationType(type) {
+        switch (type) {
+            case 'OneToOne':
+                return 'OneToOne';
+            case 'OneToMany':
+                return 'ManyToOne';
+            case 'ManyToOne':
+                return 'OneToMany';
+            case 'ManyToMany':
+                return 'ManyToMany';
+        }
+    }
+    // ============================================================================
+    // Index Operations
+    // ============================================================================
+    /**
+     * Add an index to the schema.
+     */
+    addIndex(index) {
+        this.indexes.push(index);
+        if (!index.table.indexes.includes(index)) {
+            index.table.indexes.push(index);
+        }
+    }
+    /**
+     * Get all indexes for a table.
+     */
+    getTableIndexes(tableName) {
+        const table = this.tables.get(tableName);
+        return table?.indexes ?? [];
+    }
+    /**
+     * Find an index by name.
+     */
+    getIndex(name) {
+        return this.indexes.find((i) => i.name === name);
+    }
+    // ============================================================================
+    // Relationship Operations
+    // ============================================================================
+    /**
+     * Add a relationship to the schema.
+     */
+    addRelationship(rel) {
+        this.relationships.push(rel);
+        // Update table links
+        rel.from.table.outgoingRelations.push(rel);
+        rel.to.table.incomingRelations.push(rel);
+        // Update column links
+        for (const col of rel.from.columns) {
+            col.references = rel;
+        }
+        for (const col of rel.to.columns) {
+            col.referencedBy.push(rel);
+        }
+    }
+    /**
+     * Remove a relationship from the schema.
+     */
+    removeRelationship(name) {
+        const index = this.relationships.findIndex((r) => r.name === name);
+        if (index === -1)
+            return false;
+        const rel = this.relationships[index];
+        // Remove from table links
+        const fromIdx = rel.from.table.outgoingRelations.indexOf(rel);
+        if (fromIdx !== -1)
+            rel.from.table.outgoingRelations.splice(fromIdx, 1);
+        const toIdx = rel.to.table.incomingRelations.indexOf(rel);
+        if (toIdx !== -1)
+            rel.to.table.incomingRelations.splice(toIdx, 1);
+        // Remove from column links
+        for (const col of rel.from.columns) {
+            if (col.references === rel) {
+                col.references = undefined;
+            }
+        }
+        for (const col of rel.to.columns) {
+            const refIdx = col.referencedBy.indexOf(rel);
+            if (refIdx !== -1)
+                col.referencedBy.splice(refIdx, 1);
+        }
+        this.relationships.splice(index, 1);
+        return true;
+    }
+    // ============================================================================
+    // Utility Methods
+    // ============================================================================
+    /**
+     * Create a deep clone of this schema.
+     */
+    clone() {
+        const clone = new SchemaAST();
+        // First pass: clone tables and columns (without links)
+        for (const [name, table] of this.tables) {
+            const clonedColumns = new Map();
+            for (const [colName, col] of table.columns) {
+                const clonedCol = {
+                    ...col,
+                    table: undefined, // Will be set below
+                    referencedBy: [],
+                    references: undefined,
+                };
+                clonedColumns.set(colName, clonedCol);
+            }
+            const clonedTable = {
+                name,
+                columns: clonedColumns,
+                primaryKey: [],
+                indexes: [],
+                comment: table.comment,
+                schema: clone,
+                incomingRelations: [],
+                outgoingRelations: [],
+            };
+            // Link columns to table
+            for (const col of clonedColumns.values()) {
+                col.table = clonedTable;
+            }
+            // Set primary key
+            clonedTable.primaryKey = table.primaryKey
+                .map((pk) => clonedColumns.get(pk.name))
+                .filter(Boolean);
+            clone.tables.set(name, clonedTable);
+        }
+        // Second pass: clone relationships
+        for (const rel of this.relationships) {
+            const fromTable = clone.tables.get(rel.from.table.name);
+            const toTable = clone.tables.get(rel.to.table.name);
+            if (!fromTable || !toTable)
+                continue;
+            const fromColumns = rel.from.columns
+                .map((c) => fromTable.columns.get(c.name))
+                .filter((c) => c !== undefined);
+            const toColumns = rel.to.columns
+                .map((c) => toTable.columns.get(c.name))
+                .filter((c) => c !== undefined);
+            const clonedRel = {
+                ...rel,
+                from: {
+                    table: fromTable,
+                    columns: fromColumns,
+                },
+                to: {
+                    table: toTable,
+                    columns: toColumns,
+                },
+                through: rel.through ? clone.tables.get(rel.through.name) : undefined,
+            };
+            clone.addRelationship(clonedRel);
+        }
+        // Third pass: clone indexes
+        for (const idx of this.indexes) {
+            const table = clone.tables.get(idx.table.name);
+            if (!table)
+                continue;
+            const columns = idx.columns.map((c) => table.columns.get(c.name)).filter((c) => c !== undefined);
+            const clonedIdx = {
+                ...idx,
+                table,
+                columns,
+            };
+            clone.addIndex(clonedIdx);
+        }
+        return clone;
+    }
+    /**
+     * Get statistics about the schema.
+     */
+    getStats() {
+        let columnCount = 0;
+        for (const table of this.tables.values()) {
+            columnCount += table.columns.size;
+        }
+        return {
+            tableCount: this.tables.size,
+            columnCount,
+            relationshipCount: this.relationships.length,
+            indexCount: this.indexes.length,
+        };
+    }
+    /**
+     * Convert schema to a plain object for serialization/debugging.
+     */
+    toJSON() {
+        return {
+            tables: Array.from(this.tables.values()).map((t) => ({
+                name: t.name,
+                columns: Array.from(t.columns.values()).map((c) => ({
+                    name: c.name,
+                    type: c.type,
+                    nullable: c.nullable,
+                    isPrimaryKey: c.isPrimaryKey,
+                    isAutoIncrement: c.isAutoIncrement,
+                    isUnique: c.isUnique,
+                })),
+                indexes: t.indexes.map((i) => ({
+                    name: i.name,
+                    columns: i.columns.map((c) => c.name),
+                    unique: i.unique,
+                })),
+            })),
+            relationships: this.relationships.map((r) => ({
+                name: r.name,
+                type: r.type,
+                from: `${r.from.table.name}.${r.from.columns.map((c) => c.name).join(',')}`,
+                to: `${r.to.table.name}.${r.to.columns.map((c) => c.name).join(',')}`,
+                onDelete: r.onDelete,
+                onUpdate: r.onUpdate,
+            })),
+        };
+    }
+}
+//# sourceMappingURL=schemaAST.js.map