@stacksjs/database 0.70.87 → 0.70.90

package/dist/drivers/sqlite.js

@@ -0,0 +1,397 @@
+import { log } from "@stacksjs/logging";
+function italic(str) {
+  return `\x1B[3m${str}\x1B[23m`;
+}
+import { app } from "@stacksjs/config";
+import { db, SQLITE_BOOTSTRAP_PRAGMAS } from "../utils";
+import { ok } from "@stacksjs/error-handling";
+import { fetchOtherModelRelations, getModelName, getPivotTables, getTableName } from "@stacksjs/orm";
+import { path } from "@stacksjs/path";
+import { fs, globSync } from "@stacksjs/storage";
+import { snakeCase } from "@stacksjs/strings";
+import {
+  arrangeColumns,
+  checkPivotMigration,
+  deleteFrameworkModels,
+  deleteMigrationFiles,
+  fetchTables,
+  findDifferingKeys,
+  getLastMigrationFields,
+  getLikeableForeignKey,
+  getUpvoteTableName,
+  isArrayEqual,
+  mapFieldTypeToColumnType,
+  pluckChanges
+} from "./helpers";
+import { dropCommonTables } from "./defaults/traits";
+export async function resetSqliteDatabase() {
+  await deleteFrameworkModels();
+  await deleteMigrationFiles();
+  await dropSqliteTables();
+  return ok("All tables dropped successfully!");
+}
+export async function configureSqlitePragmas() {
+  try {
+    for (const pragma of SQLITE_BOOTSTRAP_PRAGMAS)
+      await db.unsafe(pragma).execute();
+  } catch (err) {
+    log.debug(`[sqlite] Failed to apply pragmas: ${err.message}`);
+  }
+}
+export async function dropSqliteTables() {
+  const userModelFiles = globSync([path.userModelsPath("*.ts"), path.storagePath("framework/defaults/app/Models/**/*.ts")], { absolute: !0 }), tables = await fetchTables(), safeName = /^[a-z_][\w]*$/i;
+  await db.unsafe("PRAGMA foreign_keys = OFF").execute();
+  try {
+    for (const table of tables) {
+      if (!safeName.test(table))
+        throw Error(`[sqlite] Refusing to drop table with unsafe name: ${table}`);
+      await db.unsafe(`DROP TABLE IF EXISTS "${table}"`).execute();
+    }
+    await db.unsafe('DROP TABLE IF EXISTS "migrations"').execute();
+    await dropCommonTables();
+    for (const userModel of userModelFiles) {
+      const userModelPath = (await import(userModel)).default, pivotTables = await getPivotTables(userModelPath, userModel);
+      for (const pivotTable of pivotTables) {
+        if (!safeName.test(pivotTable.table))
+          throw Error(`[sqlite] Refusing to drop pivot table with unsafe name: ${pivotTable.table}`);
+        await db.unsafe(`DROP TABLE IF EXISTS "${pivotTable.table}"`).execute();
+      }
+    }
+  } finally {
+    await db.unsafe("PRAGMA foreign_keys = ON").execute();
+  }
+}
+export function fetchSqliteFile() {
+  if (app.env === "testing")
+    return fetchTestSqliteFile();
+  return path.userDatabasePath("stacks.sqlite");
+}
+export function fetchTestSqliteFile() {
+  return path.userDatabasePath("stacks_testing.sqlite");
+}
+export async function generateSqliteMigration(modelPath) {
+  const model = (await import(modelPath)).default, fileName = path.basename(modelPath), tableName = await getTableName(model, modelPath), fieldsString = JSON.stringify(model.attributes, null, 2), copiedModelPath = path.frameworkPath(`cache/models/${fileName}`);
+  let haveFieldsChanged = !1;
+  if (fs.existsSync(copiedModelPath)) {
+    log.debug(`Fields have already been generated for ${tableName}`);
+    const previousFields = await getLastMigrationFields(fileName);
+    if (JSON.stringify(previousFields, null, 2) === fieldsString) {
+      log.debug(`Fields have not changed for ${tableName}`);
+      return;
+    }
+    haveFieldsChanged = !0;
+    log.debug(`Fields have changed for ${tableName}`);
+  } else
+    log.debug(`Fields have not been generated for ${tableName}`);
+  await Bun.$`mkdir -p ${path.frameworkPath("cache/models")} && cp ${modelPath} ${copiedModelPath}`;
+  const hasBeenMigrated = !1;
+  log.debug(`Has ${tableName} been migrated? ${hasBeenMigrated}`);
+  if (haveFieldsChanged)
+    await createAlterTableMigration(modelPath);
+  else
+    await createTableMigration(modelPath);
+}
+export async function copyModelFiles(modelPath) {
+  const model = (await import(modelPath)).default, fileName = path.basename(modelPath), tableName = await getTableName(model, modelPath), fieldsString = JSON.stringify(model.attributes, null, 2), copiedModelPath = path.frameworkPath(`cache/models/${fileName}`);
+  if (fs.existsSync(copiedModelPath)) {
+    log.debug(`Fields have already been generated for ${tableName}`);
+    const previousFields = await getLastMigrationFields(fileName);
+    if (JSON.stringify(previousFields, null, 2) === fieldsString) {
+      log.debug(`Fields have not changed for ${tableName}`);
+      return;
+    }
+  }
+  await Bun.$`mkdir -p ${path.frameworkPath("cache/models")} && cp ${modelPath} ${copiedModelPath}`;
+}
+async function createTableMigration(modelPath) {
+  log.debug("createTableMigration modelPath:", modelPath);
+  const model = (await import(modelPath)).default, tableName = getTableName(model, modelPath), modelName = getModelName(model, modelPath), twoFactorEnabled = model.traits?.useAuth && typeof model.traits.useAuth !== "boolean" ? model.traits.useAuth.useTwoFactor : !1;
+  await createPivotTableMigration(model, modelPath);
+  const otherModelRelations = await fetchOtherModelRelations(modelName), useTimestamps = model?.traits?.useTimestamps ?? model?.traits?.timestampable ?? !0, useSocials = model?.traits?.useSocials && Array.isArray(model.traits.useSocials) && model.traits.useSocials.length > 0, useLikeable = Array.isArray(model?.traits?.likeable) ? model.traits.likeable.length > 0 : Boolean(model?.traits?.likeable), useSoftDeletes = model?.traits?.useSoftDeletes ?? model?.traits?.softDeletable ?? !1, usePasskey = (typeof model.traits?.useAuth === "object" && model.traits.useAuth.usePasskey) ?? !1, useBillable = model.traits?.billable || !1, useUuid = model.traits?.useUuid || !1;
+  let migrationContent = `import type { Database } from '@stacksjs/database'
+`;
+  migrationContent += `import { sql } from '@stacksjs/database'
+
+`;
+  migrationContent += `export async function up(db: Database<any>) {
+`;
+  migrationContent += `  await (db as any).schema
+`;
+  migrationContent += `    .createTable('${tableName}')
+`;
+  migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+`;
+  if (useUuid)
+    migrationContent += `    .addColumn('uuid', 'text')
+`;
+  if (useSocials) {
+    const socials = model.traits?.useSocials || [];
+    if (socials.includes("google"))
+      migrationContent += `    .addColumn('google_id', 'text')
+`;
+    if (socials.includes("github"))
+      migrationContent += `    .addColumn('github_id', 'text')
+`;
+    if (socials.includes("apple"))
+      migrationContent += `    .addColumn('apple_id', 'text')
+`;
+    if (socials.includes("twitter"))
+      migrationContent += `    .addColumn('twitter_id', 'text')
+`;
+    if (socials.includes("facebook"))
+      migrationContent += `    .addColumn('facebook_id', 'text')
+`;
+  }
+  for (const [fieldName, options] of arrangeColumns(model.attributes)) {
+    const fieldOptions = options, fieldNameFormatted = snakeCase(fieldName), columnType = mapFieldTypeToColumnType(fieldOptions.validation?.rule, "sqlite");
+    migrationContent += `    .addColumn('${fieldNameFormatted}', ${columnType}`;
+    const isRequired = fieldOptions.validation?.rule.isRequired;
+    if (isRequired || fieldOptions.unique || fieldOptions.default !== void 0) {
+      migrationContent += ", col => col";
+      if (isRequired)
+        migrationContent += ".notNull()";
+      if (fieldOptions.unique)
+        migrationContent += ".unique()";
+      if (fieldOptions.default !== void 0)
+        if (typeof fieldOptions.default === "string")
+          migrationContent += `.defaultTo('${fieldOptions.default}')`;
+        else if (fieldOptions.default === null)
+          migrationContent += ".defaultTo(null)";
+        else
+          migrationContent += `.defaultTo(${fieldOptions.default})`;
+      migrationContent += "";
+    }
+    migrationContent += `)
+`;
+  }
+  if (twoFactorEnabled !== !1 && twoFactorEnabled)
+    migrationContent += `    .addColumn('two_factor_secret', 'text')
+`;
+  if (useBillable)
+    migrationContent += `    .addColumn('stripe_id', 'text')
+`;
+  if (useSoftDeletes)
+    migrationContent += `    .addColumn('deleted_at', 'timestamp')
+`;
+  if (usePasskey)
+    migrationContent += `    .addColumn('public_passkey', 'text')
+`;
+  if (otherModelRelations?.length)
+    for (const modelRelation of otherModelRelations) {
+      if (!modelRelation.foreignKey)
+        continue;
+      migrationContent += `    .addColumn('${modelRelation.foreignKey}', 'integer', (col) =>
+        col.references('${modelRelation.relationTable}.id').onDelete('cascade')
+      ) 
+`;
+    }
+  if (useTimestamps) {
+    migrationContent += "    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`))\n";
+    migrationContent += `    .addColumn('updated_at', 'timestamp')
+`;
+  }
+  migrationContent += `    .execute()
+
+`;
+  if (otherModelRelations?.length)
+    for (const modelRelation of otherModelRelations) {
+      if (!modelRelation.foreignKey)
+        continue;
+      migrationContent += generateForeignKeyIndexSQL(tableName, modelRelation.foreignKey);
+    }
+  if (model.indexes?.length) {
+    migrationContent += `
+`;
+    for (const index of model.indexes)
+      migrationContent += generateIndexCreationSQL(tableName, index);
+  }
+  migrationContent += generatePrimaryKeyIndexSQL(tableName);
+  if (useLikeable) {
+    const upvoteTable = getUpvoteTableName(model, tableName);
+    if (upvoteTable) {
+      const foreignKey = getLikeableForeignKey(model, tableName);
+      migrationContent += `
+  // Create upvote table
+`;
+      migrationContent += `  await (db as any).schema
+`;
+      migrationContent += `    .createTable('${upvoteTable}')
+`;
+      migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+`;
+      migrationContent += `    .addColumn('${foreignKey}', 'integer', col => col.notNull())
+`;
+      migrationContent += `    .addColumn('user_id', 'integer', col => col.notNull())
+`;
+      migrationContent += "    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`))\n";
+      migrationContent += `    .addColumn('updated_at', 'timestamp')
+`;
+      migrationContent += `    .execute()
+
+`;
+      migrationContent += `  // Add indexes for upvote table
+`;
+      migrationContent += `  await (db as any).schema.createIndex('${upvoteTable}_${foreignKey}_index').on('${upvoteTable}').column('${foreignKey}').execute()
+`;
+      migrationContent += `  await (db as any).schema.createIndex('${upvoteTable}_user_${foreignKey}_unique').on('${upvoteTable}').columns(['user_id', '${foreignKey}']).unique().execute()
+`;
+      migrationContent += `  await (db as any).schema.createIndex('${upvoteTable}_id_index').on('${upvoteTable}').column('id').execute()
+`;
+    }
+  }
+  migrationContent += `}
+`;
+  const migrationFileName = `${new Date().getTime().toString()}-create-${tableName}-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+  await Bun.write(migrationFilePath, migrationContent);
+  log.success(`Created migration: ${italic(migrationFileName)}`);
+}
+async function createPivotTableMigration(model, modelPath) {
+  const pivotTables = await getPivotTables(model, modelPath);
+  if (!pivotTables.length)
+    return;
+  for (const pivotTable of pivotTables) {
+    if (await checkPivotMigration(pivotTable.table))
+      return;
+    let migrationContent = `import type { Database } from '@stacksjs/database'
+`;
+    migrationContent += `import { sql } from '@stacksjs/database'
+
+`;
+    migrationContent += `export async function up(db: Database<any>) {
+`;
+    migrationContent += `  await (db as any).schema
+`;
+    migrationContent += `    .createTable('${pivotTable.table}')
+`;
+    migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+`;
+    migrationContent += `    .addColumn('${pivotTable.firstForeignKey}', 'integer')
+`;
+    migrationContent += `    .addColumn('${pivotTable.secondForeignKey}', 'integer')
+`;
+    migrationContent += `    .addColumn('created_at', 'timestamp', col => col.defaultTo(sql.raw('CURRENT_TIMESTAMP')))
+`;
+    migrationContent += `    .execute()
+`;
+    migrationContent += `    }
+`;
+    const migrationFileName = `${new Date().getTime().toString()}-create-${pivotTable.table}-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+    await Bun.write(migrationFilePath, migrationContent);
+    log.success(`Created pivot migration: ${migrationFileName}`);
+  }
+}
+async function createAlterTableMigration(modelPath) {
+  const model = (await import(modelPath)).default, modelName = getModelName(model, modelPath), tableName = getTableName(model, modelPath);
+  let hasChanged = !1;
+  const oldModel = (await import(path.frameworkPath(`cache/models/${modelName}.ts`))).default, lastFields = await getLastMigrationFields(modelName) ?? {}, currentFields = model.attributes, changes = pluckChanges(Object.keys(lastFields), Object.keys(currentFields)), fieldsToAdd = changes?.added || [], fieldsToRemove = changes?.removed || [];
+  let migrationContent = `import type { Database } from '@stacksjs/database'
+`;
+  migrationContent += `import { sql } from '@stacksjs/database'
+
+`;
+  migrationContent += `export async function up(db: Database<any>) {
+`;
+  if (fieldsToAdd.length || fieldsToRemove.length) {
+    hasChanged = !0;
+    migrationContent += `  await (db as any).schema.alterTable('${tableName}')
+`;
+  }
+  const fieldValidations = findDifferingKeys(lastFields, currentFields);
+  for (const fieldValidation of fieldValidations) {
+    hasChanged = !0;
+    const fieldNameFormatted = snakeCase(fieldValidation.key);
+    migrationContent += `await sql\`
+        ALTER TABLE ${tableName}
+        MODIFY COLUMN ${fieldNameFormatted} TEXT
+      \`.execute(db)
+
+`;
+  }
+  for (const fieldName of fieldsToAdd) {
+    const options = currentFields[fieldName], columnType = mapFieldTypeToColumnType(options.validation?.rule, "sqlite"), formattedFieldName = snakeCase(fieldName), isRequired = options.validation?.rule.isRequired;
+    migrationContent += `    .addColumn('${formattedFieldName}', ${columnType}`;
+    if (isRequired || options.unique || options.default !== void 0) {
+      migrationContent += ", col => col";
+      if (isRequired)
+        migrationContent += ".notNull()";
+      if (options.unique)
+        migrationContent += ".unique()";
+      if (options.default !== void 0)
+        if (typeof options.default === "string")
+          migrationContent += `.defaultTo('${options.default}')`;
+        else if (options.default === null)
+          migrationContent += ".defaultTo(null)";
+        else
+          migrationContent += `.defaultTo(${options.default})`;
+      migrationContent += "";
+    }
+    migrationContent += `)
+
+`;
+  }
+  for (const fieldName of fieldsToRemove)
+    migrationContent += `    .dropColumn('${fieldName}')
+`;
+  if (fieldsToAdd.length || fieldsToRemove.length)
+    migrationContent += `    .execute();
+`;
+  const lastFieldOrder = Object.values(lastFields).map((attr) => attr.order), currentFieldOrder = Object.values(currentFields).map((attr) => attr.order);
+  if (!isArrayEqual(lastFieldOrder, currentFieldOrder)) {
+    hasChanged = !0;
+    migrationContent += reArrangeColumns(model.attributes, tableName);
+  }
+  const oldIndexes = oldModel.indexes || [], newIndexes = model.indexes || [];
+  for (const oldIndex of oldIndexes)
+    if (!newIndexes.find((newIndex) => newIndex.name === oldIndex.name)) {
+      hasChanged = !0;
+      migrationContent += `  await (db as any).schema.dropIndex('${oldIndex.name}').execute()
+`;
+    }
+  for (const newIndex of newIndexes)
+    if (!oldIndexes.find((oldIndex) => oldIndex.name === newIndex.name)) {
+      hasChanged = !0;
+      migrationContent += generateIndexCreationSQL(tableName, newIndex);
+    }
+  migrationContent += `}
+`;
+  const migrationFileName = `${new Date().getTime().toString()}-update-${tableName}-table.ts`, migrationFilePath = path.userMigrationsPath(migrationFileName);
+  if (hasChanged) {
+    await Bun.write(migrationFilePath, migrationContent);
+    log.success(`Created migration: ${italic(migrationFileName)}`);
+  }
+}
+function reArrangeColumns(attributes, tableName) {
+  const fields = arrangeColumns(attributes);
+  let migrationContent = "", previousField = "";
+  for (const [fieldName] of fields) {
+    const fieldNameFormatted = snakeCase(fieldName);
+    if (previousField)
+      migrationContent += `await sql\`
+        ALTER TABLE ${tableName}
+        MODIFY COLUMN ${fieldNameFormatted} TEXT NOT NULL AFTER ${snakeCase(previousField)};
+      \`.execute(db)
+
+`;
+    previousField = fieldNameFormatted;
+  }
+  return migrationContent;
+}
+export function generateIndexCreationSQL(tableName, index) {
+  if (index.unique || index.where) {
+    const unique = index.unique ? "UNIQUE " : "", cols = index.columns.map((col) => snakeCase(col)).join(", "), whereClause = index.where ? ` WHERE ${index.where}` : "";
+    return `  await db.unsafe(\`CREATE ${unique}INDEX IF NOT EXISTS "${index.name}" ON "${tableName}" (${cols})${whereClause}\`).execute()
+`;
+  }
+  const columnsStr = index.columns.map((col) => `\`${snakeCase(col)}\``).join(", ");
+  return `  await (db as any).schema.createIndex('${index.name}').on('${tableName}').columns([${columnsStr}]).execute()
+`;
+}
+function generatePrimaryKeyIndexSQL(tableName) {
+  return `  await (db as any).schema.createIndex('${tableName}_id_index').on('${tableName}').column('id').execute()
+`;
+}
+function generateForeignKeyIndexSQL(tableName, foreignKey) {
+  return `  await (db as any).schema.createIndex('${tableName}_${foreignKey}_index').on('${tableName}').column(\`${foreignKey}\`).execute()
+
+`;
+}

