metal-orm 1.0.11 → 1.0.12

package/dist/index.cjs

@@ -20,15 +20,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AsyncLocalStorage: () => AsyncLocalStorage,
+  BaseSchemaDialect: () => BaseSchemaDialect,
   DefaultBelongsToReference: () => DefaultBelongsToReference,
   DefaultHasManyCollection: () => DefaultHasManyCollection,
   DefaultManyToManyCollection: () => DefaultManyToManyCollection,
   DeleteQueryBuilder: () => DeleteQueryBuilder,
   EntityStatus: () => EntityStatus,
   InsertQueryBuilder: () => InsertQueryBuilder,
+  MSSqlSchemaDialect: () => MSSqlSchemaDialect,
   MySqlDialect: () => MySqlDialect,
+  MySqlSchemaDialect: () => MySqlSchemaDialect,
   OrmContext: () => OrmContext,
+  PostgresDialect: () => PostgresDialect,
+  PostgresSchemaDialect: () => PostgresSchemaDialect,
   RelationKinds: () => RelationKinds,
+  SQLiteSchemaDialect: () => SQLiteSchemaDialect,
   SelectQueryBuilder: () => SelectQueryBuilder,
   SqlServerDialect: () => SqlServerDialect,
   SqliteDialect: () => SqliteDialect,
