@stacksjs/database 0.70.88 → 0.70.90

package/dist/migrations.js

@@ -0,0 +1,528 @@
+var {require}=import.meta;import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { log as _log } from "@stacksjs/logging";
+const log = {
+  info: (...args) => typeof _log?.info === "function" ? _log.info(...args) : console.log(...args),
+  success: (msg) => typeof _log?.success === "function" ? _log.success(msg) : console.log(msg),
+  warn: (msg) => typeof _log?.warn === "function" ? _log.warn(msg) : console.warn(msg),
+  error: (...args) => typeof _log?.error === "function" ? _log.error(...args) : console.error(...args),
+  debug: (...args) => typeof _log?.debug === "function" ? _log.debug(...args) : console.debug(...args)
+};
+import { err, handleError, ok } from "@stacksjs/error-handling";
+import { path } from "@stacksjs/path";
+import {
+  createQueryBuilder,
+  executeMigration as qbExecuteMigration,
+  generateMigration as qbGenerateMigration,
+  resetConnection,
+  resetDatabase as qbResetDatabase,
+  setConfig
+} from "@stacksjs/query-builder";
+import { db } from "./utils";
+import { acquireMigrationLock } from "./migration-lock";
+import { env as envVars } from "@stacksjs/env";
+import { getConnectionDefaults } from "./defaults";
+const dbDriver = envVars.DB_CONNECTION || "sqlite", sqliteDefaults = getConnectionDefaults("sqlite", envVars), mysqlDefaults = getConnectionDefaults("mysql", envVars), postgresDefaults = getConnectionDefaults("postgres", envVars), dbConfig = {
+  default: dbDriver,
+  connections: {
+    sqlite: { database: sqliteDefaults.database, prefix: "" },
+    mysql: { name: mysqlDefaults.database, host: mysqlDefaults.host, username: mysqlDefaults.username, password: mysqlDefaults.password, port: mysqlDefaults.port, prefix: "" },
+    postgres: { name: postgresDefaults.database, host: postgresDefaults.host, username: postgresDefaults.username, password: postgresDefaults.password, port: postgresDefaults.port, prefix: "" }
+  }
+};
+function getDriver() {
+  return dbConfig.default || "sqlite";
+}
+function getDialect() {
+  const driver = getDriver();
+  if (driver === "sqlite" || driver === "mysql" || driver === "postgres")
+    return driver;
+  if (driver === "singlestore")
+    return "mysql";
+  if (driver === "dynamodb")
+    throw Error("[database] DB_CONNECTION=dynamodb is not compatible with the SQL migration runner. " + "DynamoDB has no schema-migration concept \u2014 use the entity-style `dynamo.entity(...)` " + "API from @stacksjs/database directly. To run SQL migrations, set DB_CONNECTION to one of: sqlite, mysql, postgres.");
+  throw Error(`[database] Unknown DB_CONNECTION "${driver}". Allowed values: sqlite, mysql, postgres, dynamodb.`);
+}
+function getQbDialect() {
+  return getDriver() === "singlestore" ? "singlestore" : getDialect();
+}
+function configureQueryBuilder() {
+  const dialect = getDialect(), connectionConfig = dbConfig.connections[dialect];
+  setConfig({
+    dialect,
+    verbose: !1,
+    database: {
+      database: connectionConfig?.name || connectionConfig?.database || "stacks",
+      host: connectionConfig?.host || "localhost",
+      port: connectionConfig?.port || (dialect === "postgres" ? 5432 : dialect === "mysql" ? 3306 : 0),
+      username: connectionConfig?.username || "",
+      password: connectionConfig?.password || ""
+    }
+  });
+  resetConnection();
+}
+function prepareMigrationModelsDir() {
+  const userModelsDir = path.userModelsPath();
+  return { modelsDir: userModelsDir, skip: !existsSync(userModelsDir) };
+}
+export function preprocessSqliteMigrations() {
+  const migrationsDir = join(process.cwd(), "database", "migrations");
+  let files;
+  try {
+    files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql"));
+  } catch {
+    return;
+  }
+  const droppedMigrations = [], skipMigration = (file, reason) => {
+    log.info(`Skipping migration on SQLite (${reason}): ${file}`);
+    droppedMigrations.push(file);
+  }, deleteMigration = (file, filePath, reason) => {
+    log.info(`Dropping no-op migration (${reason}): ${file}`);
+    try {
+      unlinkSync(filePath);
+    } catch {}
+    droppedMigrations.push(file);
+  }, replayMigrations = [], addConstraintPattern = /^\s*ALTER\s+TABLE\s+.+\s+ADD\s+CONSTRAINT\s+/i, createTypePattern = /^\s*CREATE\s+TYPE\s+/i, createUniqueIndexPattern = /^\s*CREATE\s+UNIQUE\s+INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["'`]?(\w+)["'`]?/i, dropColumnPattern = /^\s*ALTER\s+TABLE\s+["']?(\w+)["']?\s+DROP\s+COLUMN\s+["']?(\w+)["']?\s*$/i, createTablePattern = /^\s*CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?/i, createTableEarliest = new Map;
+  for (const file of files) {
+    const m = file.match(/^\d+-create-(\w+)-table\.sql$/);
+    if (!m || !m[1])
+      continue;
+    const tableName = m[1], existing = createTableEarliest.get(tableName);
+    if (!existing || file < existing)
+      createTableEarliest.set(tableName, file);
+  }
+  const sqliteDbPath = join(process.cwd(), dbConfig.connections.sqlite.database || "stacks.db");
+  let sqliteDb = null;
+  if (existsSync(sqliteDbPath))
+    try {
+      const { Database } = require("bun:sqlite");
+      sqliteDb = new Database(sqliteDbPath, { readonly: !0 });
+    } catch {}
+  for (const file of files) {
+    log.debug(`[migration] Running: ${file}`);
+    const filePath = join(migrationsDir, file), statements = readFileSync(filePath, "utf-8").split(";").map((s) => s.trim()).filter((s) => s.length > 0 && !s.startsWith("--"));
+    if (statements.length === 0)
+      continue;
+    const firstStatement = statements[0], createTableMatch = firstStatement ? firstStatement.match(createTablePattern) : null;
+    if (createTableMatch && createTableMatch[1]) {
+      const tableName = createTableMatch[1], earliest = createTableEarliest.get(tableName);
+      if (earliest && earliest !== file) {
+        deleteMigration(file, filePath, `duplicate create-table for "${tableName}" (kept ${earliest})`);
+        continue;
+      }
+    }
+    if (statements.every((s) => addConstraintPattern.test(s))) {
+      skipMigration(file, "SQLite does not support ALTER TABLE ADD CONSTRAINT");
+      continue;
+    }
+    if (statements.every((s) => createTypePattern.test(s))) {
+      skipMigration(file, "SQLite does not support CREATE TYPE (enum types)");
+      continue;
+    }
+    const uniqueIndexNames = statements.map((s) => s.match(createUniqueIndexPattern)?.[1]).filter((name) => Boolean(name));
+    if (sqliteDb && uniqueIndexNames.length === statements.length) {
+      const indexExists = sqliteDb.prepare("SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?");
+      if (uniqueIndexNames.filter((name) => !indexExists.get(name)).length > 0) {
+        log.info(`Re-queueing unique-index migration (index missing from database): ${file}`);
+        replayMigrations.push(file);
+      }
+      continue;
+    }
+    if (statements.some((s) => dropColumnPattern.test(s))) {
+      let modified = !1;
+      const filteredStatements = [];
+      for (const stmt of statements) {
+        const dropColMatch = stmt.match(dropColumnPattern);
+        if (dropColMatch && dropColMatch[1] && dropColMatch[2]) {
+          const tableName = dropColMatch[1], columnName = dropColMatch[2];
+          if (!sqliteDb) {
+            log.info(`Skipping DROP COLUMN "${columnName}" \u2014 no database exists yet: ${file}`);
+            modified = !0;
+            continue;
+          }
+          try {
+            const safeTableName = tableName.replace(/[^a-zA-Z0-9_]/g, ""), columns = sqliteDb.prepare(`PRAGMA table_info("${safeTableName}")`).all();
+            if (columns.length === 0) {
+              log.info(`Skipping DROP COLUMN "${columnName}" \u2014 table "${tableName}" does not exist yet: ${file}`);
+              modified = !0;
+              continue;
+            }
+            if (!columns.some((col) => col.name === columnName)) {
+              log.info(`Skipping DROP COLUMN "${columnName}" from "${tableName}" \u2014 column does not exist: ${file}`);
+              modified = !0;
+              continue;
+            }
+          } catch {
+            log.info(`Skipping DROP COLUMN "${columnName}" \u2014 table "${tableName}" not found: ${file}`);
+            modified = !0;
+            continue;
+          }
+        }
+        filteredStatements.push(stmt);
+      }
+      if (modified) {
+        if (filteredStatements.length === 0)
+          deleteMigration(file, filePath, "columns already absent from table");
+        else
+          writeFileSync(filePath, `${filteredStatements.join(`;
+`)};
+`);
+        continue;
+      }
+    }
+  }
+  if (sqliteDb)
+    try {
+      sqliteDb.close();
+    } catch {}
+  if (droppedMigrations.length > 0 || replayMigrations.length > 0)
+    try {
+      const dbPath = join(process.cwd(), dbConfig.connections.sqlite.database || "stacks.db");
+      mkdirSync(dirname(dbPath), { recursive: !0 });
+      const { Database } = require("bun:sqlite"), writeDb = new Database(dbPath);
+      try {
+        writeDb.exec(`CREATE TABLE IF NOT EXISTS migrations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          migration TEXT NOT NULL UNIQUE,
+          executed_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )`);
+        const insert = writeDb.prepare("INSERT OR IGNORE INTO migrations (migration) VALUES (?)");
+        for (const migration of droppedMigrations)
+          insert.run(migration);
+        const unrecord = writeDb.prepare("DELETE FROM migrations WHERE migration = ?");
+        for (const migration of replayMigrations)
+          unrecord.run(migration);
+      } finally {
+        writeDb.close();
+      }
+    } catch (e) {
+      log.debug(`[migration] Could not record dropped migrations as executed: ${e}`);
+    }
+}
+async function ensureDatabaseExists() {
+  const dialect = getDialect();
+  if (dialect === "sqlite")
+    return;
+  const connectionConfig = dbConfig.connections[dialect], dbName = (connectionConfig?.name || "stacks").replace(/['"]/g, ""), host = connectionConfig?.host || "localhost", port = connectionConfig?.port || (dialect === "postgres" ? 5432 : 3306), username = connectionConfig?.username || (dialect === "postgres" ? process.env.USER || "postgres" : "root"), password = connectionConfig?.password || "", adminDatabase = dialect === "postgres" ? "postgres" : "mysql";
+  try {
+    setConfig({
+      dialect,
+      database: {
+        database: adminDatabase,
+        host,
+        port,
+        username,
+        password
+      }
+    });
+    resetConnection();
+    const adminDb = createQueryBuilder();
+    if (dialect === "postgres")
+      try {
+        await adminDb.unsafe(`CREATE DATABASE "${dbName}"`);
+        log.info(`Created database "${dbName}"`);
+      } catch (e) {
+        if (e?.message?.includes("already exists") || e?.errno === "42P04")
+          log.info(`Database "${dbName}" already exists`);
+        else
+          throw e;
+      }
+    else if (dialect === "mysql")
+      try {
+        await adminDb.unsafe(`CREATE DATABASE IF NOT EXISTS \`${dbName}\``);
+        log.info(`Ensured database "${dbName}" exists`);
+      } catch (e) {
+        if (e?.message?.includes("database exists"))
+          log.info(`Database "${dbName}" already exists`);
+        else
+          throw e;
+      }
+    resetConnection();
+  } catch (error) {
+    log.warn(`Could not auto-create database "${dbName}": ${error?.message || error}`);
+    log.info("If the database already exists, this warning can be ignored.");
+    resetConnection();
+  }
+}
+async function hideDisabledFeatureMigrations() {
+  const hidden = [];
+  try {
+    const { FEATURE_NAMES, migrationFeature } = await import("@stacksjs/buddy"), { feature: isFeatureEnabled } = await import("@stacksjs/config"), fs = await import("node:fs/promises"), migrationsDir = path.projectPath("database/migrations");
+    if (!existsSync(migrationsDir))
+      return hidden;
+    const disabledFeatures = new Set(FEATURE_NAMES.filter((f) => !isFeatureEnabled(f)));
+    if (disabledFeatures.size === 0)
+      return hidden;
+    const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql"));
+    for (const file of files) {
+      const owner = migrationFeature(file);
+      if (!owner || !disabledFeatures.has(owner))
+        continue;
+      const original = join(migrationsDir, file), hiddenPath = `${original}.disabled`;
+      await fs.rename(original, hiddenPath);
+      hidden.push({ original, hidden: hiddenPath, feature: owner });
+    }
+    if (hidden.length > 0) {
+      const summary = Object.entries(hidden.reduce((acc, h) => {
+        acc[h.feature] = (acc[h.feature] ?? 0) + 1;
+        return acc;
+      }, {})).map(([f, n]) => `${f}: ${n}`).join(", ");
+      log.info(`[migration] Skipping ${hidden.length} migration(s) for disabled features (${summary}). Run \`./buddy <feature>:install\` to enable.`);
+    }
+  } catch {}
+  return hidden;
+}
+async function restoreHiddenMigrations(hidden) {
+  const fs = await import("node:fs/promises");
+  for (const { original, hidden: h } of hidden)
+    try {
+      await fs.rename(h, original);
+    } catch {}
+}
+async function countAppliedMigrations() {
+  try {
+    const row = await db.selectFrom("migrations").select((eb) => eb.fn.count("id").as("n")).executeTakeFirst();
+    if (!row)
+      return 0;
+    const n = Number(row.n ?? row.N ?? 0);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+async function writeMigrateMarker(appliedCount) {
+  try {
+    const fs = await import("node:fs/promises"), dir = path.projectPath(".stacks");
+    await fs.mkdir(dir, { recursive: !0 });
+    const file = `${dir}/last-migrate-result.json`, body = JSON.stringify({
+      appliedCount,
+      completedAt: new Date().toISOString()
+    });
+    await fs.writeFile(file, body, "utf8");
+  } catch {}
+}
+export async function runDatabaseMigration() {
+  const startedAt = Date.now(), hidden = await hideDisabledFeatureMigrations();
+  let lockHandle = null;
+  try {
+    log.debug("Migrating database...");
+    await ensureDatabaseExists();
+    configureQueryBuilder();
+    const dialect = getDialect(), lockDb = dialect === "sqlite" ? null : createQueryBuilder();
+    lockHandle = await acquireMigrationLock(dialect, lockDb);
+    if (dialect === "sqlite")
+      preprocessSqliteMigrations();
+    const modelsDir = path.userModelsPath(), appliedBefore = await countAppliedMigrations();
+    log.debug(`[migration] Running migrations from: ${modelsDir}`);
+    await qbExecuteMigration(modelsDir);
+    const appliedAfter = await countAppliedMigrations(), appliedCount = Math.max(0, appliedAfter - appliedBefore);
+    await writeMigrateMarker(appliedCount);
+    log.debug(`Database migration completed in ${Date.now() - startedAt}ms (applied ${appliedCount}).`);
+    return ok(appliedCount === 0 ? "Nothing to migrate." : `Applied ${appliedCount} migration${appliedCount === 1 ? "" : "s"}.`);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    log.error(`[migration] Failed after ${Date.now() - startedAt}ms: ${detail}`);
+    log.info("[migration] Run `./buddy migrate:fresh` to drop and recreate the schema if state is partial.");
+    return err(handleError("Migration failed", error));
+  } finally {
+    if (lockHandle)
+      try {
+        await lockHandle.release();
+      } catch {}
+    await restoreHiddenMigrations(hidden);
+  }
+}
+const FRAMEWORK_TABLES = [
+  "oauth_refresh_tokens",
+  "oauth_access_tokens",
+  "oauth_clients",
+  "passkeys",
+  "failed_jobs",
+  "jobs",
+  "notifications",
+  "password_reset_tokens"
+];
+export async function resetDatabase() {
+  try {
+    configureQueryBuilder();
+    const modelsDir = path.userModelsPath(), dialect = getDialect();
+    await dropFrameworkTables(dialect);
+    await qbResetDatabase(modelsDir, { dialect });
+    return ok("All tables dropped successfully!");
+  } catch (error) {
+    return err(handleError("Database reset failed", error));
+  }
+}
+async function dropFrameworkTables(dialect) {
+  if (dialect === "mysql")
+    try {
+      await db.unsafe("SET FOREIGN_KEY_CHECKS = 0").execute();
+    } catch (error) {
+      log.warn(`Could not disable foreign key checks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  if (dialect === "sqlite")
+    try {
+      await db.unsafe("PRAGMA foreign_keys = OFF").execute();
+    } catch (error) {
+      log.warn(`Could not disable foreign key checks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  for (const tableName of FRAMEWORK_TABLES)
+    try {
+      let dropSql;
+      if (dialect === "postgres")
+        dropSql = `DROP TABLE IF EXISTS "${tableName}" CASCADE`;
+      else if (dialect === "mysql")
+        dropSql = `DROP TABLE IF EXISTS \`${tableName}\``;
+      else
+        dropSql = `DROP TABLE IF EXISTS "${tableName}"`;
+      log.info(`Dropping framework table: ${tableName}`);
+      await db.unsafe(dropSql).execute();
+      log.info(`Dropped framework table: ${tableName}`);
+    } catch (error) {
+      log.warn(`Could not drop table ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  if (dialect === "mysql")
+    try {
+      await db.unsafe("SET FOREIGN_KEY_CHECKS = 1").execute();
+    } catch (error) {
+      log.warn(`Could not re-enable foreign key checks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  if (dialect === "sqlite")
+    try {
+      await db.unsafe("PRAGMA foreign_keys = ON").execute();
+    } catch (error) {
+      log.warn(`Could not re-enable foreign key checks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function resolveGenerateOptions(options) {
+  const applyRenames = options.applyRenames ?? (process.env.STACKS_MIGRATE_NO_RENAME === "1" ? !1 : void 0), fromDb = options.fromDb ?? (process.env.STACKS_MIGRATE_FROM_DB === "1" ? !0 : void 0);
+  return { applyRenames, fromDb };
+}
+export async function previewPendingMigrations(options = {}) {
+  try {
+    configureQueryBuilder();
+    const dialect = getDialect(), { modelsDir, skip } = prepareMigrationModelsDir();
+    if (skip)
+      return [];
+    const { applyRenames, fromDb } = resolveGenerateOptions(options);
+    return (await qbGenerateMigration(modelsDir, { dialect: getQbDialect(), dryRun: !0, applyRenames, fromDb })).operations ?? [];
+  } catch (error) {
+    log.debug(`[migration] preview failed: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+export async function generateMigrations(options = {}) {
+  try {
+    log.debug("Generating migrations...");
+    configureQueryBuilder();
+    const dialect = getDialect(), { modelsDir, skip } = prepareMigrationModelsDir();
+    if (skip) {
+      log.debug("No app/Models directory found; using committed framework migrations");
+      return ok("Migrations generated");
+    }
+    const { applyRenames, fromDb } = resolveGenerateOptions(options);
+    log.debug(`[migration] Generating migrations for dialect: ${dialect}, models: ${modelsDir}`);
+    const result = await qbGenerateMigration(modelsDir, { dialect: getQbDialect(), dryRun: !0, applyRenames, fromDb });
+    if (result.hasChanges) {
+      const written = persistGeneratedMigrations(result.sqlStatements ?? []);
+      if (written > 0)
+        log.success(`Generated ${written} migration file${written === 1 ? "" : "s"}`);
+      else
+        log.debug("Migration generation produced no new files (already up to date)");
+    } else
+      log.debug("No changes detected");
+    return ok("Migrations generated");
+  } catch (error) {
+    return err(handleError("Migration generation failed", error));
+  }
+}
+function persistGeneratedMigrations(sqlStatements) {
+  if (!sqlStatements?.length)
+    return 0;
+  const migrationsDir = join(process.cwd(), "database", "migrations");
+  try {
+    require("node:fs").mkdirSync(migrationsDir, { recursive: !0 });
+  } catch {}
+  let existingSql = "";
+  try {
+    for (const f of readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")))
+      existingSql += `
+${readFileSync(join(migrationsDir, f), "utf8")}`;
+  } catch {}
+  const normalize = (s) => s.replace(/\s+/g, " ").trim(), haystack = normalize(existingSql), groups = groupGeneratedStatements(sqlStatements);
+  let written = 0, cursor = nextMigrationNumber(migrationsDir);
+  for (const group of groups) {
+    const fresh = group.statements.filter((stmt) => !haystack.includes(normalize(stmt)));
+    if (fresh.length === 0)
+      continue;
+    const filename = `${String(cursor).padStart(10, "0")}-${group.label}.sql`, filePath = join(migrationsDir, filename), body = `${fresh.map((s) => s.trim().replace(/;\s*$/, "")).join(`;
+`)};
+`;
+    writeFileSync(filePath, body);
+    log.debug(`[migration] Wrote ${filename} (${fresh.length} stmt${fresh.length === 1 ? "" : "s"})`);
+    written += 1;
+    cursor += 1;
+  }
+  return written;
+}
+function groupGeneratedStatements(sqlStatements) {
+  const groups = new Map, push = (label, stmt) => {
+    const list = groups.get(label) ?? [];
+    list.push(stmt);
+    groups.set(label, list);
+  };
+  for (const raw of sqlStatements) {
+    const stmt = raw.trim();
+    if (!stmt)
+      continue;
+    const create = stmt.match(/^\s*CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?(\w+)["`]?/i);
+    if (create) {
+      push(`create-${create[1]}-table`, stmt);
+      continue;
+    }
+    const alter = stmt.match(/^\s*ALTER\s+TABLE\s+["`]?(\w+)["`]?\s+(?:ADD\s+COLUMN\s+["`]?(\w+)["`]?|DROP\s+COLUMN\s+["`]?(\w+)["`]?|ADD\s+CONSTRAINT)/i);
+    if (alter) {
+      push(`alter-${alter[1]}-${alter[2] || alter[3] || "constraint"}`, stmt);
+      continue;
+    }
+    const idx = stmt.match(/^\s*CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?(\w+)["`]?\s+ON\s+["`]?(\w+)["`]?/i);
+    if (idx) {
+      push(`create-${idx[1]}-index-in-${idx[2]}`, stmt);
+      continue;
+    }
+    const drop = stmt.match(/^\s*DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?["`]?(\w+)["`]?/i);
+    if (drop) {
+      push(`drop-${drop[1]}-table`, stmt);
+      continue;
+    }
+    push("auto-misc", stmt);
+  }
+  return [...groups.entries()].map(([label, statements]) => ({ label, statements }));
+}
+function nextMigrationNumber(migrationsDir) {
+  let max = 0;
+  try {
+    for (const f of readdirSync(migrationsDir)) {
+      const m = f.match(/^(\d+)-/);
+      if (m?.[1])
+        max = Math.max(max, Number.parseInt(m[1], 10));
+    }
+  } catch {}
+  return max + 1;
+}
+export async function generateMigrations2() {
+  try {
+    log.info("Generating fresh migrations...");
+    configureQueryBuilder();
+    const dialect = getDialect(), { modelsDir, skip } = prepareMigrationModelsDir();
+    if (skip) {
+      log.info("No app/Models directory found; using committed framework migrations");
+      return ok("Migrations generated");
+    }
+    await qbGenerateMigration(modelsDir, { dialect: getQbDialect(), full: !0, dryRun: !0 });
+    log.success("Migrations generated");
+    return ok("Migrations generated");
+  } catch (error) {
+    return err(handleError("Fresh migration generation failed", error));
+  }
+}

package/dist/notification-tables.d.ts

@@ -0,0 +1,20 @@
+import { sqlHelpers } from './sql-helpers';
+/**
+ * `CREATE TABLE IF NOT EXISTS notifications` for the given dialect.
+ * Pure (no execution) so the cross-dialect DDL is unit-testable.
+ * Columns match the `DatabaseNotification` interface in
+ * `notifications/src/drivers/database.ts`.
+ */
+export declare function notificationsTableSql(sql: SqlHelpers): string;
+/**
+ * `CREATE TABLE IF NOT EXISTS notification_preferences`. The
+ * `UNIQUE (user_id, channel, category)` constraint is what makes the
+ * preference upsert safe — matches `NotificationPreferenceRow`.
+ */
+export declare function notificationPreferencesTableSql(sql: SqlHelpers): string;
+/**
+ * Create the notification + notification_preferences tables. Idempotent
+ * (`IF NOT EXISTS`), so it's safe to run on every `buddy migrate`.
+ */
+export declare function migrateNotificationTables(options?: { verbose?: boolean }): Promise<{ success: boolean, error?: string }>;
+declare type SqlHelpers = ReturnType<typeof sqlHelpers>;

package/dist/notification-tables.js

@@ -0,0 +1,54 @@
+import { log } from "@stacksjs/logging";
+import { env as envVars } from "@stacksjs/env";
+import { db } from "./utils";
+import { sqlHelpers } from "./sql-helpers";
+function getDbDriver() {
+  return envVars.DB_CONNECTION || "sqlite";
+}
+export function notificationsTableSql(sql) {
+  const { pkColumn, nullableTimestamp } = sql;
+  return `CREATE TABLE IF NOT EXISTS notifications (
+    ${pkColumn},
+    user_id INTEGER NOT NULL,
+    type VARCHAR(255) NOT NULL,
+    data TEXT NOT NULL,
+    read_at ${nullableTimestamp},
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at ${nullableTimestamp}
+  )`;
+}
+export function notificationPreferencesTableSql(sql) {
+  const { pkColumn, boolTrue, nullableTimestamp } = sql;
+  return `CREATE TABLE IF NOT EXISTS notification_preferences (
+    ${pkColumn},
+    user_id INTEGER NOT NULL,
+    channel VARCHAR(50) NOT NULL,
+    enabled BOOLEAN NOT NULL DEFAULT ${boolTrue},
+    category VARCHAR(255),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at ${nullableTimestamp},
+    UNIQUE (user_id, channel, category)
+  )`;
+}
+export async function migrateNotificationTables(options = {}) {
+  const dbDriver = getDbDriver(), sql = sqlHelpers(dbDriver);
+  if (options.verbose)
+    log.info(`Creating notification tables for ${dbDriver}...`);
+  try {
+    if (options.verbose)
+      log.info("Creating notifications table...");
+    await db.unsafe(notificationsTableSql(sql)).execute();
+    await db.unsafe("CREATE INDEX IF NOT EXISTS idx_notifications_user ON notifications (user_id)").execute();
+    if (options.verbose)
+      log.info("Creating notification_preferences table...");
+    await db.unsafe(notificationPreferencesTableSql(sql)).execute();
+    await db.unsafe("CREATE INDEX IF NOT EXISTS idx_notification_preferences_user ON notification_preferences (user_id)").execute();
+    if (options.verbose)
+      log.success("Notification tables created");
+    return { success: !0 };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(`Failed to create notification tables: ${message}`);
+    return { success: !1, error: message };
+  }
+}

package/dist/query-logger.d.ts

@@ -0,0 +1,26 @@
+export declare function setQueryTracker(fn: QueryTracker): void;
+/**
+ * Process an executed query and store it in the database
+ */
+export declare function logQuery(event: LogEvent): Promise<void>;
+/**
+ * Query log event type - compatible with bun-query-builder hooks
+ */
+declare interface LogEvent {
+  query?: {
+    sql?: string
+    parameters?: unknown[]
+  }
+  queryDurationMillis?: number
+  error?: Error | unknown
+}
+/**
+ * Soft dependency on the router's query tracker. Importing it directly
+ * creates the cycle `database → router → database` (router uses db
+ * helpers transitively via middleware). The DI shape below lets the
+ * router register its tracker at module-init time and lets the database
+ * package stay leaf-node — runs that don't load the router (CLI tools,
+ * cron tasks) silently no-op the tracker call.
+ */
+// eslint-disable-next-line pickier/no-unused-vars
+declare type QueryTracker = (query: string, durationMs?: number, connection?: string) => void;