tempest-db-js 0.4.0 → 0.6.0

package/dist/migrations/index.cjs

@@ -1,9 +1,42 @@
 'use strict';
 
+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))))";
+  }
+}
+module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+function toAsyncDriver(driver) {
+  return {
+    async execute(sql, params) {
+      return await driver.execute(sql, params);
+    },
+    async close() {
+      await driver.close();
+    }
+  };
+}
+
 // 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) {
@@ -17,48 +50,71 @@ function parseReference(ref, options) {
   };
 }
 var Column = class _Column {
-  constructor(type, flags, defaultValue = null, onUpdateValue = null, reference = null) {
+  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;
-  primaryKey() {
+  dbName;
+  /** Clone this column with one facet replaced, carrying every other over. */
+  derive(patch) {
     return new _Column(
       this.type,
-      { ...this.flags, primaryKey: true, hasDefault: true },
-      this.defaultValue,
-      this.onUpdateValue,
-      this.reference
+      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 new _Column(
-      this.type,
-      { ...this.flags, notNull: true },
-      this.defaultValue,
-      this.onUpdateValue,
-      this.reference
-    );
+    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 new _Column(
-      this.type,
-      { ...this.flags, unique: true },
-      this.defaultValue,
-      this.onUpdateValue,
-      this.reference
-    );
+    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
@@ -71,37 +127,50 @@ var Column = class _Column {
    * @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)
-    );
+    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 };
-    return new _Column(
-      this.type,
-      { ...this.flags, hasDefault: true },
-      resolved,
-      this.onUpdateValue,
-      this.reference
-    );
+    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 };
-    return new _Column(this.type, this.flags, this.defaultValue, resolved, this.reference);
+    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);
@@ -116,16 +185,43 @@ function columnsOf(model) {
   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/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,
@@ -140,15 +236,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,
@@ -239,6 +336,8 @@ function renderColumnType(type, dialect) {
         return "NUMERIC";
       case "blob":
         return "BLOB";
+      case "array":
+        throw new Error(unsupportedArray("sqlite"));
       default:
         return "TEXT";
     }
@@ -280,6 +379,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) {
@@ -318,27 +419,39 @@ function renderColumnType(type, dialect) {
       return "UUID";
     case "enum":
       return "TEXT";
+    case "array":
+      return `${renderColumnType(arrayElement(meta.element), dialect)}[]`;
   }
 }
-function renderDefault(def, 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, 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";
   }
@@ -384,7 +497,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;
 }
@@ -408,7 +523,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)) {
@@ -552,7 +669,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;
 }
@@ -1041,62 +1158,26 @@ function affinityToKind(affinity) {
 }
 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;
+  return sqliteForeignKeysFromPragma(table, rows);
 }
 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 });
-    }
+    if (!isUniqueIndex(idx)) continue;
+    const cols = driver.execute(`PRAGMA index_info(${JSON.stringify(idx.name)})`, []).rows;
+    const unique = sqliteUniqueFromPragma(table, cols);
+    if (unique) uniques.push(unique);
   }
   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 tablesRows = driver.execute(SQLITE_TABLES_SQL, []).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);
-    }
+    const { columns, primaryKey } = sqliteColumnsFromPragma(info);
     tables[tableName] = {
       name: tableName,
       columns,
@@ -1125,8 +1206,9 @@ function constraintKeys(table) {
   return { fks, uniques };
 }
 function checkDrift(driver, models) {
-  const actual = introspectSqlite(driver);
-  const expected = reflectSchema(models);
+  return compareSqliteSchemas(introspectSqlite(driver), reflectSchema(models));
+}
+function compareSqliteSchemas(actual, expected) {
   const issues = [];
   for (const [tableName, expectedTable] of Object.entries(expected.tables)) {
     const actualTable = actual.tables[tableName];
@@ -1197,6 +1279,138 @@ 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";
@@ -1244,10 +1458,7 @@ async function introspectPostgres(driver) {
       const isPk = pkSet.has(name);
       columns[name] = {
         name,
-        type: {
-          kind: pgTypeToKind(String(col.data_type), String(col.udt_name)),
-          meta: {}
-        },
+        type: pgTypeToColumnType(String(col.data_type), String(col.udt_name)),
         notNull: col.is_nullable === "NO" || isPk,
         primaryKey: isPk,
         default: null,
@@ -1303,6 +1514,10 @@ async function postgresUniques(driver, table) {
     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);
@@ -1319,9 +1534,9 @@ async function checkDriftPostgres(driver, models) {
         issues.push(`column "${tableName}.${colName}" is missing from the database`);
         continue;
       }
-      if (expectedCol.type.kind !== actualCol.type.kind) {
+      if (describeKind(expectedCol.type) !== describeKind(actualCol.type)) {
         issues.push(
-          `column "${tableName}.${colName}" type differs: model ${expectedCol.type.kind}, db ${actualCol.type.kind}`
+          `column "${tableName}.${colName}" type differs: model ${describeKind(expectedCol.type)}, db ${describeKind(actualCol.type)}`
         );
       }
       if (expectedCol.notNull !== actualCol.notNull) {
@@ -1588,23 +1803,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}` : ""}`
@@ -1614,7 +1830,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}`);
@@ -1625,19 +1841,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)
@@ -1684,7 +1900,9 @@ exports.UnknownRevision = UnknownRevision;
 exports.applyOperation = applyOperation;
 exports.applyRenames = applyRenames;
 exports.checkDrift = checkDrift;
+exports.checkDriftAsync = checkDriftAsync;
 exports.checkDriftPostgres = checkDriftPostgres;
+exports.compareSqliteSchemas = compareSqliteSchemas;
 exports.defineMigrationConfig = defineMigrationConfig;
 exports.detectRenames = detectRenames;
 exports.diffSchema = diffSchema;
@@ -1693,6 +1911,7 @@ exports.generateMigration = generateMigration;
 exports.heads = heads;
 exports.introspectPostgres = introspectPostgres;
 exports.introspectSqlite = introspectSqlite;
+exports.introspectSqliteAsync = introspectSqliteAsync;
 exports.invert = invert;
 exports.invertAll = invertAll;
 exports.makeRevisionId = makeRevisionId;