@@ -50,15 +56,22 @@ __export(index_exports, {
   createLiteral: () => createLiteral,
   defineTable: () => defineTable,
   denseRank: () => denseRank,
+  deriveIndexName: () => deriveIndexName,
+  diffSchema: () => diffSchema,
   eq: () => eq,
+  escapeLiteral: () => escapeLiteral,
   executeHydrated: () => executeHydrated,
   exists: () => exists,
   firstValue: () => firstValue,
+  formatLiteral: () => formatLiteral,
+  generateCreateTableSql: () => generateCreateTableSql,
+  generateSchemaSql: () => generateSchemaSql,
   gt: () => gt,
   gte: () => gte,
   hasMany: () => hasMany,
   hydrateRows: () => hydrateRows,
   inList: () => inList,
+  introspectSchema: () => introspectSchema,
   isCaseExpressionNode: () => isCaseExpressionNode,
   isExpressionSelectionNode: () => isExpressionSelectionNode,
   isFunctionNode: () => isFunctionNode,
@@ -83,9 +96,14 @@ __export(index_exports, {
   notLike: () => notLike,
   ntile: () => ntile,
   or: () => or,
+  quoteQualified: () => quoteQualified,
   rank: () => rank,
+  renderColumnDefinition: () => renderColumnDefinition,
+  renderIndexColumns: () => renderIndexColumns,
+  resolvePrimaryKey: () => resolvePrimaryKey,
   rowNumber: () => rowNumber,
   sum: () => sum,
+  synchronizeSchema: () => synchronizeSchema,
   valueToOperand: () => valueToOperand,
   visitExpression: () => visitExpression,
   visitOperand: () => visitOperand,
@@ -94,12 +112,25 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/schema/table.ts
-var defineTable = (name, columns, relations = {}, hooks) => {
+var defineTable = (name, columns, relations = {}, hooks, options = {}) => {
   const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
     acc[key] = { ...def, name: key, table: name };
     return acc;
   }, {});
-  return { name, columns: colsWithNames, relations, hooks };
+  return {
+    name,
+    schema: options.schema,
+    columns: colsWithNames,
+    relations,
+    hooks,
+    primaryKey: options.primaryKey,
+    indexes: options.indexes,
+    checks: options.checks,
+    comment: options.comment,
+    engine: options.engine,
+    charset: options.charset,
+    collation: options.collation
+  };
 };
 
 // src/schema/column.ts
@@ -109,12 +140,52 @@ var col = {
    * @returns ColumnDef with INT type
    */
   int: () => ({ name: "", type: "INT" }),
+  /**
+   * Creates a big integer column definition
+   */
+  bigint: () => ({ name: "", type: "BIGINT" }),
   /**
    * Creates a variable character column definition
    * @param length - Maximum length of the string
    * @returns ColumnDef with VARCHAR type
    */
   varchar: (length) => ({ name: "", type: "VARCHAR", args: [length] }),
+  /**
+   * Creates a fixed precision decimal column definition
+   */
+  decimal: (precision, scale = 0) => ({
+    name: "",
+    type: "DECIMAL",
+    args: [precision, scale]
+  }),
+  /**
+   * Creates a floating point column definition
+   */
+  float: (precision) => ({
+    name: "",
+    type: "FLOAT",
+    args: precision !== void 0 ? [precision] : void 0
+  }),
+  /**
+   * Creates a UUID column definition
+   */
+  uuid: () => ({ name: "", type: "UUID" }),
+  /**
+   * Creates a timestamp column definition
+   */
+  timestamp: () => ({ name: "", type: "TIMESTAMP" }),
+  /**
+   * Creates a timestamptz column definition
+   */
+  timestamptz: () => ({ name: "", type: "TIMESTAMPTZ" }),
+  /**
+   * Creates a date column definition
+   */
+  date: () => ({ name: "", type: "DATE" }),
+  /**
+   * Creates a datetime column definition
+   */
+  datetime: () => ({ name: "", type: "DATETIME" }),
   /**
    * Creates a JSON column definition
    * @returns ColumnDef with JSON type
@@ -125,12 +196,64 @@ var col = {
    * @returns ColumnDef with BOOLEAN type
    */
   boolean: () => ({ name: "", type: "BOOLEAN" }),
+  /**
+   * Creates an enum column definition
+   * @param values - Enum values
+   */
+  enum: (values) => ({ name: "", type: "ENUM", args: values }),
   /**
    * Marks a column definition as a primary key
    * @param def - Column definition to modify
    * @returns Modified ColumnDef with primary: true
    */
-  primaryKey: (def) => ({ ...def, primary: true })
+  primaryKey: (def) => ({ ...def, primary: true }),
+  /**
+   * Marks a column as NOT NULL
+   */
+  notNull: (def) => ({ ...def, notNull: true }),
+  /**
+   * Marks a column as UNIQUE
+   */
+  unique: (def, name) => ({
+    ...def,
+    unique: name ?? true
+  }),
+  /**
+   * Sets a default value for the column
+   */
+  default: (def, value) => ({
+    ...def,
+    default: value
+  }),
+  /**
+   * Sets a raw SQL default value for the column
+   */
+  defaultRaw: (def, expression) => ({
+    ...def,
+    default: { raw: expression }
+  }),
+  /**
+   * Marks a column as auto-increment / identity
+   */
+  autoIncrement: (def, strategy = "byDefault") => ({
+    ...def,
+    autoIncrement: true,
+    generated: strategy
+  }),
+  /**
+   * Adds a foreign key reference
+   */
+  references: (def, ref) => ({
+    ...def,
+    references: ref
+  }),
+  /**
+   * Adds a check constraint to the column
+   */
+  check: (def, expression) => ({
+    ...def,
+    check: expression
+  })
 };
 
 // src/schema/relation.ts
@@ -2994,8 +3117,132 @@ var Dialect = class {
   }
 };
 
+// src/core/dialect/base/sql-dialect.ts
+var SqlDialectBase = class extends Dialect {
+  /**
+   * Compiles SELECT query AST to SQL using common rules.
+   */
+  compileSelectAst(ast, ctx) {
+    const ctes = this.compileCtes(ast, ctx);
+    const columns = this.compileSelectColumns(ast, ctx);
+    const from = this.compileFrom(ast.from);
+    const joins = this.compileJoins(ast, ctx);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const groupBy = this.compileGroupBy(ast);
+    const having = this.compileHaving(ast, ctx);
+    const orderBy = this.compileOrderBy(ast);
+    const pagination = this.compilePagination(ast, orderBy);
+    return `${ctes}SELECT ${this.compileDistinct(ast)}${columns} FROM ${from}${joins}${whereClause}${groupBy}${having}${orderBy}${pagination}`;
+  }
+  compileInsertAst(ast, ctx) {
+    const table = this.compileTableName(ast.into);
+    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
+    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning}`;
+  }
+  compileUpdateAst(ast, ctx) {
+    const table = this.compileTableName(ast.table);
+    const assignments = ast.set.map((assignment) => {
+      const col2 = assignment.column;
+      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(", ");
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning}`;
+  }
+  compileDeleteAst(ast, ctx) {
+    const table = this.compileTableName(ast.from);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${whereClause}${returning}`;
+  }
+  /**
+   * Default RETURNING compilation: no support.
+   */
+  compileReturning(returning, _ctx) {
+    if (!returning || returning.length === 0) return "";
+    throw new Error("RETURNING is not supported by this dialect.");
+  }
+  /**
+   * DISTINCT clause. Override for DISTINCT ON support.
+   */
+  compileDistinct(ast) {
+    return ast.distinct ? "DISTINCT " : "";
+  }
+  compileSelectColumns(ast, ctx) {
+    return ast.columns.map((c) => {
+      const expr = this.compileOperand(c, ctx);
+      if (c.alias) {
+        if (c.alias.includes("(")) return c.alias;
+        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
+      }
+      return expr;
+    }).join(", ");
+  }
+  compileFrom(ast) {
+    const base = this.compileTableName(ast);
+    return ast.alias ? `${base} AS ${this.quoteIdentifier(ast.alias)}` : base;
+  }
+  compileTableName(table) {
+    if (table.schema) {
+      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
+    }
+    return this.quoteIdentifier(table.name);
+  }
+  compileJoins(ast, ctx) {
+    if (!ast.joins || ast.joins.length === 0) return "";
+    const parts = ast.joins.map((j) => {
+      const table = this.compileFrom(j.table);
+      const cond = this.compileExpression(j.condition, ctx);
+      return `${j.kind} JOIN ${table} ON ${cond}`;
+    });
+    return ` ${parts.join(" ")}`;
+  }
+  compileGroupBy(ast) {
+    if (!ast.groupBy || ast.groupBy.length === 0) return "";
+    const cols = ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ");
+    return ` GROUP BY ${cols}`;
+  }
+  compileHaving(ast, ctx) {
+    if (!ast.having) return "";
+    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
+  }
+  compileOrderBy(ast) {
+    if (!ast.orderBy || ast.orderBy.length === 0) return "";
+    const parts = ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ");
+    return ` ORDER BY ${parts}`;
+  }
+  /**
+   * Default LIMIT/OFFSET pagination clause.
+   */
+  compilePagination(ast, _orderByClause) {
+    const parts = [];
+    if (ast.limit !== void 0) parts.push(`LIMIT ${ast.limit}`);
+    if (ast.offset !== void 0) parts.push(`OFFSET ${ast.offset}`);
+    return parts.length ? ` ${parts.join(" ")}` : "";
+  }
+  compileCtes(ast, ctx) {
+    if (!ast.ctes || ast.ctes.length === 0) return "";
+    const hasRecursive = ast.ctes.some((cte) => cte.recursive);
+    const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
+    const cteDefs = ast.ctes.map((cte) => {
+      const name = this.quoteIdentifier(cte.name);
+      const cols = cte.columns && cte.columns.length ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
+      const query = this.stripTrailingSemicolon(this.compileSelectAst(cte.query, ctx));
+      return `${name}${cols} AS (${query})`;
+    }).join(", ");
+    return `${prefix}${cteDefs} `;
+  }
+  stripTrailingSemicolon(sql) {
+    return sql.trim().replace(/;$/, "");
+  }
+};
+
 // src/core/dialect/mysql/index.ts
-var MySqlDialect = class extends Dialect {
+var MySqlDialect = class extends SqlDialectBase {
   /**
    * Creates a new MySqlDialect instance
    */
@@ -3019,78 +3266,6 @@ var MySqlDialect = class extends Dialect {
     const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
     return `${col2}->'${node.path}'`;
   }
-  /**
-   * Compiles SELECT query AST to MySQL SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns MySQL SQL string
-   */
-  compileSelectAst(ast, ctx) {
-    const columns = ast.columns.map((c) => {
-      let expr = "";
-      if (c.type === "Function") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "Column") {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === "ScalarSubquery") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "WindowFunction") {
-        expr = this.compileOperand(c, ctx);
-      }
-      if (c.alias) {
-        if (c.alias.includes("(")) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(", ");
-    const distinct = ast.distinct ? "DISTINCT " : "";
-    const from = `${this.quoteIdentifier(ast.from.name)}`;
-    const joins = ast.joins.map((j) => {
-      const table = this.quoteIdentifier(j.table.name);
-      const cond = this.compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    }).join(" ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
-    const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
-    const orderBy = ast.orderBy && ast.orderBy.length > 0 ? " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ") : "";
-    const limit = ast.limit ? ` LIMIT ${ast.limit}` : "";
-    const offset = ast.offset ? ` OFFSET ${ast.offset}` : "";
-    const ctes = ast.ctes && ast.ctes.length > 0 ? (() => {
-      const hasRecursive = ast.ctes.some((cte) => cte.recursive);
-      const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
-      const cteDefs = ast.ctes.map((cte) => {
-        const name = this.quoteIdentifier(cte.name);
-        const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-        const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, "");
-        return `${name}${cols} AS (${query})`;
-      }).join(", ");
-      return prefix + cteDefs + " ";
-    })() : "";
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
-  compileInsertAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
-    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
-  }
-  compileUpdateAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map((assignment) => {
-      const col2 = assignment.column;
-      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(", ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause};`;
-  }
-  compileDeleteAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
-  }
 };
 
 // src/core/dialect/mssql/index.ts
