easy-ping 0.8.1 → 0.9.0

package/dist/schema.cjs

@@ -60,6 +60,173 @@ var coreSchema = {
   }
 };
 
+// src/schema/render-mysql.ts
+var quote = (value) => `\`${value.split("`").join("``")}\``;
+function stringType(field, table, spec) {
+  const keys = [
+    ...table.primaryKey ? [table.primaryKey] : [],
+    ...(table.indexes ?? []).map((index) => index.on)
+  ].filter((columns) => columns.includes(field));
+  if (keys.some((columns) => columns.length > 1)) return "VARCHAR(255)";
+  if (keys.length > 0) return "VARCHAR(768)";
+  if (spec.default !== void 0) return "VARCHAR(255)";
+  return "TEXT";
+}
+function columnType(field, table, spec) {
+  switch (spec.type) {
+    case "string":
+      return stringType(field, table, spec);
+    case "number":
+      return "INT";
+    case "boolean":
+      return "TINYINT(1)";
+    case "date":
+      return "DATETIME(3)";
+    case "json":
+      return "JSON";
+  }
+}
+var defaultClause = (spec) => {
+  if (spec.defaultNow) return " DEFAULT CURRENT_TIMESTAMP(3)";
+  if (spec.default === void 0) return "";
+  if (typeof spec.default === "string") return ` DEFAULT '${spec.default.replace(/'/g, "''")}'`;
+  if (typeof spec.default === "boolean") return ` DEFAULT ${spec.default ? 1 : 0}`;
+  return ` DEFAULT ${spec.default}`;
+};
+function mysqlColumnDefinition(field, table, spec) {
+  const nullability = spec.required ? " NOT NULL" : "";
+  return `${quote(toSnakeCase(field))} ${columnType(field, table, spec)}${nullability}${defaultClause(spec)}`;
+}
+function renderMysqlDdl(schema, prefix = "") {
+  const statements = [];
+  for (const table of Object.values(schema)) {
+    const lines = Object.entries(table.fields).map(
+      ([field, spec]) => `  ${mysqlColumnDefinition(field, table, spec)}`
+    );
+    if (table.primaryKey?.length) {
+      lines.push(
+        `  PRIMARY KEY (${table.primaryKey.map((f) => quote(toSnakeCase(f))).join(", ")})`
+      );
+    }
+    for (const index of table.indexes ?? []) {
+      const name = quote(prefix + (index.name ?? `${table.tableName}_${index.on.join("_")}_idx`));
+      const columns = index.on.map((f) => quote(toSnakeCase(f))).join(", ");
+      lines.push(`  ${index.unique ? "UNIQUE " : ""}INDEX ${name} (${columns})`);
+    }
+    statements.push(
+      `CREATE TABLE IF NOT EXISTS ${quote(prefix + table.tableName)} (
+${lines.join(",\n")}
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`
+    );
+  }
+  return statements;
+}
+
+// src/schema/migrate-mysql.ts
+var MYSQL_INTROSPECT_COLUMNS_SQL = `
+  SELECT TABLE_NAME AS table_name, COLUMN_NAME AS column_name, DATA_TYPE AS data_type
+  FROM information_schema.COLUMNS
+  WHERE TABLE_SCHEMA = DATABASE()
+`;
+var MYSQL_INTROSPECT_INDEXES_SQL = `
+  SELECT DISTINCT TABLE_NAME AS table_name, INDEX_NAME AS index_name
+  FROM information_schema.STATISTICS
+  WHERE TABLE_SCHEMA = DATABASE()
+`;
+var LIVE_TYPE = {
+  string: ["varchar", "char", "text", "tinytext", "mediumtext", "longtext"],
+  number: ["int", "integer", "bigint", "smallint", "mediumint", "tinyint"],
+  boolean: ["tinyint", "bit", "boolean"],
+  date: ["datetime", "timestamp"],
+  json: ["json", "longtext"]
+};
+var quote2 = (value) => `\`${value.split("`").join("``")}\``;
+var indexName = (table, declaration) => declaration.name ?? `${table.tableName}_${declaration.on.join("_")}_idx`;
+var lower = (value) => String(value).toLowerCase();
+async function planMysqlMigration(query, schema, prefix = "") {
+  const [columnRows, indexRows] = await Promise.all([
+    query(MYSQL_INTROSPECT_COLUMNS_SQL, []),
+    query(MYSQL_INTROSPECT_INDEXES_SQL, [])
+  ]);
+  const columns = /* @__PURE__ */ new Map();
+  for (const row of columnRows.rows) {
+    const table = lower(row.table_name ?? row.TABLE_NAME);
+    const byColumn = columns.get(table) ?? /* @__PURE__ */ new Map();
+    byColumn.set(lower(row.column_name ?? row.COLUMN_NAME), lower(row.data_type ?? row.DATA_TYPE));
+    columns.set(table, byColumn);
+  }
+  const indexes = new Set(
+    indexRows.rows.map(
+      (row) => `${lower(row.table_name ?? row.TABLE_NAME)}.${lower(row.index_name ?? row.INDEX_NAME)}`
+    )
+  );
+  const statements = [];
+  const unsupported = [];
+  const createdTables = [];
+  for (const table of Object.values(schema)) {
+    const qualified = prefix + table.tableName;
+    const existing = columns.get(qualified.toLowerCase());
+    if (!existing || existing.size === 0) {
+      createdTables.push(qualified);
+      statements.push(...renderMysqlDdl({ [table.tableName]: table }, prefix));
+      continue;
+    }
+    for (const [field, spec] of Object.entries(table.fields)) {
+      const column = toSnakeCase(field);
+      const found = existing.get(column.toLowerCase());
+      if (found === void 0) {
+        const canFill = spec.defaultNow || spec.default !== void 0;
+        const definition = mysqlColumnDefinition(field, table, {
+          ...spec,
+          // A required column with nothing to fill existing rows with is added nullable.
+          required: Boolean(spec.required && canFill)
+        });
+        statements.push(`ALTER TABLE ${quote2(qualified)} ADD COLUMN ${definition}`);
+        if (spec.required && !canFill) {
+          unsupported.push(
+            `${qualified}.${column} is declared required but has no default; it was added nullable. Backfill it, then ALTER TABLE ... MODIFY ... NOT NULL yourself.`
+          );
+        }
+        continue;
+      }
+      if (!LIVE_TYPE[spec.type].includes(found)) {
+        unsupported.push(
+          `${qualified}.${column} is ${found} but ${spec.type} is declared. Changing a column type can lose data \u2014 do it yourself.`
+        );
+      }
+    }
+    for (const declaration of table.indexes ?? []) {
+      const name = prefix + indexName(table, declaration);
+      if (indexes.has(`${qualified.toLowerCase()}.${name.toLowerCase()}`)) continue;
+      const textColumn = declaration.on.find((field) => {
+        const live = existing.get(toSnakeCase(field).toLowerCase());
+        return live?.endsWith("text") ?? false;
+      });
+      if (textColumn) {
+        unsupported.push(
+          `${qualified}: index ${name} needs ${toSnakeCase(textColumn)} as VARCHAR, but it is TEXT, which MySQL cannot index without a prefix length. Change the column type, then rerun.`
+        );
+        continue;
+      }
+      const cols = declaration.on.map((field) => quote2(toSnakeCase(field))).join(", ");
+      statements.push(
+        `CREATE ${declaration.unique ? "UNIQUE " : ""}INDEX ${quote2(name)} ON ${quote2(qualified)} (${cols})`
+      );
+    }
+    for (const column of existing.keys()) {
+      const declared = Object.keys(table.fields).some(
+        (field) => toSnakeCase(field).toLowerCase() === column
+      );
+      if (!declared) {
+        unsupported.push(
+          `${qualified}.${column} exists but is not declared. Left alone \u2014 drop it yourself if it is ours and no longer needed.`
+        );
+      }
+    }
+  }
+  return { statements, unsupported, createdTables };
+}
+
 // src/schema/render-sql.ts
 var SQL_TYPE = {
   string: "text",
@@ -68,8 +235,8 @@ var SQL_TYPE = {
   date: "timestamptz",
   json: "jsonb"
 };
-var quote = (value) => `"${value.replace(/"/g, '""')}"`;
-var defaultClause = (field) => {
+var quote3 = (value) => `"${value.replace(/"/g, '""')}"`;
+var defaultClause2 = (field) => {
   if (field.defaultNow) return " DEFAULT now()";
   if (field.default === void 0) return "";
   if (typeof field.default === "string") return ` DEFAULT '${field.default.replace(/'/g, "''")}'`;
@@ -78,25 +245,25 @@ var defaultClause = (field) => {
 function renderPostgresDdl(schema, prefix = "") {
   const statements = [];
   for (const table of Object.values(schema)) {
-    const name = quote(prefix + table.tableName);
+    const name = quote3(prefix + table.tableName);
     const columns = Object.entries(table.fields).map(([field, spec]) => {
       const nullability = spec.required ? " NOT NULL" : "";
-      return `  ${quote(toSnakeCase(field))} ${SQL_TYPE[spec.type]}${nullability}${defaultClause(spec)}`;
+      return `  ${quote3(toSnakeCase(field))} ${SQL_TYPE[spec.type]}${nullability}${defaultClause2(spec)}`;
     });
     if (table.primaryKey?.length) {
-      const key = table.primaryKey.map((field) => quote(toSnakeCase(field))).join(", ");
+      const key = table.primaryKey.map((field) => quote3(toSnakeCase(field))).join(", ");
       columns.push(`  PRIMARY KEY (${key})`);
     }
     statements.push(`CREATE TABLE IF NOT EXISTS ${name} (
 ${columns.join(",\n")}
 )`);
     for (const declaration of table.indexes ?? []) {
-      const indexName2 = quote(
+      const indexName3 = quote3(
         prefix + (declaration.name ?? `${table.tableName}_${declaration.on.join("_")}_idx`)
       );
-      const columns2 = declaration.on.map((field) => quote(toSnakeCase(field))).join(", ");
+      const columns2 = declaration.on.map((field) => quote3(toSnakeCase(field))).join(", ");
       const unique = declaration.unique ? "UNIQUE " : "";
-      statements.push(`CREATE ${unique}INDEX IF NOT EXISTS ${indexName2} ON ${name} (${columns2})`);
+      statements.push(`CREATE ${unique}INDEX IF NOT EXISTS ${indexName3} ON ${name} (${columns2})`);
     }
   }
   return statements;
@@ -110,21 +277,21 @@ var SQL_TYPE2 = {
   date: "timestamptz",
   json: "jsonb"
 };
-var LIVE_TYPE = {
+var LIVE_TYPE2 = {
   string: ["text", "character varying", "character"],
   number: ["integer", "bigint", "smallint"],
   boolean: ["boolean"],
   date: ["timestamp with time zone", "timestamp without time zone"],
   json: ["jsonb", "json"]
 };
-var quote2 = (value) => `"${value.replace(/"/g, '""')}"`;
-var defaultClause2 = (field) => {
+var quote4 = (value) => `"${value.replace(/"/g, '""')}"`;
+var defaultClause3 = (field) => {
   if (field.defaultNow) return " DEFAULT now()";
   if (field.default === void 0) return "";
   if (typeof field.default === "string") return ` DEFAULT '${field.default.replace(/'/g, "''")}'`;
   return ` DEFAULT ${field.default}`;
 };
-var indexName = (table, declaration) => declaration.name ?? `${table.tableName}_${declaration.on.join("_")}_idx`;
+var indexName2 = (table, declaration) => declaration.name ?? `${table.tableName}_${declaration.on.join("_")}_idx`;
 function normaliseColumn(row) {
   if ("table" in row) return row;
   return {
@@ -166,7 +333,7 @@ async function planPostgresMigration(introspect, schema, prefix = "") {
         const canFill = spec.defaultNow || spec.default !== void 0;
         const nullability = spec.required && canFill ? " NOT NULL" : "";
         statements.push(
-          `ALTER TABLE ${quote2(qualified)} ADD COLUMN IF NOT EXISTS ${quote2(column)} ${SQL_TYPE2[spec.type]}${nullability}${defaultClause2(spec)}`
+          `ALTER TABLE ${quote4(qualified)} ADD COLUMN IF NOT EXISTS ${quote4(column)} ${SQL_TYPE2[spec.type]}${nullability}${defaultClause3(spec)}`
         );
         if (spec.required && !canFill) {
           unsupported.push(
@@ -175,17 +342,17 @@ async function planPostgresMigration(introspect, schema, prefix = "") {
         }
         continue;
       }
-      if (!LIVE_TYPE[spec.type].includes(found.type)) {
+      if (!LIVE_TYPE2[spec.type].includes(found.type)) {
         unsupported.push(
           `${qualified}.${column} is ${found.type} but ${spec.type} is declared (${SQL_TYPE2[spec.type]}). Changing a column type can lose data \u2014 do it yourself.`
         );
       }
     }
     for (const declaration of table.indexes ?? []) {
-      const name = quote2(prefix + indexName(table, declaration));
-      const columns = declaration.on.map((field) => quote2(toSnakeCase(field))).join(", ");
+      const name = quote4(prefix + indexName2(table, declaration));
+      const columns = declaration.on.map((field) => quote4(toSnakeCase(field))).join(", ");
       statements.push(
-        `CREATE ${declaration.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${name} ON ${quote2(qualified)} (${columns})`
+        `CREATE ${declaration.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${name} ON ${quote4(qualified)} (${columns})`
       );
     }
     for (const column of existing.keys()) {
@@ -200,6 +367,151 @@ async function planPostgresMigration(introspect, schema, prefix = "") {
   return { statements, unsupported, createdTables };
 }
 
+// src/schema/render-sqlite.ts
+var SQLITE_TYPE = {
+  string: "TEXT",
+  number: "INTEGER",
+  boolean: "INTEGER",
+  // ISO-8601 with milliseconds and a trailing Z, the same 24 characters
+  // `Date#toISOString` writes, so `<=` on the text is `<=` on the instant.
+  date: "TEXT",
+  json: "TEXT"
+};
+var quote5 = (value) => `"${value.split('"').join('""')}"`;
+var defaultClause4 = (spec) => {
+  if (spec.defaultNow) return " DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))";
+  if (spec.default === void 0) return "";
+  if (typeof spec.default === "string") return ` DEFAULT '${spec.default.replace(/'/g, "''")}'`;
+  if (typeof spec.default === "boolean") return ` DEFAULT ${spec.default ? 1 : 0}`;
+  return ` DEFAULT ${spec.default}`;
+};
+function sqliteColumnDefinition(field, spec) {
+  const nullability = spec.required ? " NOT NULL" : "";
+  return `${quote5(toSnakeCase(field))} ${SQLITE_TYPE[spec.type]}${nullability}${defaultClause4(spec)}`;
+}
+function renderSqliteDdl(schema, prefix = "") {
+  const statements = [];
+  for (const table of Object.values(schema)) {
+    const name = quote5(prefix + table.tableName);
+    const columns = Object.entries(table.fields).map(
+      ([field, spec]) => `  ${sqliteColumnDefinition(field, spec)}`
+    );
+    if (table.primaryKey?.length) {
+      columns.push(
+        `  PRIMARY KEY (${table.primaryKey.map((f) => quote5(toSnakeCase(f))).join(", ")})`
+      );
+    }
+    statements.push(`CREATE TABLE IF NOT EXISTS ${name} (
+${columns.join(",\n")}
+)`);
+    for (const index of table.indexes ?? []) {
+      const indexName3 = quote5(
+        prefix + (index.name ?? `${table.tableName}_${index.on.join("_")}_idx`)
+      );
+      const cols = index.on.map((f) => quote5(toSnakeCase(f))).join(", ");
+      statements.push(
+        `CREATE ${index.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${indexName3} ON ${name} (${cols})`
+      );
+    }
+  }
+  return statements;
+}
+
+// src/schema/migrate-sqlite.ts
+var SQLITE_INTROSPECT_SQL = `
+  SELECT m.name AS table_name, p.name AS column_name, p.type AS data_type
+  FROM sqlite_master AS m
+  JOIN pragma_table_info(m.name) AS p
+  WHERE m.type = 'table' AND m.name NOT LIKE 'sqlite_%'
+`;
+var quote6 = (value) => `"${value.split('"').join('""')}"`;
+var REBUILD_SUFFIX = "__easy_ping_rebuild";
+async function planSqliteMigration(query, schema, prefix = "") {
+  const { rows } = await query(SQLITE_INTROSPECT_SQL, []);
+  const live = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const table = String(row.table_name);
+    const columns = live.get(table) ?? /* @__PURE__ */ new Map();
+    columns.set(String(row.column_name), String(row.data_type).toUpperCase());
+    live.set(table, columns);
+  }
+  const statements = [];
+  const unsupported = [];
+  const createdTables = [];
+  for (const table of Object.values(schema)) {
+    const qualified = prefix + table.tableName;
+    const existing = live.get(qualified);
+    if (!existing || existing.size === 0) {
+      createdTables.push(qualified);
+      statements.push(...renderSqliteDdl({ [table.tableName]: table }, prefix));
+      continue;
+    }
+    const missing = Object.entries(table.fields).filter(
+      ([field]) => !existing.has(toSnakeCase(field))
+    );
+    const relaxed = {
+      ...table,
+      fields: Object.fromEntries(
+        Object.entries(table.fields).map(([field, spec]) => {
+          const unfillable = !existing.has(toSnakeCase(field)) && spec.required && !spec.defaultNow && spec.default === void 0;
+          if (unfillable) {
+            unsupported.push(
+              `${qualified}.${toSnakeCase(field)} is declared required but has no default; it was added nullable. Backfill it; SQLite cannot add NOT NULL afterwards without a rebuild.`
+            );
+          }
+          return [field, unfillable ? { ...spec, required: false } : spec];
+        })
+      )
+    };
+    if (missing.some(([, spec]) => spec.defaultNow)) {
+      statements.push(...rebuild(relaxed, prefix, existing));
+    } else {
+      for (const [field] of missing) {
+        const spec = relaxed.fields[field];
+        if (!spec) continue;
+        statements.push(
+          `ALTER TABLE ${quote6(qualified)} ADD COLUMN ${sqliteColumnDefinition(field, spec)}`
+        );
+      }
+      statements.push(...renderSqliteDdl({ [table.tableName]: table }, prefix).slice(1));
+    }
+    for (const [field, spec] of Object.entries(table.fields)) {
+      const found = existing.get(toSnakeCase(field));
+      if (found !== void 0 && found !== SQLITE_TYPE[spec.type]) {
+        unsupported.push(
+          `${qualified}.${toSnakeCase(field)} is ${found || "untyped"} but ${SQLITE_TYPE[spec.type]} is declared. Changing a column type needs a table rebuild \u2014 do it yourself.`
+        );
+      }
+    }
+    for (const column of existing.keys()) {
+      const declared = Object.keys(table.fields).some((field) => toSnakeCase(field) === column);
+      if (!declared) {
+        unsupported.push(
+          `${qualified}.${column} exists but is not declared. Left alone \u2014 drop it yourself if it is ours and no longer needed.`
+        );
+      }
+    }
+  }
+  return { statements, unsupported, createdTables };
+}
+function rebuild(table, prefix, existing) {
+  const qualified = prefix + table.tableName;
+  const temp = qualified + REBUILD_SUFFIX;
+  const [createTemp = ""] = renderSqliteDdl(
+    { [table.tableName]: { ...table, tableName: table.tableName + REBUILD_SUFFIX, indexes: [] } },
+    prefix
+  );
+  const shared = Object.keys(table.fields).map(toSnakeCase).filter((column) => existing.has(column)).map(quote6).join(", ");
+  return [
+    `DROP TABLE IF EXISTS ${quote6(temp)}`,
+    createTemp,
+    `INSERT INTO ${quote6(temp)} (${shared}) SELECT ${shared} FROM ${quote6(qualified)}`,
+    `DROP TABLE ${quote6(qualified)}`,
+    `ALTER TABLE ${quote6(temp)} RENAME TO ${quote6(qualified)}`,
+    ...renderSqliteDdl({ [table.tableName]: table }, prefix).slice(1)
+  ];
+}
+
 // src/schema/render-drizzle.ts
 var COLUMN_BUILDER = {
   string: "text",
@@ -264,115 +576,14 @@ ${body}
 `;
 }
 
-// src/schema/render-mysql.ts
-var quote3 = (value) => `\`${value.split("`").join("``")}\``;
-function stringType(field, table, spec) {
-  const keys = [
-    ...table.primaryKey ? [table.primaryKey] : [],
-    ...(table.indexes ?? []).map((index) => index.on)
-  ].filter((columns) => columns.includes(field));
-  if (keys.some((columns) => columns.length > 1)) return "VARCHAR(255)";
-  if (keys.length > 0) return "VARCHAR(768)";
-  if (spec.default !== void 0) return "VARCHAR(255)";
-  return "TEXT";
-}
-function columnType(field, table, spec) {
-  switch (spec.type) {
-    case "string":
-      return stringType(field, table, spec);
-    case "number":
-      return "INT";
-    case "boolean":
-      return "TINYINT(1)";
-    case "date":
-      return "DATETIME(3)";
-    case "json":
-      return "JSON";
-  }
-}
-var defaultClause3 = (spec) => {
-  if (spec.defaultNow) return " DEFAULT CURRENT_TIMESTAMP(3)";
-  if (spec.default === void 0) return "";
-  if (typeof spec.default === "string") return ` DEFAULT '${spec.default.replace(/'/g, "''")}'`;
-  if (typeof spec.default === "boolean") return ` DEFAULT ${spec.default ? 1 : 0}`;
-  return ` DEFAULT ${spec.default}`;
-};
-function renderMysqlDdl(schema, prefix = "") {
-  const statements = [];
-  for (const table of Object.values(schema)) {
-    const lines = Object.entries(table.fields).map(([field, spec]) => {
-      const nullability = spec.required ? " NOT NULL" : "";
-      return `  ${quote3(toSnakeCase(field))} ${columnType(field, table, spec)}${nullability}${defaultClause3(spec)}`;
-    });
-    if (table.primaryKey?.length) {
-      lines.push(
-        `  PRIMARY KEY (${table.primaryKey.map((f) => quote3(toSnakeCase(f))).join(", ")})`
-      );
-    }
-    for (const index of table.indexes ?? []) {
-      const name = quote3(prefix + (index.name ?? `${table.tableName}_${index.on.join("_")}_idx`));
-      const columns = index.on.map((f) => quote3(toSnakeCase(f))).join(", ");
-      lines.push(`  ${index.unique ? "UNIQUE " : ""}INDEX ${name} (${columns})`);
-    }
-    statements.push(
-      `CREATE TABLE IF NOT EXISTS ${quote3(prefix + table.tableName)} (
-${lines.join(",\n")}
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`
-    );
-  }
-  return statements;
-}
-
-// src/schema/render-sqlite.ts
-var SQL_TYPE3 = {
-  string: "TEXT",
-  number: "INTEGER",
-  boolean: "INTEGER",
-  // ISO-8601 with milliseconds and a trailing Z, the same 24 characters
-  // `Date#toISOString` writes, so `<=` on the text is `<=` on the instant.
-  date: "TEXT",
-  json: "TEXT"
-};
-var quote4 = (value) => `"${value.split('"').join('""')}"`;
-var defaultClause4 = (spec) => {
-  if (spec.defaultNow) return " DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))";
-  if (spec.default === void 0) return "";
-  if (typeof spec.default === "string") return ` DEFAULT '${spec.default.replace(/'/g, "''")}'`;
-  if (typeof spec.default === "boolean") return ` DEFAULT ${spec.default ? 1 : 0}`;
-  return ` DEFAULT ${spec.default}`;
-};
-function renderSqliteDdl(schema, prefix = "") {
-  const statements = [];
-  for (const table of Object.values(schema)) {
-    const name = quote4(prefix + table.tableName);
-    const columns = Object.entries(table.fields).map(([field, spec]) => {
-      const nullability = spec.required ? " NOT NULL" : "";
-      return `  ${quote4(toSnakeCase(field))} ${SQL_TYPE3[spec.type]}${nullability}${defaultClause4(spec)}`;
-    });
-    if (table.primaryKey?.length) {
-      columns.push(
-        `  PRIMARY KEY (${table.primaryKey.map((f) => quote4(toSnakeCase(f))).join(", ")})`
-      );
-    }
-    statements.push(`CREATE TABLE IF NOT EXISTS ${name} (
-${columns.join(",\n")}
-)`);
-    for (const index of table.indexes ?? []) {
-      const indexName2 = quote4(
-        prefix + (index.name ?? `${table.tableName}_${index.on.join("_")}_idx`)
-      );
-      const cols = index.on.map((f) => quote4(toSnakeCase(f))).join(", ");
-      statements.push(
-        `CREATE ${index.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${indexName2} ON ${name} (${cols})`
-      );
-    }
-  }
-  return statements;
-}
-
 exports.INTROSPECT_SQL = INTROSPECT_SQL;
+exports.MYSQL_INTROSPECT_COLUMNS_SQL = MYSQL_INTROSPECT_COLUMNS_SQL;
+exports.MYSQL_INTROSPECT_INDEXES_SQL = MYSQL_INTROSPECT_INDEXES_SQL;
+exports.SQLITE_INTROSPECT_SQL = SQLITE_INTROSPECT_SQL;
 exports.coreSchema = coreSchema;
+exports.planMysqlMigration = planMysqlMigration;
 exports.planPostgresMigration = planPostgresMigration;
+exports.planSqliteMigration = planSqliteMigration;
 exports.renderDrizzleSchema = renderDrizzleSchema;
 exports.renderMysqlDdl = renderMysqlDdl;
 exports.renderPostgresDdl = renderPostgresDdl;