package/dist/factory.js

@@ -0,0 +1,51 @@
+import { log } from "@stacksjs/logging";
+import { seedModelDirect } from "./seeder";
+function resolveDefinition(input) {
+  if (input && typeof input === "object") {
+    const obj = input;
+    if (obj._definition && typeof obj._definition === "object" && "name" in obj._definition)
+      return obj._definition;
+    if ("name" in obj && (("attributes" in obj) || ("table" in obj) || ("traits" in obj)))
+      return obj;
+  }
+  throw Error("factory.generate: expected a Stacks model (the default export of app/Models/*.ts, or a defineModel() return value). Got something without a `.name` field.");
+}
+function snakeCase(str) {
+  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/(\d)([A-Za-z])/g, "$1_$2").toLowerCase();
+}
+function snakeCaseKeys(input) {
+  const out = {};
+  for (const [key, value] of Object.entries(input))
+    out[snakeCase(key)] = value;
+  return out;
+}
+export function buildSeederPayload(modelInput, options = {}) {
+  const def = resolveDefinition(modelInput), name = def.name, attributes = def.attributes ?? {}, useSeederConfig = def.traits?.useSeeder, seederDefault = useSeederConfig && typeof useSeederConfig === "object" ? useSeederConfig : void 0, count = options.count ?? seederDefault?.count ?? 10, globalOverrides = options.with ? snakeCaseKeys(options.with) : void 0, perRow = options.rows ?? seederDefault?.fixtures ?? [], fixtureCount = Math.max(count, perRow.length), fixtures = [];
+  for (let i = 0;i < fixtureCount; i++) {
+    const row = perRow[i];
+    if (!globalOverrides && !row)
+      continue;
+    fixtures[i] = { ...globalOverrides ?? {}, ...row ? snakeCaseKeys(row) : {} };
+  }
+  const table = def.table ?? `${snakeCase(name)}s`;
+  return { name, table, count: fixtureCount, fixtures, attributes, model: def };
+}
+export async function generate(modelInput, options = {}) {
+  const payload = buildSeederPayload(modelInput, options);
+  try {
+    return await seedModelDirect({
+      ...payload,
+      filePath: ""
+    }, {
+      fresh: options.fresh,
+      verbose: options.verbose ?? !1
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error(`[factory] generate(${payload.name}) failed: ${message}`);
+    throw err;
+  }
+}
+export const factory = {
+  generate
+};

package/dist/fk-audit.js

@@ -0,0 +1,181 @@
+import { existsSync } from "node:fs";
+import { dirname } from "node:path";
+import { plural, singular, snakeCase } from "@stacksjs/strings";
+import { path } from "@stacksjs/path";
+import { globSync } from "@stacksjs/storage";
+export function safeGlob(pattern) {
+  const metaIdx = pattern.search(/[*?[]/), root = metaIdx === -1 ? dirname(pattern) : dirname(pattern.slice(0, metaIdx));
+  if (!existsSync(root))
+    return [];
+  try {
+    return globSync(pattern, { absolute: !0 });
+  } catch {
+    return [];
+  }
+}
+export async function getDeclaredFKs() {
+  const modelFiles = [
+    ...safeGlob(path.userModelsPath("*.ts")),
+    ...safeGlob(path.storagePath("framework/defaults/app/Models/**/*.ts"))
+  ], declared = [];
+  for (const modelFile of modelFiles) {
+    let model;
+    try {
+      model = (await import(modelFile)).default;
+    } catch {
+      continue;
+    }
+    if (!model || typeof model !== "object")
+      continue;
+    const fromTable = model.table || plural(snakeCase(model.name || "")), belongsTo = model.belongsTo;
+    if (Array.isArray(belongsTo))
+      for (const entry of belongsTo) {
+        const related = typeof entry === "string" ? entry : entry?.model ?? "";
+        if (!related)
+          continue;
+        const fromColumn = `${snakeCase(singular(related))}_id`, toTable = plural(snakeCase(related));
+        declared.push({
+          fromTable,
+          fromColumn,
+          toTable,
+          toColumn: "id",
+          model: model.name || ""
+        });
+      }
+    else if (belongsTo && typeof belongsTo === "object")
+      for (const related of Object.keys(belongsTo)) {
+        const fromColumn = `${snakeCase(singular(related))}_id`, toTable = plural(snakeCase(related));
+        declared.push({
+          fromTable,
+          fromColumn,
+          toTable,
+          toColumn: "id",
+          model: model.name || ""
+        });
+      }
+  }
+  return declared;
+}
+export async function getLiveFKs() {
+  const { db } = await import("./utils"), dialect = await currentDialect();
+  if (dialect === "sqlite")
+    return getSqliteLiveFKs(db);
+  if (dialect === "mysql")
+    return getMysqlLiveFKs(db);
+  if (dialect === "postgres")
+    return getPostgresLiveFKs(db);
+  return [];
+}
+export async function auditForeignKeys() {
+  const declared = await getDeclaredFKs(), live = await getLiveFKs(), liveKeys = new Set(live.map((fk) => `${fk.fromTable.toLowerCase()}.${fk.fromColumn.toLowerCase()}\u2192${fk.toTable.toLowerCase()}.${fk.toColumn.toLowerCase()}`)), missing = declared.filter((d) => {
+    const key = `${d.fromTable.toLowerCase()}.${d.fromColumn.toLowerCase()}\u2192${d.toTable.toLowerCase()}.${d.toColumn.toLowerCase()}`;
+    return !liveKeys.has(key);
+  });
+  return { declared, live, missing };
+}
+export async function findFkOrphans(dialect) {
+  if ((dialect ?? await currentDialect()) !== "sqlite")
+    return { supported: !1, total: 0, orphans: [] };
+  const { db } = await import("./utils"), rows = await db.unsafe("PRAGMA foreign_key_check").execute(), checkRows = Array.isArray(rows) ? rows : [], fkListCache = new Map;
+  async function fkListFor(table) {
+    if (fkListCache.has(table))
+      return fkListCache.get(table);
+    if (!/^[a-z_]\w*$/i.test(table)) {
+      fkListCache.set(table, []);
+      return [];
+    }
+    const list = await db.unsafe(`PRAGMA foreign_key_list("${table}")`).execute(), arr = Array.isArray(list) ? list : [];
+    fkListCache.set(table, arr);
+    return arr;
+  }
+  const grouped = new Map;
+  for (const raw of checkRows) {
+    const r = raw, table = String(r.table ?? ""), parent = String(r.parent ?? "");
+    if (!table || !parent)
+      continue;
+    const fkid = Number(r.fkid ?? 0);
+    let column = "";
+    const fkList = await fkListFor(table);
+    for (const fk of fkList) {
+      const f = fk;
+      if (Number(f.id) === fkid && f.from) {
+        column = String(f.from);
+        break;
+      }
+    }
+    const key = `${table}\x00${parent}\x00${fkid}`;
+    let entry = grouped.get(key);
+    if (!entry) {
+      entry = { table, column, parent, count: 0, sampleRowids: [] };
+      grouped.set(key, entry);
+    }
+    entry.count++;
+    if (entry.sampleRowids.length < 5 && typeof r.rowid === "number")
+      entry.sampleRowids.push(r.rowid);
+  }
+  const orphans = [...grouped.values()];
+  return { supported: !0, total: orphans.reduce((sum, o) => sum + o.count, 0), orphans };
+}
+async function currentDialect() {
+  const driver = ((await import("@stacksjs/env")).env?.DB_CONNECTION ?? "sqlite").toLowerCase();
+  if (driver === "sqlite" || driver === "mysql" || driver === "postgres")
+    return driver;
+  return "other";
+}
+async function getSqliteLiveFKs(db) {
+  const tables = await db.unsafe("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"), rows = Array.isArray(tables) ? tables : [], fks = [];
+  for (const row of rows) {
+    const fromTable = row.name;
+    if (!fromTable)
+      continue;
+    if (!/^[a-z_][\w]*$/i.test(fromTable))
+      continue;
+    const fkRows = await db.unsafe(`PRAGMA foreign_key_list("${fromTable}")`);
+    for (const fk of Array.isArray(fkRows) ? fkRows : []) {
+      const r = fk;
+      if ((r.seq ?? 0) !== 0)
+        continue;
+      if (!r.from || !r.to || !r.table)
+        continue;
+      fks.push({ fromTable, fromColumn: r.from, toTable: r.table, toColumn: r.to });
+    }
+  }
+  return fks;
+}
+async function getMysqlLiveFKs(db) {
+  const rows = await db.unsafe(`
+    SELECT TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+    FROM information_schema.KEY_COLUMN_USAGE
+    WHERE TABLE_SCHEMA = DATABASE()
+      AND REFERENCED_TABLE_NAME IS NOT NULL
+  `);
+  return (Array.isArray(rows) ? rows : []).map((row) => ({
+    fromTable: String(row.TABLE_NAME ?? row.table_name ?? ""),
+    fromColumn: String(row.COLUMN_NAME ?? row.column_name ?? ""),
+    toTable: String(row.REFERENCED_TABLE_NAME ?? row.referenced_table_name ?? ""),
+    toColumn: String(row.REFERENCED_COLUMN_NAME ?? row.referenced_column_name ?? "")
+  })).filter((fk) => fk.fromTable && fk.fromColumn && fk.toTable && fk.toColumn);
+}
+async function getPostgresLiveFKs(db) {
+  const rows = await db.unsafe(`
+    SELECT
+      kcu.table_name AS from_table,
+      kcu.column_name AS from_column,
+      ccu.table_name AS to_table,
+      ccu.column_name AS to_column
+    FROM information_schema.referential_constraints rc
+    JOIN information_schema.key_column_usage kcu
+      ON kcu.constraint_name = rc.constraint_name
+    AND kcu.constraint_schema = rc.constraint_schema
+    JOIN information_schema.constraint_column_usage ccu
+      ON ccu.constraint_name = rc.constraint_name
+    AND ccu.constraint_schema = rc.constraint_schema
+    WHERE rc.constraint_schema = 'public'
+  `);
+  return (Array.isArray(rows) ? rows : []).map((row) => ({
+    fromTable: String(row.from_table ?? ""),
+    fromColumn: String(row.from_column ?? ""),
+    toTable: String(row.to_table ?? ""),
+    toColumn: String(row.to_column ?? "")
+  })).filter((fk) => fk.fromTable && fk.fromColumn && fk.toTable && fk.toColumn);
+}