@@ -3204,7 +3379,7 @@ var SqlServerDialect = class extends Dialect {
 };
 
 // src/core/dialect/sqlite/index.ts
-var SqliteDialect = class extends Dialect {
+var SqliteDialect = class extends SqlDialectBase {
   /**
    * Creates a new SqliteDialect instance
    */
@@ -3228,82 +3403,40 @@ var SqliteDialect = class extends Dialect {
     const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
     return `json_extract(${col2}, '${node.path}')`;
   }
-  /**
-   * Compiles SELECT query AST to SQLite SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQLite SQL string
-   */
-  compileSelectAst(ast, ctx) {
-    const columns = ast.columns.map((c) => {
-      let expr = "";
-      if (c.type === "Function") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "Column") {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === "ScalarSubquery") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "CaseExpression") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "WindowFunction") {
-        expr = this.compileOperand(c, ctx);
-      }
-      if (c.alias) {
-        if (c.alias.includes("(")) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
+  compileReturning(returning, ctx) {
+    if (!returning || returning.length === 0) return "";
+    const columns = returning.map((column) => {
+      const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : "";
+      return `${tablePart}${this.quoteIdentifier(column.name)}`;
     }).join(", ");
-    const distinct = ast.distinct ? "DISTINCT " : "";
-    const from = `${this.quoteIdentifier(ast.from.name)}`;
-    const joins = ast.joins.map((j) => {
-      const table = this.quoteIdentifier(j.table.name);
-      const cond = this.compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    }).join(" ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
-    const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
-    const orderBy = ast.orderBy && ast.orderBy.length > 0 ? " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ") : "";
-    const limit = ast.limit ? ` LIMIT ${ast.limit}` : "";
-    const offset = ast.offset ? ` OFFSET ${ast.offset}` : "";
-    const ctes = ast.ctes && ast.ctes.length > 0 ? (() => {
-      const hasRecursive = ast.ctes.some((cte) => cte.recursive);
-      const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
-      const cteDefs = ast.ctes.map((cte) => {
-        const name = this.quoteIdentifier(cte.name);
-        const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-        const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, "");
-        return `${name}${cols} AS (${query})`;
-      }).join(", ");
-      return prefix + cteDefs + " ";
-    })() : "";
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+    return ` RETURNING ${columns}`;
   }
-  compileInsertAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
-    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
+};
+
+// src/core/dialect/postgres/index.ts
+var PostgresDialect = class extends SqlDialectBase {
+  /**
+   * Creates a new PostgresDialect instance
+   */
+  constructor() {
+    super();
   }
-  compileUpdateAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map((assignment) => {
-      const col2 = assignment.column;
-      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(", ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
+  /**
+   * Quotes an identifier using PostgreSQL double-quote syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id) {
+    return `"${id}"`;
   }
-  compileDeleteAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${table}${whereClause}${returning};`;
+  /**
+   * Compiles JSON path expression using PostgreSQL syntax
+   * @param node - JSON path node
+   * @returns PostgreSQL JSON path expression
+   */
+  compileJsonPath(node) {
+    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `${col2}->>'${node.path}'`;
   }
   compileReturning(returning, ctx) {
     if (!returning || returning.length === 0) return "";
@@ -3315,6 +3448,1100 @@ var SqliteDialect = class extends Dialect {
   }
 };
 
+// src/core/ddl/dialects/base-schema-dialect.ts
+var BaseSchemaDialect = class {
+  supportsPartialIndexes() {
+    return false;
+  }
+  formatTableName(table) {
+    if (table.schema) {
+      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
+    }
+    return this.quoteIdentifier(table.name);
+  }
+  renderDefault(value, _column) {
+    return formatLiteral(value, this.name);
+  }
+  renderReference(ref, _table) {
+    const parts = ["REFERENCES", quoteQualified(this, ref.table), `(${this.quoteIdentifier(ref.column)})`];
+    if (ref.onDelete) parts.push("ON DELETE", ref.onDelete);
+    if (ref.onUpdate) parts.push("ON UPDATE", ref.onUpdate);
+    if (ref.deferrable && this.name === "postgres") parts.push("DEFERRABLE INITIALLY DEFERRED");
+    return parts.join(" ");
+  }
+  renderTableOptions(_table) {
+    return void 0;
+  }
+  dropTableSql(table) {
+    return [`DROP TABLE IF EXISTS ${this.formatTableName(table)};`];
+  }
+  warnDropColumn(_table, _column) {
+    return void 0;
+  }
+};
+
+// src/core/ddl/dialects/postgres-schema-dialect.ts
+var PostgresSchemaDialect = class extends BaseSchemaDialect {
+  constructor() {
+    super(...arguments);
+    this.name = "postgres";
+  }
+  quoteIdentifier(id) {
+    return `"${id}"`;
+  }
+  renderColumnType(column) {
+    switch (column.type) {
+      case "INT":
+      case "INTEGER":
+      case "int":
+      case "integer":
+        return "integer";
+      case "BIGINT":
+      case "bigint":
+        return "bigint";
+      case "UUID":
+      case "uuid":
+        return "uuid";
+      case "BOOLEAN":
+      case "boolean":
+        return "boolean";
+      case "JSON":
+      case "json":
+        return "jsonb";
+      case "DECIMAL":
+      case "decimal":
+        return column.args?.length ? `numeric(${column.args[0]}, ${column.args[1] ?? 0})` : "numeric";
+      case "FLOAT":
+      case "float":
+      case "DOUBLE":
+      case "double":
+        return "double precision";
+      case "TIMESTAMPTZ":
+      case "timestamptz":
+        return "timestamptz";
+      case "TIMESTAMP":
+      case "timestamp":
+        return "timestamp";
+      case "DATE":
+      case "date":
+        return "date";
+      case "DATETIME":
+      case "datetime":
+        return "timestamp";
+      case "VARCHAR":
+      case "varchar":
+        return column.args?.length ? `varchar(${column.args[0]})` : "varchar";
+      case "TEXT":
+      case "text":
+        return "text";
+      case "ENUM":
+      case "enum":
+        return "text";
+      default:
+        return String(column.type).toLowerCase();
+    }
+  }
+  renderAutoIncrement(column) {
+    if (!column.autoIncrement) return void 0;
+    const strategy = column.generated === "always" ? "GENERATED ALWAYS" : "GENERATED BY DEFAULT";
+    return `${strategy} AS IDENTITY`;
+  }
+  renderIndex(table, index) {
+    const name = index.name || deriveIndexName(table, index);
+    const cols = renderIndexColumns(this, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    const where = index.where ? ` WHERE ${index.where}` : "";
+    return `CREATE ${unique}INDEX IF NOT EXISTS ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols})${where};`;
+  }
+  supportsPartialIndexes() {
+    return true;
+  }
+  dropColumnSql(table, column) {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+  dropIndexSql(table, index) {
+    const qualified = table.schema ? `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(index)}` : this.quoteIdentifier(index);
+    return [`DROP INDEX IF EXISTS ${qualified};`];
+  }
+};
+
+// src/core/ddl/dialects/mysql-schema-dialect.ts
+var MySqlSchemaDialect = class extends BaseSchemaDialect {
+  constructor() {
+    super(...arguments);
+    this.name = "mysql";
+  }
+  quoteIdentifier(id) {
+    return `\`${id}\``;
+  }
+  renderColumnType(column) {
+    switch (column.type) {
+      case "INT":
+      case "INTEGER":
+      case "int":
+      case "integer":
+        return "INT";
+      case "BIGINT":
+      case "bigint":
+        return "BIGINT";
+      case "UUID":
+      case "uuid":
+        return "CHAR(36)";
+      case "BOOLEAN":
+      case "boolean":
+        return "TINYINT(1)";
+      case "JSON":
+      case "json":
+        return "JSON";
+      case "DECIMAL":
+      case "decimal":
+        return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : "DECIMAL";
+      case "FLOAT":
+      case "float":
+        return column.args?.length ? `FLOAT(${column.args[0]})` : "FLOAT";
+      case "DOUBLE":
+      case "double":
+        return "DOUBLE";
+      case "TIMESTAMPTZ":
+      case "timestamptz":
+        return "TIMESTAMP";
+      case "TIMESTAMP":
+      case "timestamp":
+        return "TIMESTAMP";
+      case "DATETIME":
+      case "datetime":
+        return "DATETIME";
+      case "DATE":
+      case "date":
+        return "DATE";
+      case "VARCHAR":
+      case "varchar":
+        return column.args?.length ? `VARCHAR(${column.args[0]})` : "VARCHAR(255)";
+      case "TEXT":
+      case "text":
+        return "TEXT";
+      case "ENUM":
+      case "enum":
+        return column.args && Array.isArray(column.args) && column.args.length ? `ENUM(${column.args.map((v) => `'${escapeLiteral(v)}'`).join(",")})` : "ENUM";
+      default:
+        return String(column.type).toUpperCase();
+    }
+  }
+  renderDefault(value) {
+    return formatLiteral(value, this.name);
+  }
+  renderAutoIncrement(column) {
+    return column.autoIncrement ? "AUTO_INCREMENT" : void 0;
+  }
+  renderIndex(table, index) {
+    if (index.where) {
+      throw new Error("MySQL does not support partial/filtered indexes");
+    }
+    const name = index.name || deriveIndexName(table, index);
+    const cols = renderIndexColumns(this, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    return `CREATE ${unique}INDEX ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols});`;
+  }
+  renderTableOptions(table) {
+    const parts = [];
+    if (table.engine) parts.push(`ENGINE=${table.engine}`);
+    if (table.charset) parts.push(`DEFAULT CHARSET=${table.charset}`);
+    if (table.collation) parts.push(`COLLATE=${table.collation}`);
+    return parts.length ? parts.join(" ") : void 0;
+  }
+  dropColumnSql(table, column) {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+  dropIndexSql(table, index) {
+    return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
+  }
+};
+
+// src/core/ddl/dialects/sqlite-schema-dialect.ts
+var SQLiteSchemaDialect = class extends BaseSchemaDialect {
+  constructor() {
+    super(...arguments);
+    this.name = "sqlite";
+  }
+  quoteIdentifier(id) {
+    return `"${id}"`;
+  }
+  renderColumnType(column) {
+    switch (column.type) {
+      case "INT":
+      case "INTEGER":
+      case "int":
+      case "integer":
+      case "BIGINT":
+      case "bigint":
+        return "INTEGER";
+      case "BOOLEAN":
+      case "boolean":
+        return "INTEGER";
+      case "DECIMAL":
+      case "decimal":
+      case "FLOAT":
+      case "float":
+      case "DOUBLE":
+      case "double":
+        return "REAL";
+      case "DATE":
+      case "date":
+      case "DATETIME":
+      case "datetime":
+      case "TIMESTAMP":
+      case "timestamp":
+      case "TIMESTAMPTZ":
+      case "timestamptz":
+        return "TEXT";
+      case "VARCHAR":
+      case "varchar":
+      case "TEXT":
+      case "text":
+      case "JSON":
+      case "json":
+      case "UUID":
+      case "uuid":
+        return "TEXT";
+      case "ENUM":
+      case "enum":
+        return "TEXT";
+      default:
+        return "TEXT";
+    }
+  }
+  renderAutoIncrement(column, table) {
+    const pk = resolvePrimaryKey(table);
+    if (column.autoIncrement && pk.length === 1 && pk[0] === column.name) {
+      return "PRIMARY KEY AUTOINCREMENT";
+    }
+    return void 0;
+  }
+  preferInlinePkAutoincrement(column, table, pk) {
+    return !!(column.autoIncrement && pk.length === 1 && pk[0] === column.name);
+  }
+  renderDefault(value) {
+    return formatLiteral(value, this.name);
+  }
+  renderIndex(table, index) {
+    if (index.where) {
+      throw new Error("SQLite does not support partial/filtered indexes");
+    }
+    const name = index.name || deriveIndexName(table, index);
+    const cols = renderIndexColumns(this, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    return `CREATE ${unique}INDEX IF NOT EXISTS ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols});`;
+  }
+  dropColumnSql(_table, _column) {
+    return [];
+  }
+  dropIndexSql(_table, index) {
+    return [`DROP INDEX IF EXISTS ${this.quoteIdentifier(index)};`];
+  }
+  warnDropColumn(table, column) {
+    const key = table.schema ? `${table.schema}.${table.name}` : table.name;
+    return `Dropping columns on SQLite requires table rebuild (column ${column} on ${key}).`;
+  }
+};
+
+// src/core/ddl/dialects/mssql-schema-dialect.ts
+var MSSqlSchemaDialect = class extends BaseSchemaDialect {
+  constructor() {
+    super(...arguments);
+    this.name = "mssql";
+  }
+  quoteIdentifier(id) {
+    return `[${id.replace(/]/g, "]]")}]`;
+  }
+  renderColumnType(column) {
+    switch (column.type) {
+      case "INT":
+      case "INTEGER":
+      case "int":
+      case "integer":
+        return "INT";
+      case "BIGINT":
+      case "bigint":
+        return "BIGINT";
+      case "UUID":
+      case "uuid":
+        return "UNIQUEIDENTIFIER";
+      case "BOOLEAN":
+      case "boolean":
+        return "BIT";
+      case "JSON":
+      case "json":
+        return "NVARCHAR(MAX)";
+      case "DECIMAL":
+      case "decimal":
+        return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : "DECIMAL(18,0)";
+      case "FLOAT":
+      case "float":
+      case "DOUBLE":
+      case "double":
+        return "FLOAT";
+      case "TIMESTAMPTZ":
+      case "timestamptz":
+      case "TIMESTAMP":
+      case "timestamp":
+      case "DATETIME":
+      case "datetime":
+        return "DATETIME2";
+      case "DATE":
+      case "date":
+        return "DATE";
+      case "VARCHAR":
+      case "varchar":
+        return column.args?.length ? `NVARCHAR(${column.args[0]})` : "NVARCHAR(255)";
+      case "TEXT":
+      case "text":
+        return "NVARCHAR(MAX)";
+      case "ENUM":
+      case "enum":
+        return "NVARCHAR(255)";
+      default:
+        return String(column.type).toUpperCase();
+    }
+  }
+  renderDefault(value) {
+    return formatLiteral(value, this.name);
+  }
+  renderAutoIncrement(column) {
+    return column.autoIncrement ? "IDENTITY(1,1)" : void 0;
+  }
+  renderIndex(table, index) {
+    const name = index.name || deriveIndexName(table, index);
+    const cols = renderIndexColumns(this, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    const where = index.where ? ` WHERE ${index.where}` : "";
+    return `CREATE ${unique}INDEX ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols})${where};`;
+  }
+  supportsPartialIndexes() {
+    return true;
+  }
+  dropColumnSql(table, column) {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+  dropIndexSql(table, index) {
+    return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
+  }
+};
+
+// src/core/ddl/schema-generator.ts
+var escapeLiteral = (value) => value.replace(/'/g, "''");
+var isRawDefault = (value) => {
+  return !!value && typeof value === "object" && "raw" in value && typeof value.raw === "string";
+};
+var formatLiteral = (value, dialect) => {
+  if (isRawDefault(value)) return value.raw;
+  if (value === null) return "NULL";
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
+  if (typeof value === "boolean") {
+    if (dialect === "mysql" || dialect === "sqlite" || dialect === "mssql") {
+      return value ? "1" : "0";
+    }
+    return value ? "TRUE" : "FALSE";
+  }
+  if (value instanceof Date) return `'${escapeLiteral(value.toISOString())}'`;
+  if (typeof value === "string") return `'${escapeLiteral(value)}'`;
+  return `'${escapeLiteral(JSON.stringify(value))}'`;
+};
+var resolvePrimaryKey = (table) => {
+  if (table.primaryKey && table.primaryKey.length > 0) {
+    return table.primaryKey;
+  }
+  const cols = Object.values(table.columns);
+  return cols.filter((c) => c.primary).map((c) => c.name);
+};
+var quoteQualified = (dialect, identifier) => {
+  if (identifier.includes(".")) {
+    return identifier.split(".").map((part) => dialect.quoteIdentifier(part)).join(".");
+  }
+  return dialect.quoteIdentifier(identifier);
+};
+var renderIndexColumns = (dialect, columns) => {
+  return columns.map((col2) => {
+    if (typeof col2 === "string") return dialect.quoteIdentifier(col2);
+    const parts = [dialect.quoteIdentifier(col2.column)];
+    if (col2.order) parts.push(col2.order);
+    if (col2.nulls) parts.push(`NULLS ${col2.nulls}`);
+    return parts.join(" ");
+  }).join(", ");
+};
+var deriveIndexName = (table, index) => {
+  const base = (index.columns || []).map((col2) => typeof col2 === "string" ? col2 : col2.column).join("_");
+  const suffix = index.unique ? "uniq" : "idx";
+  return `${table.name}_${base}_${suffix}`;
+};
+var renderColumnDefinition = (table, col2, dialect, options = {}) => {
+  const parts = [];
+  parts.push(dialect.quoteIdentifier(col2.name));
+  parts.push(dialect.renderColumnType(col2));
+  const autoInc = dialect.renderAutoIncrement(col2, table);
+  if (autoInc) parts.push(autoInc);
+  if (col2.notNull) parts.push("NOT NULL");
+  if (col2.unique) parts.push("UNIQUE");
+  if (col2.default !== void 0) {
+    parts.push(`DEFAULT ${dialect.renderDefault(col2.default, col2)}`);
+  }
+  if (options.includePrimary && col2.primary) {
+    parts.push("PRIMARY KEY");
+  }
+  if (col2.check) {
+    parts.push(`CHECK (${col2.check})`);
+  }
+  if (col2.references) {
+    parts.push(dialect.renderReference(col2.references, table));
+  }
+  return { sql: parts.join(" "), inlinePrimary: !!(options.includePrimary && col2.primary) };
+};
+var generateCreateTableSql = (table, dialect) => {
+  const pk = resolvePrimaryKey(table);
+  const inlinePkColumns = /* @__PURE__ */ new Set();
+  const columnLines = Object.values(table.columns).map((col2) => {
+    const includePk = dialect.preferInlinePkAutoincrement?.(col2, table, pk) && pk.includes(col2.name);
+    if (includePk) {
+      inlinePkColumns.add(col2.name);
+    }
+    return renderColumnDefinition(table, col2, dialect, { includePrimary: includePk }).sql;
+  });
+  const constraintLines = [];
+  if (pk.length > 0 && !(pk.length === 1 && inlinePkColumns.has(pk[0]))) {
+    const cols = pk.map((c) => dialect.quoteIdentifier(c)).join(", ");
+    constraintLines.push(`PRIMARY KEY (${cols})`);
+  }
+  if (table.checks) {
+    table.checks.forEach((check) => {
+      const name = check.name ? `${dialect.quoteIdentifier(check.name)} ` : "";
+      constraintLines.push(`CONSTRAINT ${name}CHECK (${check.expression})`);
+    });
+  }
+  const allLines = [...columnLines, ...constraintLines];
+  const body = allLines.map((line) => `  ${line}`).join(",\n");
+  const tableOptions = dialect.renderTableOptions(table);
+  const tableSql = `CREATE TABLE ${dialect.formatTableName(table)} (
+${body}
+)${tableOptions ? " " + tableOptions : ""};`;
+  const indexSql = [];
+  if (table.indexes && table.indexes.length > 0) {
+    for (const idx of table.indexes) {
+      if (idx.where && !dialect.supportsPartialIndexes()) {
+        throw new Error(`Dialect ${dialect.name} does not support partial/filtered indexes (${idx.name || idx.columns.join("_")}).`);
+      }
+      indexSql.push(dialect.renderIndex(table, idx));
+    }
+  }
+  return { tableSql, indexSql };
+};
+var generateSchemaSql = (tables, dialect) => {
+  const ordered = orderTablesByDependencies(tables);
+  const statements = [];
+  ordered.forEach((table) => {
+    const { tableSql, indexSql } = generateCreateTableSql(table, dialect);
+    statements.push(tableSql, ...indexSql);
+  });
+  return statements;
+};
+var orderTablesByDependencies = (tables) => {
+  const map = /* @__PURE__ */ new Map();
+  tables.forEach((t) => map.set(t.name, t));
+  const deps = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    const refTables = /* @__PURE__ */ new Set();
+    Object.values(table.columns).forEach((col2) => {
+      if (col2.references?.table) {
+        refTables.add(col2.references.table);
+      }
+    });
+    deps.set(table.name, refTables);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const visit = (name, stack) => {
+    if (visited.has(name)) return;
+    const table = map.get(name);
+    if (!table) return;
+    if (stack.has(name)) {
+      ordered.push(table);
+      visited.add(name);
+      return;
+    }
+    stack.add(name);
+    for (const dep of deps.get(name) || []) {
+      visit(dep, stack);
+    }
+    stack.delete(name);
+    visited.add(name);
+    ordered.push(table);
+  };
+  tables.forEach((t) => visit(t.name, /* @__PURE__ */ new Set()));
+  return ordered;
+};
+
+// src/core/ddl/schema-diff.ts
+var tableKey = (name, schema) => schema ? `${schema}.${name}` : name;
+var mapTables = (schema) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const table of schema.tables) {
+    map.set(tableKey(table.name, table.schema), table);
+  }
+  return map;
+};
+var buildAddColumnSql = (table, colName, dialect) => {
+  const column = table.columns[colName];
+  const rendered = renderColumnDefinition(table, column, dialect);
+  return `ALTER TABLE ${dialect.formatTableName(table)} ADD ${rendered.sql};`;
+};
+var diffSchema = (expectedTables, actualSchema, dialect, options = {}) => {
+  const allowDestructive = options.allowDestructive ?? false;
+  const plan = { changes: [], warnings: [] };
+  const actualMap = mapTables(actualSchema);
+  for (const table of expectedTables) {
+    const key = tableKey(table.name, table.schema);
+    const actual = actualMap.get(key);
+    if (!actual) {
+      const { tableSql, indexSql } = generateCreateTableSql(table, dialect);
+      plan.changes.push({
+        kind: "createTable",
+        table: key,
+        description: `Create table ${key}`,
+        statements: [tableSql, ...indexSql],
+        safe: true
+      });
+      continue;
+    }
+    const actualCols = new Map(actual.columns.map((c) => [c.name, c]));
+    for (const colName of Object.keys(table.columns)) {
+      if (!actualCols.has(colName)) {
+        plan.changes.push({
+          kind: "addColumn",
+          table: key,
+          description: `Add column ${colName} to ${key}`,
+          statements: [buildAddColumnSql(table, colName, dialect)],
+          safe: true
+        });
+      }
+    }
+    for (const colName of actualCols.keys()) {
+      if (!table.columns[colName]) {
+        plan.changes.push({
+          kind: "dropColumn",
+          table: key,
+          description: `Drop column ${colName} from ${key}`,
+          statements: allowDestructive ? dialect.dropColumnSql(actual, colName) : [],
+          safe: false
+        });
+        const warning = dialect.warnDropColumn?.(actual, colName);
+        if (warning) plan.warnings.push(warning);
+      }
+    }
+    const expectedIndexes = table.indexes ?? [];
+    const actualIndexes = actual.indexes ?? [];
+    const actualIndexMap = new Map(actualIndexes.map((idx) => [idx.name, idx]));
+    for (const idx of expectedIndexes) {
+      const name = idx.name || deriveIndexName(table, idx);
+      if (!actualIndexMap.has(name)) {
+        plan.changes.push({
+          kind: "addIndex",
+          table: key,
+          description: `Create index ${name} on ${key}`,
+          statements: [dialect.renderIndex(table, { ...idx, name })],
+          safe: true
+        });
+      }
+    }
+    for (const idx of actualIndexes) {
+      if (idx.name && !expectedIndexes.find((expected) => (expected.name || deriveIndexName(table, expected)) === idx.name)) {
+        plan.changes.push({
+          kind: "dropIndex",
+          table: key,
+          description: `Drop index ${idx.name} on ${key}`,
+          statements: allowDestructive ? dialect.dropIndexSql(actual, idx.name) : [],
+          safe: false
+        });
+      }
+    }
+  }
+  for (const actual of actualSchema.tables) {
+    const key = tableKey(actual.name, actual.schema);
+    if (!expectedTables.find((t) => tableKey(t.name, t.schema) === key)) {
+      plan.changes.push({
+        kind: "dropTable",
+        table: key,
+        description: `Drop table ${key}`,
+        statements: allowDestructive ? dialect.dropTableSql(actual) : [],
+        safe: false
+      });
+    }
+  }
+  return plan;
+};
+var synchronizeSchema = async (expectedTables, actualSchema, dialect, executor, options = {}) => {
+  const plan = diffSchema(expectedTables, actualSchema, dialect, options);
+  if (options.dryRun) return plan;
+  for (const change of plan.changes) {
+    if (!change.statements.length) continue;
+    if (!change.safe && !options.allowDestructive) continue;
+    for (const stmt of change.statements) {
+      if (!stmt.trim()) continue;
+      await executor.executeSql(stmt);
+    }
+  }
+  return plan;
+};
+
+// src/core/ddl/introspect/utils.ts
+var toRows = (result) => {
+  if (!result) return [];
+  return result.values.map(
+    (row) => result.columns.reduce((acc, col2, idx) => {
+      acc[col2] = row[idx];
+      return acc;
+    }, {})
+  );
+};
+var queryRows = async (executor, sql, params = []) => {
+  const [first] = await executor.executeSql(sql, params);
+  return toRows(first);
+};
+var shouldIncludeTable = (name, options) => {
+  if (options.includeTables && !options.includeTables.includes(name)) return false;
+  if (options.excludeTables && options.excludeTables.includes(name)) return false;
+  return true;
+};
+
+// src/core/ddl/introspect/postgres.ts
+var postgresIntrospector = {
+  async introspect(executor, options) {
+    const schema = options.schema || "public";
+    const tables = [];
+    const columnRows = await queryRows(
+      executor,
+      `
+      SELECT table_schema, table_name, column_name, data_type, is_nullable, column_default
+      FROM information_schema.columns
+      WHERE table_schema = $1
+      ORDER BY table_name, ordinal_position
+      `,
+      [schema]
+    );
+    const pkRows = await queryRows(
+      executor,
+      `
+      SELECT
+        ns.nspname AS table_schema,
+        tbl.relname AS table_name,
+        array_agg(att.attname ORDER BY arr.idx) AS pk_columns
+      FROM pg_index i
+      JOIN pg_class tbl ON tbl.oid = i.indrelid
+      JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+      JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS arr(attnum, idx) ON TRUE
+      LEFT JOIN pg_attribute att ON att.attrelid = tbl.oid AND att.attnum = arr.attnum
+      WHERE i.indisprimary AND ns.nspname = $1
+      GROUP BY ns.nspname, tbl.relname
+      `,
+      [schema]
+    );
+    const pkMap = /* @__PURE__ */ new Map();
+    pkRows.forEach((r) => {
+      pkMap.set(`${r.table_schema}.${r.table_name}`, r.pk_columns || []);
+    });
+    const fkRows = await queryRows(
+      executor,
+      `
+      SELECT
+        tc.table_schema,
+        tc.table_name,
+        kcu.column_name,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.update_rule AS on_update,
+        rc.delete_rule AS on_delete
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+      JOIN information_schema.referential_constraints rc
+        ON rc.constraint_name = tc.constraint_name AND rc.constraint_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1
+      `,
+      [schema]
+    );
+    const fkMap = /* @__PURE__ */ new Map();
+    fkRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      fkMap.set(key, [{
+        table: `${r.foreign_table_schema}.${r.foreign_table_name}`,
+        column: r.foreign_column_name,
+        onDelete: r.on_delete?.toUpperCase(),
+        onUpdate: r.on_update?.toUpperCase()
+      }]);
+    });
+    const indexRows = await queryRows(
+      executor,
+      `
+      SELECT
+        ns.nspname AS table_schema,
+        tbl.relname AS table_name,
+        idx.relname AS index_name,
+        i.indisunique AS is_unique,
+        pg_get_expr(i.indpred, i.indrelid) AS predicate,
+        array_agg(att.attname ORDER BY arr.idx) AS column_names
+      FROM pg_index i
+      JOIN pg_class tbl ON tbl.oid = i.indrelid
+      JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+      JOIN pg_class idx ON idx.oid = i.indexrelid
+      JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS arr(attnum, idx) ON TRUE
+      LEFT JOIN pg_attribute att ON att.attrelid = tbl.oid AND att.attnum = arr.attnum
+      WHERE ns.nspname = $1 AND NOT i.indisprimary
+      GROUP BY ns.nspname, tbl.relname, idx.relname, i.indisunique, i.indpred
+      `,
+      [schema]
+    );
+    const tablesByKey = /* @__PURE__ */ new Map();
+    columnRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!shouldIncludeTable(r.table_name, options)) {
+        return;
+      }
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const cols = tablesByKey.get(key);
+      const fk = fkMap.get(`${r.table_schema}.${r.table_name}.${r.column_name}`)?.[0];
+      const column = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === "NO",
+        default: r.column_default ?? void 0,
+        references: fk ? {
+          table: fk.table,
+          column: fk.column,
+          onDelete: fk.onDelete,
+          onUpdate: fk.onUpdate
+        } : void 0
+      };
+      cols.columns.push(column);
+    });
+    indexRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const idx = {
+        name: r.index_name,
+        columns: (r.column_names || []).map((c) => ({ column: c })),
+        unique: !!r.is_unique,
+        where: r.predicate || void 0
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+    tables.push(...tablesByKey.values());
+    return { tables };
+  }
+};
+
+// src/core/ddl/introspect/mysql.ts
+var mysqlIntrospector = {
+  async introspect(executor, options) {
+    const schema = options.schema;
+    const filterClause = schema ? "table_schema = ?" : "table_schema = database()";
+    const params = schema ? [schema] : [];
+    const columnRows = await queryRows(
+      executor,
+      `
+      SELECT table_schema, table_name, column_name, data_type, is_nullable, column_default, extra
+      FROM information_schema.columns
+      WHERE ${filterClause}
+      ORDER BY table_name, ordinal_position
+      `,
+      params
+    );
+    const pkRows = await queryRows(
+      executor,
+      `
+      SELECT table_schema, table_name, column_name
+      FROM information_schema.key_column_usage
+      WHERE constraint_name = 'PRIMARY' AND ${filterClause}
+      ORDER BY ordinal_position
+      `,
+      params
+    );
+    const pkMap = /* @__PURE__ */ new Map();
+    pkRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const list = pkMap.get(key) || [];
+      list.push(r.column_name);
+      pkMap.set(key, list);
+    });
+    const indexRows = await queryRows(
+      executor,
+      `
+      SELECT
+        table_schema,
+        table_name,
+        index_name,
+        non_unique,
+        GROUP_CONCAT(column_name ORDER BY seq_in_index) AS cols
+      FROM information_schema.statistics
+      WHERE ${filterClause} AND index_name <> 'PRIMARY'
+      GROUP BY table_schema, table_name, index_name, non_unique
+      `,
+      params
+    );
+    const tablesByKey = /* @__PURE__ */ new Map();
+    columnRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const cols = tablesByKey.get(key);
+      const column = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === "NO",
+        default: r.column_default ?? void 0,
+        autoIncrement: typeof r.extra === "string" && r.extra.includes("auto_increment")
+      };
+      cols.columns.push(column);
+    });
+    indexRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const cols = (typeof r.cols === "string" ? r.cols.split(",") : []).map((c) => ({ column: c.trim() }));
+      const idx = {
+        name: r.index_name,
+        columns: cols,
+        unique: r.non_unique === 0
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+    return { tables: Array.from(tablesByKey.values()) };
+  }
+};
+
+// src/core/ddl/introspect/sqlite.ts
+var escapeSingleQuotes = (name) => name.replace(/'/g, "''");
+var sqliteIntrospector = {
+  async introspect(executor, options) {
+    const tables = [];
+    const tableRows = await queryRows(
+      executor,
+      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%';`
+    );
+    for (const row of tableRows) {
+      const name = row.name;
+      if (!shouldIncludeTable(name, options)) continue;
+      const table = { name, columns: [], primaryKey: [], indexes: [] };
+      const cols = await queryRows(executor, `PRAGMA table_info('${escapeSingleQuotes(name)}');`);
+      cols.forEach((c) => {
+        table.columns.push({
+          name: c.name,
+          type: c.type,
+          notNull: c.notnull === 1,
+          default: c.dflt_value ?? void 0,
+          autoIncrement: false
+        });
+        if (c.pk && c.pk > 0) {
+          table.primaryKey = table.primaryKey || [];
+          table.primaryKey.push(c.name);
+        }
+      });
+      const fkRows = await queryRows(executor, `PRAGMA foreign_key_list('${escapeSingleQuotes(name)}');`);
+      fkRows.forEach((fk) => {
+        const col2 = table.columns.find((c) => c.name === fk.from);
+        if (col2) {
+          col2.references = {
+            table: fk.table,
+            column: fk.to,
+            onDelete: fk.on_delete?.toUpperCase(),
+            onUpdate: fk.on_update?.toUpperCase()
+          };
+        }
+      });
+      const idxList = await queryRows(executor, `PRAGMA index_list('${escapeSingleQuotes(name)}');`);
+      for (const idx of idxList) {
+        const idxName = idx.name;
+        const columnsInfo = await queryRows(executor, `PRAGMA index_info('${escapeSingleQuotes(idxName)}');`);
+        const idxEntry = {
+          name: idxName,
+          columns: columnsInfo.map((ci) => ({ column: ci.name })),
+          unique: idx.unique === 1
+        };
+        table.indexes.push(idxEntry);
+      }
+      tables.push(table);
+    }
+    return { tables };
+  }
+};
+
+// src/core/ddl/introspect/mssql.ts
+var mssqlIntrospector = {
+  async introspect(executor, options) {
+    const schema = options.schema;
+    const filterSchema = schema ? "sch.name = @p1" : "1=1";
+    const params = schema ? [schema] : [];
+    const columnRows = await queryRows(
+      executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        c.name AS column_name,
+        ty.name AS data_type,
+        c.is_nullable,
+        c.is_identity,
+        object_definition(c.default_object_id) AS column_default
+      FROM sys.columns c
+      JOIN sys.tables t ON t.object_id = c.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      JOIN sys.types ty ON ty.user_type_id = c.user_type_id
+      WHERE t.is_ms_shipped = 0 AND ${filterSchema}
+      `,
+      params
+    );
+    const pkRows = await queryRows(
+      executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        c.name AS column_name,
+        ic.key_ordinal
+      FROM sys.indexes i
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE i.is_primary_key = 1 AND ${filterSchema}
+      ORDER BY ic.key_ordinal
+      `,
+      params
+    );
+    const pkMap = /* @__PURE__ */ new Map();
+    pkRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const list = pkMap.get(key) || [];
+      list.push(r.column_name);
+      pkMap.set(key, list);
+    });
+    const indexRows = await queryRows(
+      executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        i.name AS index_name,
+        i.is_unique,
+        i.has_filter,
+        i.filter_definition
+      FROM sys.indexes i
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE i.is_primary_key = 0 AND i.is_hypothetical = 0 AND ${filterSchema}
+      `,
+      params
+    );
+    const indexColsRows = await queryRows(
+      executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        i.name AS index_name,
+        c.name AS column_name,
+        ic.key_ordinal
+      FROM sys.index_columns ic
+      JOIN sys.indexes i ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
+      WHERE i.is_primary_key = 0 AND ${filterSchema}
+      ORDER BY ic.key_ordinal
+      `,
+      params
+    );
+    const indexColumnsMap = /* @__PURE__ */ new Map();
+    indexColsRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}.${r.index_name}`;
+      const list = indexColumnsMap.get(key) || [];
+      list.push({ column: r.column_name, order: r.key_ordinal });
+      indexColumnsMap.set(key, list);
+    });
+    const tablesByKey = /* @__PURE__ */ new Map();
+    columnRows.forEach((r) => {
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const t = tablesByKey.get(key);
+      const column = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === false || r.is_nullable === 0,
+        default: r.column_default ?? void 0,
+        autoIncrement: !!r.is_identity
+      };
+      t.columns.push(column);
+    });
+    indexRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const cols = (indexColumnsMap.get(`${r.table_schema}.${r.table_name}.${r.index_name}`) || []).sort((a, b) => a.order - b.order).map((c) => ({ column: c.column }));
+      const idx = {
+        name: r.index_name,
+        columns: cols,
+        unique: !!r.is_unique,
+        where: r.has_filter ? r.filter_definition : void 0
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+    return { tables: Array.from(tablesByKey.values()) };
+  }
+};
+
+// src/core/ddl/schema-introspect.ts
+var INTROSPECTORS = {
+  postgres: postgresIntrospector,
+  mysql: mysqlIntrospector,
+  sqlite: sqliteIntrospector,
+  mssql: mssqlIntrospector
+};
+var introspectSchema = async (executor, dialect, options = {}) => {
+  const handler = INTROSPECTORS[dialect];
+  if (!handler) {
+    throw new Error(`Unsupported dialect for introspection: ${dialect}`);
+  }
+  return handler.introspect(executor, options);
+};
+
 // src/orm/als.ts
 var AsyncLocalStorage = class {
   /**
@@ -4153,15 +5380,21 @@ var OrmContext = class {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AsyncLocalStorage,
+  BaseSchemaDialect,
   DefaultBelongsToReference,
   DefaultHasManyCollection,
   DefaultManyToManyCollection,
   DeleteQueryBuilder,
   EntityStatus,
   InsertQueryBuilder,
+  MSSqlSchemaDialect,
   MySqlDialect,
+  MySqlSchemaDialect,
   OrmContext,
+  PostgresDialect,
+  PostgresSchemaDialect,
   RelationKinds,
+  SQLiteSchemaDialect,
   SelectQueryBuilder,
   SqlServerDialect,
   SqliteDialect,
@@ -4183,15 +5416,22 @@ var OrmContext = class {
   createLiteral,
   defineTable,
   denseRank,
+  deriveIndexName,
+  diffSchema,
   eq,
+  escapeLiteral,
   executeHydrated,
   exists,
   firstValue,
+  formatLiteral,
+  generateCreateTableSql,
+  generateSchemaSql,
   gt,
   gte,
   hasMany,
   hydrateRows,
   inList,
+  introspectSchema,
   isCaseExpressionNode,
   isExpressionSelectionNode,
   isFunctionNode,
@@ -4216,9 +5456,14 @@ var OrmContext = class {
   notLike,
   ntile,
   or,
+  quoteQualified,
   rank,
+  renderColumnDefinition,
+  renderIndexColumns,
+  resolvePrimaryKey,
   rowNumber,
   sum,
+  synchronizeSchema,
   valueToOperand,
   visitExpression,
   visitOperand,