tempest-db-js 0.4.0 → 0.6.0

package/dist/bin.cjs

@@ -5,8 +5,218 @@ var fs = require('fs');
 var path = require('path');
 var promises = require('readline/promises');
 var url = require('url');
+var module$1 = require('module');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/expressions.ts
+function renderPortableToken(token, dialect) {
+  switch (token) {
+    case "now":
+      return dialect === "postgresql" ? "now()" : "CURRENT_TIMESTAMP";
+    case "current_date":
+      return "CURRENT_DATE";
+    case "current_time":
+      return "CURRENT_TIME";
+    case "uuidv4":
+      if (dialect === "postgresql") return "gen_random_uuid()";
+      if (dialect === "mysql") return "(UUID())";
+      return "(lower(hex(randomblob(16))))";
+  }
+}
+
+// src/index.ts
+function isDefaultValue(value) {
+  return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
+}
+function bindsParameters(value) {
+  return value.kind === "expression" && typeof value.expression === "object" && "parts" in value.expression;
+}
+function parseReference(ref, options) {
+  const dot = ref.lastIndexOf(".");
+  if (dot <= 0 || dot === ref.length - 1) {
+    throw new Error(`Invalid foreign key reference "${ref}"; expected "table.column".`);
+  }
+  return {
+    table: ref.slice(0, dot),
+    column: ref.slice(dot + 1),
+    onDelete: options?.onDelete,
+    onUpdate: options?.onUpdate
+  };
+}
+var Column = class _Column {
+  constructor(type, flags, defaultValue = null, onUpdateValue = null, reference = null, dbName = null) {
+    this.type = type;
+    this.flags = flags;
+    this.defaultValue = defaultValue;
+    this.onUpdateValue = onUpdateValue;
+    this.reference = reference;
+    this.dbName = dbName;
+  }
+  type;
+  flags;
+  defaultValue;
+  onUpdateValue;
+  reference;
+  dbName;
+  /** Clone this column with one facet replaced, carrying every other over. */
+  derive(patch) {
+    return new _Column(
+      this.type,
+      patch.flags ?? this.flags,
+      patch.defaultValue !== void 0 ? patch.defaultValue : this.defaultValue,
+      patch.onUpdateValue !== void 0 ? patch.onUpdateValue : this.onUpdateValue,
+      patch.reference !== void 0 ? patch.reference : this.reference,
+      patch.dbName !== void 0 ? patch.dbName : this.dbName
+    );
+  }
+  primaryKey() {
+    return this.derive({ flags: { ...this.flags, primaryKey: true, hasDefault: true } });
+  }
+  notNull() {
+    return this.derive({ flags: { ...this.flags, notNull: true } });
+  }
+  /**
+   * Add a `UNIQUE` constraint to the column (mirrors SQLAlchemy's
+   * `mapped_column(unique=True)`). DDL-only — does not change the inferred type.
+   */
+  unique() {
+    return this.derive({ flags: { ...this.flags, unique: true } });
+  }
+  /**
+   * Map this property to a differently-named database column, à la SQLAlchemy's
+   * `mapped_column("consumer_name")` (Django's `db_column`, Prisma's `@map`).
+   *
+   * The override applies everywhere the name reaches SQL — select, insert,
+   * update, delete, where, order by, group by, returning, conflict targets, the
+   * migration IR and the drift check — while the TypeScript row keeps the
+   * property name. Use it to keep a `snake_case` schema behind a `camelCase`
+   * model; {@link Model.naming} does the same for a whole table at once.
+   *
+   * @param dbName The real column name in the database.
+   * @returns A new column bound to that name.
+   * @throws Error When `dbName` is empty.
+   *
+   * @example
+   * ```ts
+   * class ApiKey extends Model {
+   *   static tablename = "api_keys";
+   *   consumerName = column.text().name("consumer_name").notNull();
+   * }
+   * ```
+   */
+  name(dbName) {
+    if (dbName.length === 0) {
+      throw new Error("column.name() requires a non-empty database column name.");
+    }
+    return this.derive({ dbName });
+  }
+  /**
+   * Declare a foreign-key reference to another table's column, à la SQLAlchemy's
+   * `mapped_column(ForeignKey("table.column", ondelete=...))`. DDL-only — does
+   * not change the inferred type.
+   *
+   * @param ref The target as `"table.column"` (e.g. `"users.id"`).
+   * @param options Optional `onDelete` / `onUpdate` referential actions.
+   * @returns A new column carrying the reference.
+   * @throws Error When `ref` is not a valid `"table.column"` string.
+   */
+  references(ref, options) {
+    return this.derive({ reference: parseReference(ref, options) });
+  }
+  /**
+   * Set the insert-time default: a constant value of type `T`, or a portable
+   * server-side expression from {@link sql} (e.g. `sql.now()`, `sql.uuidv4()`).
+   *
+   * @param value The literal default, or a {@link sql} expression.
+   * @returns A new column carrying the default.
+   * @throws Error When given a `sql.expr` fragment — a `DEFAULT` clause has
+   *   nowhere to bind parameters; use `sql.raw()` for a verbatim expression.
+   */
+  default(value) {
+    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
+    if (bindsParameters(resolved)) {
+      throw new Error(
+        "sql.expr`...` binds parameters and cannot be a column default \u2014 use sql.raw() for a verbatim DEFAULT expression."
+      );
+    }
+    return this.derive({
+      flags: { ...this.flags, hasDefault: true },
+      defaultValue: resolved
+    });
+  }
+  /**
+   * Re-apply a value whenever the row is updated (e.g. an `updated_at` column
+   * with `sql.now()`). Mirrors SQLAlchemy's `onupdate`.
+   *
+   * @param value The literal value, or a {@link sql} expression.
+   * @returns A new column carrying the on-update value.
+   * @throws Error When given a `sql.expr` fragment (see {@link Column.default}).
+   */
+  onUpdate(value) {
+    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
+    if (bindsParameters(resolved)) {
+      throw new Error(
+        "sql.expr`...` binds parameters and cannot be an onUpdate default \u2014 use sql.raw() for a verbatim expression."
+      );
+    }
+    return this.derive({ onUpdateValue: resolved });
+  }
+};
+function toSnakeCase(name) {
+  return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+var columnsCache = /* @__PURE__ */ new WeakMap();
+function columnsOf(model) {
+  const cached = columnsCache.get(model);
+  if (cached) return cached;
+  const instance = new model();
+  const out = {};
+  for (const [key, value] of Object.entries(instance)) {
+    if (value instanceof Column) {
+      out[key] = value;
+    }
+  }
+  columnsCache.set(model, out);
+  return out;
+}
+var nameMapCache = /* @__PURE__ */ new WeakMap();
+function columnNamesOf(model) {
+  const cached = nameMapCache.get(model);
+  if (cached !== void 0) return cached;
+  const strategy = model.naming ?? "preserve";
+  const map = {};
+  const seen = /* @__PURE__ */ new Map();
+  let renamed = false;
+  for (const [prop, col] of Object.entries(columnsOf(model))) {
+    const dbName = col.dbName ?? (strategy === "snake_case" ? toSnakeCase(prop) : prop);
+    const collision = seen.get(dbName);
+    if (collision !== void 0) {
+      throw new Error(
+        `${model.tablename}: properties "${collision}" and "${prop}" both map to column "${dbName}".`
+      );
+    }
+    seen.set(dbName, prop);
+    map[prop] = dbName;
+    if (dbName !== prop) renamed = true;
+  }
+  const result = renamed ? map : null;
+  nameMapCache.set(model, result);
+  return result;
+}
+
+// src/engine.ts
+module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href)));
+function toAsyncDriver(driver) {
+  return {
+    async execute(sql, params) {
+      return await driver.execute(sql, params);
+    },
+    async close() {
+      await driver.close();
+    }
+  };
+}
+
 // src/migrations/operations.ts
 var IrreversibleMigration = class extends Error {
   constructor(message) {
@@ -123,6 +333,8 @@ function renderColumnType(type, dialect) {
         return "NUMERIC";
       case "blob":
         return "BLOB";
+      case "array":
+        throw new Error(unsupportedArray("sqlite"));
       default:
         return "TEXT";
     }
@@ -164,6 +376,8 @@ function renderColumnType(type, dialect) {
         return "CHAR(36)";
       case "enum":
         return `ENUM(${(meta.values ?? []).map(quoteLiteral).join(", ")})`;
+      case "array":
+        throw new Error(unsupportedArray("mysql"));
     }
   }
   switch (kind) {
@@ -202,27 +416,39 @@ function renderColumnType(type, dialect) {
       return "UUID";
     case "enum":
       return "TEXT";
+    case "array":
+      return `${renderColumnType(arrayElement(meta.element), dialect)}[]`;
+  }
+}
+function unsupportedArray(dialect) {
+  return `column.array() is PostgreSQL-only \u2014 ${dialect} has no native array type. Model the column as JSON there, accepting that array operators will not work.`;
+}
+function arrayElement(element) {
+  if (!element) {
+    throw new Error(
+      "An array column has no element type \u2014 build it with column.array()."
+    );
   }
+  return element;
 }
-function renderDefault(def, dialect) {
+function renderDefault(def, dialect, type) {
   if (def.kind === "expression") {
     const expr = def.expression;
-    if (typeof expr === "object") return expr.raw;
-    switch (expr) {
-      case "now":
-        return dialect === "postgresql" ? "now()" : "CURRENT_TIMESTAMP";
-      case "current_date":
-        return "CURRENT_DATE";
-      case "current_time":
-        return "CURRENT_TIME";
-      case "uuidv4":
-        if (dialect === "postgresql") return "gen_random_uuid()";
-        if (dialect === "mysql") return "(UUID())";
-        return "(lower(hex(randomblob(16))))";
+    if (typeof expr === "object") {
+      if ("raw" in expr) return expr.raw;
+      throw new Error(
+        "sql.expr`...` binds parameters and cannot be rendered as a DEFAULT \u2014 use sql.raw()."
+      );
     }
+    return renderPortableToken(expr, dialect);
   }
   const value = def.value;
   if (value === null) return "NULL";
+  if (Array.isArray(value) && type?.kind === "array") {
+    const elementType = renderColumnType(arrayElement(type.meta.element), dialect);
+    const items = value.map((v) => renderDefault({ kind: "literal", value: v }, dialect));
+    return `ARRAY[${items.join(", ")}]::${elementType}[]`;
+  }
   if (typeof value === "boolean") {
     return dialect === "postgresql" ? value ? "TRUE" : "FALSE" : value ? "1" : "0";
   }
@@ -268,7 +494,9 @@ function tableConstraintClauses(table, dialect) {
 function renderColumnDef(col, dialect) {
   let sql = `${quoteId(col.name, dialect)} ${renderColumnType(col.type, dialect)}`;
   if (col.notNull) sql += " NOT NULL";
-  if (col.default !== null) sql += ` DEFAULT ${renderDefault(col.default, dialect)}`;
+  if (col.default !== null) {
+    sql += ` DEFAULT ${renderDefault(col.default, dialect, col.type)}`;
+  }
   sql += columnConstraintSuffix(col, dialect);
   return sql;
 }
@@ -292,7 +520,9 @@ function renderCreateTable(table, dialect) {
       typeStmts.push(`CREATE TYPE ${quoteId(typeName, dialect)} AS ENUM (${values})`);
       let def = `${quoteId(c.name, dialect)} ${quoteId(typeName, dialect)}`;
       if (c.notNull) def += " NOT NULL";
-      if (c.default !== null) def += ` DEFAULT ${renderDefault(c.default, dialect)}`;
+      if (c.default !== null) {
+        def += ` DEFAULT ${renderDefault(c.default, dialect, c.type)}`;
+      }
       return def + columnConstraintSuffix(c, dialect);
     }
     if (dialect === "postgresql" && isAutoIncrementPk(table, c)) {
@@ -436,7 +666,7 @@ function renderAlterColumn(table, to, dialect) {
     to.notNull ? `ALTER TABLE ${t} ALTER COLUMN ${c} SET NOT NULL` : `ALTER TABLE ${t} ALTER COLUMN ${c} DROP NOT NULL`
   );
   stmts.push(
-    to.default !== null ? `ALTER TABLE ${t} ALTER COLUMN ${c} SET DEFAULT ${renderDefault(to.default, dialect)}` : `ALTER TABLE ${t} ALTER COLUMN ${c} DROP DEFAULT`
+    to.default !== null ? `ALTER TABLE ${t} ALTER COLUMN ${c} SET DEFAULT ${renderDefault(to.default, dialect, to.type)}` : `ALTER TABLE ${t} ALTER COLUMN ${c} DROP DEFAULT`
   );
   return stmts;
 }
@@ -607,132 +837,18 @@ function heads(migrations) {
   return migrations.map((m) => m.revision).filter((r) => !parents.has(r)).sort();
 }
 
-// src/index.ts
-function isDefaultValue(value) {
-  return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
-}
-function parseReference(ref, options) {
-  const dot = ref.lastIndexOf(".");
-  if (dot <= 0 || dot === ref.length - 1) {
-    throw new Error(`Invalid foreign key reference "${ref}"; expected "table.column".`);
-  }
-  return {
-    table: ref.slice(0, dot),
-    column: ref.slice(dot + 1),
-    onDelete: options?.onDelete,
-    onUpdate: options?.onUpdate
-  };
-}
-var Column = class _Column {
-  constructor(type, flags, defaultValue = null, onUpdateValue = null, reference = null) {
-    this.type = type;
-    this.flags = flags;
-    this.defaultValue = defaultValue;
-    this.onUpdateValue = onUpdateValue;
-    this.reference = reference;
-  }
-  type;
-  flags;
-  defaultValue;
-  onUpdateValue;
-  reference;
-  primaryKey() {
-    return new _Column(
-      this.type,
-      { ...this.flags, primaryKey: true, hasDefault: true },
-      this.defaultValue,
-      this.onUpdateValue,
-      this.reference
-    );
-  }
-  notNull() {
-    return new _Column(
-      this.type,
-      { ...this.flags, notNull: true },
-      this.defaultValue,
-      this.onUpdateValue,
-      this.reference
-    );
-  }
-  /**
-   * Add a `UNIQUE` constraint to the column (mirrors SQLAlchemy's
-   * `mapped_column(unique=True)`). DDL-only — does not change the inferred type.
-   */
-  unique() {
-    return new _Column(
-      this.type,
-      { ...this.flags, unique: true },
-      this.defaultValue,
-      this.onUpdateValue,
-      this.reference
-    );
-  }
-  /**
-   * Declare a foreign-key reference to another table's column, à la SQLAlchemy's
-   * `mapped_column(ForeignKey("table.column", ondelete=...))`. DDL-only — does
-   * not change the inferred type.
-   *
-   * @param ref The target as `"table.column"` (e.g. `"users.id"`).
-   * @param options Optional `onDelete` / `onUpdate` referential actions.
-   * @returns A new column carrying the reference.
-   * @throws Error When `ref` is not a valid `"table.column"` string.
-   */
-  references(ref, options) {
-    return new _Column(
-      this.type,
-      this.flags,
-      this.defaultValue,
-      this.onUpdateValue,
-      parseReference(ref, options)
-    );
-  }
-  /**
-   * Set the insert-time default: a constant value of type `T`, or a portable
-   * server-side expression from {@link sql} (e.g. `sql.now()`, `sql.uuidv4()`).
-   */
-  default(value) {
-    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
-    return new _Column(
-      this.type,
-      { ...this.flags, hasDefault: true },
-      resolved,
-      this.onUpdateValue,
-      this.reference
-    );
-  }
-  /**
-   * Re-apply a value whenever the row is updated (e.g. an `updated_at` column
-   * with `sql.now()`). Mirrors SQLAlchemy's `onupdate`.
-   */
-  onUpdate(value) {
-    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
-    return new _Column(this.type, this.flags, this.defaultValue, resolved, this.reference);
-  }
-};
-var columnsCache = /* @__PURE__ */ new WeakMap();
-function columnsOf(model) {
-  const cached = columnsCache.get(model);
-  if (cached) return cached;
-  const instance = new model();
-  const out = {};
-  for (const [key, value] of Object.entries(instance)) {
-    if (value instanceof Column) {
-      out[key] = value;
-    }
-  }
-  columnsCache.set(model, out);
-  return out;
-}
-
 // src/migrations/ir.ts
 function constraintName(prefix, table, columns) {
   return `${prefix}_${table}_${columns.join("_")}`;
 }
 function reflectTable(model) {
+  const names = columnNamesOf(model);
+  const toColumn = (prop) => names?.[prop] ?? prop;
   const columns = {};
   const primaryKey = [];
-  for (const [name, col] of Object.entries(columnsOf(model))) {
+  for (const [prop, col] of Object.entries(columnsOf(model))) {
     const isPk = col.flags.primaryKey;
+    const name = toColumn(prop);
     columns[name] = {
       name,
       type: col.type,
@@ -747,15 +863,16 @@ function reflectTable(model) {
   const uniqueConstraints = [];
   const foreignKeys = [];
   for (const c of model.tableArgs?.() ?? []) {
+    const cols = c.columns.map(toColumn);
     if (c.kind === "unique") {
       uniqueConstraints.push({
-        name: c.name ?? constraintName("uq", model.tablename, c.columns),
-        columns: c.columns
+        name: c.name ?? constraintName("uq", model.tablename, cols),
+        columns: cols
       });
     } else {
       foreignKeys.push({
-        name: c.name ?? constraintName("fk", model.tablename, c.columns),
-        columns: c.columns,
+        name: c.name ?? constraintName("fk", model.tablename, cols),
+        columns: cols,
         refTable: c.refTable,
         refColumns: c.refColumns,
         onDelete: c.onDelete,
@@ -800,74 +917,6 @@ function affinityToKind(affinity) {
       return "text";
   }
 }
-function sqliteForeignKeys(driver, table) {
-  const rows = driver.execute(`PRAGMA foreign_key_list(${JSON.stringify(table)})`, []).rows;
-  const byId = /* @__PURE__ */ new Map();
-  for (const r of rows) {
-    const list = byId.get(r.id) ?? [];
-    list.push(r);
-    byId.set(r.id, list);
-  }
-  const fks = [];
-  for (const group of byId.values()) {
-    const ordered = [...group].sort((a, b) => a.seq - b.seq);
-    const columns = ordered.map((r) => r.from);
-    fks.push({
-      name: `fk_${table}_${columns.join("_")}`,
-      columns,
-      refTable: ordered[0]?.table ?? "",
-      refColumns: ordered.map((r) => r.to)
-    });
-  }
-  return fks;
-}
-function sqliteUniques(driver, table) {
-  const indexes = driver.execute(`PRAGMA index_list(${JSON.stringify(table)})`, []).rows;
-  const uniques = [];
-  for (const idx of indexes) {
-    if (Number(idx.unique) !== 1 || idx.origin === "pk") continue;
-    const cols = driver.execute(`PRAGMA index_info(${JSON.stringify(idx.name)})`, []).rows.sort((a, b) => a.seqno - b.seqno).map((c) => c.name);
-    if (cols.length > 0) {
-      uniques.push({ name: `uq_${table}_${cols.join("_")}`, columns: cols });
-    }
-  }
-  return uniques;
-}
-function introspectSqlite(driver) {
-  const tablesRows = driver.execute(
-    "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name != 'tempest_db_js_migrations'",
-    []
-  ).rows;
-  const tables = {};
-  for (const row of tablesRows) {
-    const tableName = String(row.name);
-    const info = driver.execute(`PRAGMA table_info(${JSON.stringify(tableName)})`, []).rows;
-    const columns = {};
-    const primaryKey = [];
-    for (const col of info) {
-      const isPk = Number(col.pk) > 0;
-      const affinity = sqliteAffinity(col.type);
-      columns[col.name] = {
-        name: col.name,
-        type: { kind: affinityToKind(affinity), meta: {} },
-        notNull: Number(col.notnull) === 1 || isPk,
-        primaryKey: isPk,
-        default: null,
-        unique: false,
-        references: null
-      };
-      if (isPk) primaryKey.push(col.name);
-    }
-    tables[tableName] = {
-      name: tableName,
-      columns,
-      primaryKey,
-      uniqueConstraints: sqliteUniques(driver, tableName),
-      foreignKeys: sqliteForeignKeys(driver, tableName)
-    };
-  }
-  return { tables };
-}
 function constraintKeys(table) {
   const fks = /* @__PURE__ */ new Set();
   const uniques = /* @__PURE__ */ new Set();
@@ -885,9 +934,7 @@ function constraintKeys(table) {
   }
   return { fks, uniques };
 }
-function checkDrift(driver, models) {
-  const actual = introspectSqlite(driver);
-  const expected = reflectSchema(models);
+function compareSqliteSchemas(actual, expected) {
   const issues = [];
   for (const [tableName, expectedTable] of Object.entries(expected.tables)) {
     const actualTable = actual.tables[tableName];
@@ -958,6 +1005,299 @@ function checkDrift(driver, models) {
   }
   return issues;
 }
+function sqliteColumnsFromPragma(info) {
+  const columns = {};
+  const primaryKey = [];
+  for (const col of info) {
+    const isPk = Number(col.pk) > 0;
+    columns[col.name] = {
+      name: col.name,
+      type: { kind: affinityToKind(sqliteAffinity(col.type)), meta: {} },
+      notNull: Number(col.notnull) === 1 || isPk,
+      primaryKey: isPk,
+      default: null,
+      unique: false,
+      references: null
+    };
+    if (isPk) primaryKey.push(col.name);
+  }
+  return { columns, primaryKey };
+}
+function sqliteForeignKeysFromPragma(table, rows) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const group = byId.get(row.id) ?? [];
+    group.push(row);
+    byId.set(row.id, group);
+  }
+  const fks = [];
+  for (const group of byId.values()) {
+    const ordered = [...group].sort((a, b) => a.seq - b.seq);
+    fks.push({
+      name: `fk_${table}_${ordered.map((r) => r.from).join("_")}`,
+      columns: ordered.map((r) => r.from),
+      refTable: ordered[0]?.table ?? "",
+      refColumns: ordered.map((r) => r.to)
+    });
+  }
+  return fks;
+}
+function sqliteUniqueFromPragma(table, rows) {
+  const cols = [...rows].sort((a, b) => a.seqno - b.seqno).map((c) => c.name);
+  if (cols.length === 0) return null;
+  return { name: `uq_${table}_${cols.join("_")}`, columns: cols };
+}
+function isUniqueIndex(idx) {
+  return Number(idx.unique) === 1 && idx.origin !== "pk";
+}
+var SQLITE_TABLES_SQL = "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name != 'tempest_db_js_migrations'";
+async function introspectSqliteAsync(driver) {
+  const tablesRows = (await driver.execute(SQLITE_TABLES_SQL, [])).rows;
+  const tables = {};
+  for (const row of tablesRows) {
+    const tableName = String(row.name);
+    const info = (await driver.execute(`PRAGMA table_info(${JSON.stringify(tableName)})`, [])).rows;
+    const { columns, primaryKey } = sqliteColumnsFromPragma(info);
+    const fkRows = (await driver.execute(`PRAGMA foreign_key_list(${JSON.stringify(tableName)})`, [])).rows;
+    const indexes = (await driver.execute(`PRAGMA index_list(${JSON.stringify(tableName)})`, [])).rows;
+    const uniqueConstraints = [];
+    for (const idx of indexes) {
+      if (!isUniqueIndex(idx)) continue;
+      const cols = (await driver.execute(`PRAGMA index_info(${JSON.stringify(idx.name)})`, [])).rows;
+      const unique = sqliteUniqueFromPragma(tableName, cols);
+      if (unique) uniqueConstraints.push(unique);
+    }
+    tables[tableName] = {
+      name: tableName,
+      columns,
+      primaryKey,
+      uniqueConstraints,
+      foreignKeys: sqliteForeignKeysFromPragma(tableName, fkRows)
+    };
+  }
+  return { tables };
+}
+async function checkDriftAsync(driver, dialect, models) {
+  if (dialect === "postgresql") return checkDriftPostgres(driver, models);
+  if (dialect === "sqlite") {
+    return compareSqliteSchemas(
+      await introspectSqliteAsync(driver),
+      reflectSchema(models)
+    );
+  }
+  return [
+    "drift checking is not implemented for MySQL \u2014 its information_schema introspection is still missing"
+  ];
+}
+function pgTypeToColumnType(dataType, udtName) {
+  if (dataType.toLowerCase() === "array") {
+    return {
+      kind: "array",
+      meta: { element: { kind: pgUdtToKind(udtName.replace(/^_/, "")), meta: {} } }
+    };
+  }
+  return { kind: pgTypeToKind(dataType, udtName), meta: {} };
+}
+function pgUdtToKind(udtName) {
+  switch (udtName) {
+    case "int2":
+      return "smallint";
+    case "int4":
+      return "integer";
+    case "int8":
+      return "bigint";
+    case "float4":
+      return "real";
+    case "float8":
+      return "double";
+    case "numeric":
+      return "numeric";
+    case "varchar":
+      return "varchar";
+    case "bpchar":
+      return "char";
+    case "bool":
+      return "boolean";
+    case "date":
+      return "date";
+    case "time":
+    case "timetz":
+      return "time";
+    case "timestamp":
+    case "timestamptz":
+      return "timestamp";
+    case "bytea":
+      return "blob";
+    case "json":
+    case "jsonb":
+      return "json";
+    case "uuid":
+      return "uuid";
+    default:
+      return "text";
+  }
+}
+function pgTypeToKind(dataType, udtName) {
+  const t = dataType.toLowerCase();
+  if (t === "user-defined") return "enum";
+  if (t === "smallint") return "smallint";
+  if (t === "integer") return "integer";
+  if (t === "bigint") return "bigint";
+  if (t === "numeric") return "numeric";
+  if (t === "real") return "real";
+  if (t === "double precision") return "double";
+  if (t === "character varying") return "varchar";
+  if (t === "character") return "char";
+  if (t === "text") return "text";
+  if (t === "boolean") return "boolean";
+  if (t === "date") return "date";
+  if (t.startsWith("time")) return t.startsWith("timestamp") ? "timestamp" : "time";
+  if (t === "bytea") return "blob";
+  if (t === "json") return "json";
+  if (t === "jsonb") return "json";
+  if (t === "uuid") return "uuid";
+  return udtName === "jsonb" ? "json" : "text";
+}
+async function introspectPostgres(driver) {
+  const tablesResult = await driver.execute(
+    "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE' AND table_name != 'tempest_db_js_migrations'",
+    []
+  );
+  const tables = {};
+  for (const row of tablesResult.rows) {
+    const tableName = String(row.table_name);
+    const colsResult = await driver.execute(
+      "SELECT column_name, data_type, udt_name, is_nullable FROM information_schema.columns WHERE table_name = $1",
+      [tableName]
+    );
+    const pkResult = await driver.execute(
+      `SELECT a.attname AS name FROM pg_index i
+       JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+       WHERE i.indrelid = $1::regclass AND i.indisprimary`,
+      [tableName]
+    );
+    const pkSet = new Set(pkResult.rows.map((r) => String(r.name)));
+    const columns = {};
+    const primaryKey = [];
+    for (const col of colsResult.rows) {
+      const name = String(col.column_name);
+      const isPk = pkSet.has(name);
+      columns[name] = {
+        name,
+        type: pgTypeToColumnType(String(col.data_type), String(col.udt_name)),
+        notNull: col.is_nullable === "NO" || isPk,
+        primaryKey: isPk,
+        default: null,
+        unique: false,
+        references: null
+      };
+      if (isPk) primaryKey.push(name);
+    }
+    tables[tableName] = {
+      name: tableName,
+      columns,
+      primaryKey,
+      uniqueConstraints: await postgresUniques(driver, tableName),
+      foreignKeys: await postgresForeignKeys(driver, tableName)
+    };
+  }
+  return { tables };
+}
+async function postgresForeignKeys(driver, table) {
+  const result = await driver.execute(
+    `SELECT c.conname AS name,
+            (SELECT array_agg(a.attname ORDER BY k.ord)
+               FROM unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS cols,
+            cf.relname AS ref_table,
+            (SELECT array_agg(a.attname ORDER BY k.ord)
+               FROM unnest(c.confkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.confrelid AND a.attnum = k.attnum) AS ref_cols
+       FROM pg_constraint c
+       JOIN pg_class cf ON cf.oid = c.confrelid
+      WHERE c.contype = 'f' AND c.conrelid = $1::regclass`,
+    [table]
+  );
+  return result.rows.map((r) => ({
+    name: String(r.name),
+    columns: r.cols ?? [],
+    refTable: String(r.ref_table),
+    refColumns: r.ref_cols ?? []
+  }));
+}
+async function postgresUniques(driver, table) {
+  const result = await driver.execute(
+    `SELECT c.conname AS name,
+            (SELECT array_agg(a.attname ORDER BY k.ord)
+               FROM unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.attnum) AS cols
+       FROM pg_constraint c
+      WHERE c.contype = 'u' AND c.conrelid = $1::regclass`,
+    [table]
+  );
+  return result.rows.map((r) => ({
+    name: String(r.name),
+    columns: r.cols ?? []
+  }));
+}
+function describeKind(type) {
+  if (type.kind !== "array") return type.kind;
+  return `${type.meta.element ? describeKind(type.meta.element) : "unknown"}[]`;
+}
+async function checkDriftPostgres(driver, models) {
+  const actual = await introspectPostgres(driver);
+  const expected = reflectSchema(models);
+  const issues = [];
+  for (const [tableName, expectedTable] of Object.entries(expected.tables)) {
+    const actualTable = actual.tables[tableName];
+    if (!actualTable) {
+      issues.push(`table "${tableName}" is missing from the database`);
+      continue;
+    }
+    for (const [colName, expectedCol] of Object.entries(expectedTable.columns)) {
+      const actualCol = actualTable.columns[colName];
+      if (!actualCol) {
+        issues.push(`column "${tableName}.${colName}" is missing from the database`);
+        continue;
+      }
+      if (describeKind(expectedCol.type) !== describeKind(actualCol.type)) {
+        issues.push(
+          `column "${tableName}.${colName}" type differs: model ${describeKind(expectedCol.type)}, db ${describeKind(actualCol.type)}`
+        );
+      }
+      if (expectedCol.notNull !== actualCol.notNull) {
+        issues.push(`column "${tableName}.${colName}" nullability differs`);
+      }
+    }
+    for (const colName of Object.keys(actualTable.columns)) {
+      if (!expectedTable.columns[colName]) {
+        issues.push(
+          `column "${tableName}.${colName}" exists in the database but not in the model`
+        );
+      }
+    }
+    const expectedKeys = constraintKeys(expectedTable);
+    const actualKeys = constraintKeys(actualTable);
+    for (const fk of expectedKeys.fks) {
+      if (!actualKeys.fks.has(fk)) {
+        issues.push(`foreign key "${tableName}: ${fk}" is missing from the database`);
+      }
+    }
+    for (const uq of expectedKeys.uniques) {
+      if (!actualKeys.uniques.has(uq)) {
+        issues.push(
+          `unique constraint "${tableName}: (${uq})" is missing from the database`
+        );
+      }
+    }
+  }
+  for (const tableName of Object.keys(actual.tables)) {
+    if (!expected.tables[tableName]) {
+      issues.push(`table "${tableName}" exists in the database but not in the models`);
+    }
+  }
+  return issues;
+}
 
 // src/migrations/renames.ts
 function columnShape(col) {
@@ -1100,62 +1440,77 @@ var Op = class {
   }
 };
 var VERSION_TABLE = "tempest_db_js_migrations";
-var MigrationRunner = class {
+function quoteIdent(name, dialect) {
+  return dialect === "mysql" ? `\`${name.replace(/`/g, "``")}\`` : `"${name.replace(/"/g, '""')}"`;
+}
+function placeholder(index, dialect) {
+  return dialect === "postgresql" ? `$${index}` : "?";
+}
+var AsyncMigrationRunner = class {
   constructor(driver, dialect) {
     this.driver = driver;
     this.dialect = dialect;
+    this.vt = quoteIdent(VERSION_TABLE, dialect);
   }
   driver;
   dialect;
+  vt;
   /** Create the version-tracking table if it does not exist. */
-  ensureVersionTable() {
-    this.driver.execute(
-      `CREATE TABLE IF NOT EXISTS "${VERSION_TABLE}" (revision TEXT PRIMARY KEY, applied_at TEXT NOT NULL, down_revision TEXT NOT NULL)`,
+  async ensureVersionTable() {
+    await this.driver.execute(
+      `CREATE TABLE IF NOT EXISTS ${this.vt} (revision ${this.textType()} PRIMARY KEY, applied_at ${this.textType()} NOT NULL, down_revision ${this.textType()} NOT NULL)`,
       []
     );
   }
+  /** A portable "text" column type for the version table. */
+  textType() {
+    return this.dialect === "mysql" ? "VARCHAR(255)" : "TEXT";
+  }
   /** The set of applied revision ids. */
-  applied() {
-    this.ensureVersionTable();
-    const { rows } = this.driver.execute(`SELECT revision FROM "${VERSION_TABLE}"`, []);
+  async applied() {
+    await this.ensureVersionTable();
+    const { rows } = await this.driver.execute(`SELECT revision FROM ${this.vt}`, []);
     return new Set(rows.map((r) => String(r.revision)));
   }
-  runOps(ops) {
+  async runOps(ops) {
     for (const op of ops) {
       for (const stmt of renderOperation(op, this.dialect)) {
         const trimmed = stmt.trim();
         if (trimmed.length === 0 || trimmed.startsWith("--")) continue;
-        this.driver.execute(stmt, []);
+        await this.driver.execute(stmt, []);
       }
     }
   }
-  record(migration, appliedAt) {
-    this.driver.execute(
-      `INSERT INTO "${VERSION_TABLE}" (revision, applied_at, down_revision) VALUES (?, ?, ?)`,
+  async record(migration, appliedAt) {
+    const p = (i) => placeholder(i, this.dialect);
+    await this.driver.execute(
+      `INSERT INTO ${this.vt} (revision, applied_at, down_revision) VALUES (${p(1)}, ${p(2)}, ${p(3)})`,
       [migration.revision, appliedAt, migration.downRevision.join(",")]
     );
   }
-  forget(revision) {
-    this.driver.execute(`DELETE FROM "${VERSION_TABLE}" WHERE revision = ?`, [revision]);
+  async forget(revision) {
+    await this.driver.execute(
+      `DELETE FROM ${this.vt} WHERE revision = ${placeholder(1, this.dialect)}`,
+      [revision]
+    );
   }
   /**
    * Apply all pending migrations up to the head(s), in DAG order.
    *
    * @param migrations All known migrations.
-   * @param appliedAt Timestamp string to stamp (pass one in — the runtime has no
-   *   wall clock of its own here).
+   * @param appliedAt Timestamp string to stamp on each applied revision.
    * @returns The revision ids that were applied this run.
    */
-  upgrade(migrations, appliedAt) {
-    const done = this.applied();
+  async upgrade(migrations, appliedAt) {
+    const done = await this.applied();
     const ordered = topoOrder(migrations);
     const ran = [];
     for (const migration of ordered) {
       if (done.has(migration.revision)) continue;
       const op = new Op();
       migration.up(op);
-      this.runOps(op.operations);
-      this.record(migration, appliedAt);
+      await this.runOps(op.operations);
+      await this.record(migration, appliedAt);
       ran.push(migration.revision);
     }
     return ran;
@@ -1167,27 +1522,25 @@ var MigrationRunner = class {
    * @param steps How many applied revisions to roll back.
    * @returns The revision ids that were reverted.
    */
-  downgrade(migrations, steps = 1) {
-    const done = this.applied();
+  async downgrade(migrations, steps = 1) {
+    const done = await this.applied();
     const ordered = topoOrder(migrations).filter((m) => done.has(m.revision));
     const toRevert = ordered.slice(-steps).reverse();
     const reverted = [];
     for (const migration of toRevert) {
       const op = new Op();
-      if (migration.down.length >= 0) {
-        try {
-          migration.down(op);
-        } catch {
-          op.operations.length = 0;
-        }
+      try {
+        migration.down(op);
+      } catch {
+        op.operations.length = 0;
       }
       if (op.operations.length === 0) {
         const upOp = new Op();
         migration.up(upOp);
         op.operations.push(...invertAll(upOp.operations));
       }
-      this.runOps(op.operations);
-      this.forget(migration.revision);
+      await this.runOps(op.operations);
+      await this.forget(migration.revision);
       reverted.push(migration.revision);
     }
     return reverted;
@@ -1326,23 +1679,24 @@ function parseRenameFlags(rest) {
   }
   return out;
 }
-function pending(config, runner) {
-  const done = runner.applied();
+async function pending(config, runner) {
+  const done = await runner.applied();
   return topoOrder(config.migrations).filter((m) => !done.has(m.revision));
 }
-function runMigrationCli(argv, config) {
+async function runMigrationCli(argv, config) {
   const [command, ...rest] = argv;
-  const runner = new MigrationRunner(config.driver, config.dialect);
+  const driver = toAsyncDriver(config.driver);
+  const runner = new AsyncMigrationRunner(driver, config.dialect);
   const appliedAt = config.appliedAt ?? "1970-01-01T00:00:00.000Z";
   switch (command) {
     case "current": {
-      const applied = [...runner.applied()].sort();
+      const applied = [...await runner.applied()].sort();
       return ok(applied.length > 0 ? applied : ["(no migrations applied)"]);
     }
     case "heads":
       return ok(heads(config.migrations));
     case "history": {
-      const done = runner.applied();
+      const done = await runner.applied();
       return ok(
         topoOrder(config.migrations).map(
           (m) => `${done.has(m.revision) ? "\u2713" : "\xB7"} ${m.revision}${m.label ? ` \u2014 ${m.label}` : ""}`
@@ -1352,7 +1706,7 @@ function runMigrationCli(argv, config) {
     case "upgrade": {
       if (rest.includes("--sql")) {
         const lines = [];
-        for (const migration of pending(config, runner)) {
+        for (const migration of await pending(config, runner)) {
           const op = new Op();
           migration.up(op);
           lines.push(`-- ${migration.revision}`);
@@ -1363,19 +1717,19 @@ function runMigrationCli(argv, config) {
         }
         return ok(lines.length > 0 ? lines : ["-- nothing to upgrade"]);
       }
-      const ran = runner.upgrade(config.migrations, appliedAt);
+      const ran = await runner.upgrade(config.migrations, appliedAt);
       return ok(ran.length > 0 ? ran.map((r) => `applied ${r}`) : ["nothing to upgrade"]);
     }
     case "downgrade": {
       const steps = rest[0] ? Number(rest[0]) : 1;
-      const reverted = runner.downgrade(config.migrations, steps);
+      const reverted = await runner.downgrade(config.migrations, steps);
       return ok(
         reverted.length > 0 ? reverted.map((r) => `reverted ${r}`) : ["nothing to downgrade"]
       );
     }
     case "check": {
       if (!config.models) return fail(["check requires models in the config"]);
-      const drift = config.dialect === "sqlite" ? checkDrift(config.driver, config.models) : [];
+      const drift = await checkDriftAsync(driver, config.dialect, config.models);
       const undiffed = diffSchema(
         replaySchema(config.migrations),
         reflectSchema(config.models)
@@ -1504,7 +1858,7 @@ async function main(argv) {
     appliedAt: config.appliedAt ?? (/* @__PURE__ */ new Date()).toISOString()
   };
   const renameFlags = await promptRenames(withClock, rest);
-  const result = runMigrationCli([...rest, ...renameFlags], withClock);
+  const result = await runMigrationCli([...rest, ...renameFlags], withClock);
   const sink = result.code === 0 ? process.stdout : process.stderr;
   for (const line of result.lines) sink.write(`${line}
 `);