@bobbykim/manguito-cms-db 0.1.0

package/dist/index.mjs

@@ -0,0 +1,727 @@
+// src/index.ts
+import { sql as sql4 } from "drizzle-orm";
+
+// src/adapters/postgres.ts
+import { drizzle as drizzleNode } from "drizzle-orm/node-postgres";
+import { drizzle as drizzleNeon } from "drizzle-orm/neon-http";
+import { neon } from "@neondatabase/serverless";
+import { Pool } from "pg";
+import { sql } from "drizzle-orm";
+function createPostgresAdapter(options = {}) {
+  const url = options.url ?? process.env["DB_URL"];
+  if (!url) {
+    throw new Error(
+      "DB_URL_MISSING: No database URL provided. Set the DB_URL environment variable or pass a url option."
+    );
+  }
+  if (!/^postgres(?:ql)?:\/\//i.test(url)) {
+    throw new Error(
+      "DB_URL_INVALID: Database URL must begin with postgres:// or postgresql://"
+    );
+  }
+  const isNeon = options.serverless ?? url.includes("neon.tech");
+  const poolConfig = {
+    max: options.pool?.max ?? 10,
+    idle_timeout: options.pool?.idle_timeout ?? 30,
+    connect_timeout: options.pool?.connect_timeout ?? 10
+  };
+  let db = null;
+  let pool = null;
+  let connected = false;
+  return {
+    type: "postgres",
+    async connect() {
+      if (isNeon) {
+        const sqlClient = neon(url);
+        db = drizzleNeon(sqlClient);
+      } else {
+        pool = new Pool({
+          connectionString: url,
+          max: poolConfig.max,
+          idleTimeoutMillis: poolConfig.idle_timeout * 1e3,
+          connectionTimeoutMillis: poolConfig.connect_timeout * 1e3
+        });
+        const client = await pool.connect();
+        client.release();
+        db = drizzleNode(pool);
+      }
+      connected = true;
+    },
+    async disconnect() {
+      if (pool) {
+        await pool.end();
+        pool = null;
+      }
+      db = null;
+      connected = false;
+    },
+    isConnected() {
+      return connected;
+    },
+    getDb() {
+      if (!db) {
+        throw new Error(
+          "DB not connected \u2014 call connect() before accessing the database."
+        );
+      }
+      return db;
+    },
+    async getTableNames() {
+      if (!db) throw new Error("DB not connected");
+      const result = await db.execute(
+        sql`SELECT table_name
+            FROM information_schema.tables
+            WHERE table_schema = 'public'
+            ORDER BY table_name`
+      );
+      return result.rows.map((r) => r.table_name);
+    },
+    async tableExists(name) {
+      if (!db) throw new Error("DB not connected");
+      const result = await db.execute(
+        sql`SELECT 1
+            FROM information_schema.tables
+            WHERE table_schema = 'public'
+              AND table_name = ${name}
+            LIMIT 1`
+      );
+      return result.rows.length > 0;
+    }
+  };
+}
+
+// src/codegen/index.ts
+function generateFileHeader() {
+  return "import * as s from 'drizzle-orm/pg-core'\nimport { sql } from 'drizzle-orm'";
+}
+var SYSTEM_TABLES_SECTION = `// \u2500\u2500\u2500 System Tables \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+export const media = s.pgTable('media', {
+  id: s.uuid('id').primaryKey().defaultRandom(),
+  type: s.varchar('type', { length: 50 }).notNull(),
+  url: s.varchar('url', { length: 2048 }).notNull(),
+  mime_type: s.varchar('mime_type', { length: 255 }).notNull(),
+  alt: s.varchar('alt', { length: 255 }),
+  file_size: s.integer('file_size').notNull(),
+  width: s.integer('width'),
+  height: s.integer('height'),
+  duration: s.integer('duration'),
+  reference_count: s.integer('reference_count').notNull().default(0),
+  created_at: s.timestamp('created_at').defaultNow().notNull(),
+  updated_at: s.timestamp('updated_at').defaultNow().notNull(),
+})
+
+export const base_paths = s.pgTable('base_paths', {
+  id: s.uuid('id').primaryKey().defaultRandom(),
+  name: s.varchar('name', { length: 255 }).notNull().unique(),
+  path: s.varchar('path', { length: 1024 }).notNull().unique(),
+  created_at: s.timestamp('created_at').defaultNow().notNull(),
+  updated_at: s.timestamp('updated_at').defaultNow().notNull(),
+})
+
+export const roles = s.pgTable('roles', {
+  id: s.uuid('id').primaryKey().defaultRandom(),
+  name: s.varchar('name', { length: 255 }).notNull().unique(),
+  label: s.varchar('label', { length: 255 }).notNull(),
+  is_system: s.boolean('is_system').notNull().default(false),
+  hierarchy_level: s.integer('hierarchy_level').notNull().unique(),
+  permissions: s.text('permissions').array().notNull(),
+  created_at: s.timestamp('created_at').defaultNow().notNull(),
+  updated_at: s.timestamp('updated_at').defaultNow().notNull(),
+})
+
+export const users = s.pgTable('users', {
+  id: s.uuid('id').primaryKey().defaultRandom(),
+  email: s.varchar('email', { length: 255 }).notNull().unique(),
+  password_hash: s.varchar('password_hash', { length: 255 }).notNull(),
+  role_id: s.uuid('role_id')
+    .notNull()
+    .references(() => roles.id, { onDelete: 'restrict' }),
+  token_version: s.integer('token_version').notNull().default(0),
+  must_change_password: s.boolean('must_change_password').notNull().default(false),
+  created_at: s.timestamp('created_at').defaultNow().notNull(),
+  updated_at: s.timestamp('updated_at').defaultNow().notNull(),
+})`;
+function generateSystemFieldColumn(field) {
+  const { name, db_type, primary_key, default: defaultVal, nullable } = field;
+  const col = buildSystemBase(name, db_type, primary_key, defaultVal);
+  return primary_key || nullable ? col : col + ".notNull()";
+}
+function buildSystemBase(name, db_type, primary_key, defaultVal) {
+  switch (db_type) {
+    case "uuid":
+      return primary_key ? `s.uuid('${name}').primaryKey().defaultRandom()` : `s.uuid('${name}')`;
+    case "varchar":
+      return `s.varchar('${name}')`;
+    case "boolean": {
+      const suffix = defaultVal === "false" ? ".default(false)" : defaultVal === "true" ? ".default(true)" : "";
+      return `s.boolean('${name}')${suffix}`;
+    }
+    case "timestamp":
+      return defaultVal === "now()" ? `s.timestamp('${name}').defaultNow()` : `s.timestamp('${name}')`;
+    case "integer":
+      return defaultVal !== void 0 ? `s.integer('${name}').default(${Number(defaultVal)})` : `s.integer('${name}')`;
+  }
+}
+function mapOnDelete(on_delete) {
+  if (on_delete === "CASCADE") return "cascade";
+  if (on_delete === "SET NULL") return "set null";
+  return "restrict";
+}
+function generateFieldColumn(field) {
+  if (field.field_type === "paragraph" || field.db_column === null) return null;
+  const col = field.db_column;
+  if (col.junction) return null;
+  const n = col.column_name;
+  const isEnum = col.check_constraint !== void 0 && col.check_constraint.length > 0;
+  let expr = buildFieldBase(n, col.column_type, isEnum, field.validation.limit);
+  if (!col.nullable) expr += ".notNull()";
+  if (col.foreign_key) {
+    const onDelete = mapOnDelete(col.foreign_key.on_delete);
+    expr += `.references(() => ${col.foreign_key.table}.${col.foreign_key.column}, { onDelete: '${onDelete}' })`;
+  }
+  return expr;
+}
+function buildFieldBase(name, column_type, isEnum, limit) {
+  switch (column_type) {
+    case "varchar":
+      return isEnum ? `s.varchar('${name}')` : `s.varchar('${name}', { length: ${limit ?? 255} })`;
+    case "text":
+      return `s.text('${name}')`;
+    case "integer":
+      return `s.integer('${name}')`;
+    case "decimal":
+      return `s.decimal('${name}', { precision: 10, scale: 4 })`;
+    case "boolean":
+      return `s.boolean('${name}')`;
+    case "timestamp":
+      return `s.timestamp('${name}')`;
+    case "uuid":
+      return `s.uuid('${name}')`;
+  }
+}
+function tableNameToVarName(tableName) {
+  return tableName.replace(/-/g, "_");
+}
+function generateTableDef(tableName, varName, systemFields, fields) {
+  const colLines = [];
+  for (const f of systemFields) {
+    colLines.push(`${f.name}: ${generateSystemFieldColumn(f)},`);
+  }
+  for (const f of fields) {
+    const colExpr = generateFieldColumn(f);
+    if (colExpr === null) continue;
+    colLines.push(`${f.db_column.column_name}: ${colExpr},`);
+  }
+  const enumFields = fields.filter(
+    (f) => (f.db_column?.check_constraint?.length ?? 0) > 0
+  );
+  if (enumFields.length === 0) {
+    const colBlock2 = colLines.map((l) => `  ${l}`).join("\n");
+    return `export const ${varName} = s.pgTable('${tableName}', {
+${colBlock2}
+})`;
+  }
+  const colBlock = colLines.map((l) => `    ${l}`).join("\n");
+  const constraints = enumFields.map((f) => {
+    const col = f.db_column;
+    const values = col.check_constraint.map((v) => `'${v}'`).join(", ");
+    const cname = `${col.column_name}_check`;
+    return [
+      `    ${cname}: s.check(`,
+      `      '${cname}',`,
+      `      sql\`\${table.${col.column_name}} IN (${values})\``,
+      `    ),`
+    ].join("\n");
+  }).join("\n");
+  return [
+    `export const ${varName} = s.pgTable(`,
+    `  '${tableName}',`,
+    `  {`,
+    colBlock,
+    `  },`,
+    `  (table) => ({`,
+    constraints,
+    `  })`,
+    `)`
+  ].join("\n");
+}
+function orderParagraphTypes(paragraphs) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name)) return;
+    visited.add(name);
+    const paragraph = paragraphs[name];
+    if (!paragraph) return;
+    for (const field of paragraph.fields) {
+      if (field.field_type === "paragraph") {
+        const ref = field.ui_component.ref;
+        visit(ref);
+      }
+    }
+    sorted.push(paragraph);
+  }
+  for (const name of Object.keys(paragraphs)) visit(name);
+  return sorted;
+}
+function generateJunctionTables(registry) {
+  const tables = [];
+  for (const ct of Object.values(registry.content_types)) {
+    const leftVar = tableNameToVarName(ct.db.table_name);
+    for (const jt of ct.db.junction_tables) {
+      const varName = tableNameToVarName(jt.table_name);
+      const rightVar = tableNameToVarName(jt.right_table);
+      const orderLine = jt.order_column ? `    order: s.integer('order').notNull().default(0),` : null;
+      const def = [
+        `export const ${varName} = s.pgTable(`,
+        `  '${jt.table_name}',`,
+        `  {`,
+        `    ${jt.left_column}: s.uuid('${jt.left_column}')`,
+        `      .notNull()`,
+        `      .references(() => ${leftVar}.id, { onDelete: 'cascade' }),`,
+        `    ${jt.right_column}: s.uuid('${jt.right_column}')`,
+        `      .notNull()`,
+        `      .references(() => ${rightVar}.id, { onDelete: 'cascade' }),`,
+        ...orderLine ? [orderLine] : [],
+        `  }`,
+        `)`
+      ].join("\n");
+      tables.push(def);
+    }
+  }
+  if (tables.length === 0) return "";
+  return "// \u2500\u2500\u2500 Junction Tables \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n" + tables.join("\n\n");
+}
+function generateSchemaFile(registry) {
+  const sections = [generateFileHeader(), SYSTEM_TABLES_SECTION];
+  const taxonomyTypes = Object.values(registry.taxonomy_types);
+  if (taxonomyTypes.length > 0) {
+    const header = "// \u2500\u2500\u2500 Taxonomy Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+    const defs = taxonomyTypes.map(
+      (t) => generateTableDef(
+        t.db.table_name,
+        tableNameToVarName(t.db.table_name),
+        t.system_fields,
+        t.fields
+      )
+    );
+    sections.push(header + "\n" + defs.join("\n\n"));
+  }
+  const paragraphTypes = orderParagraphTypes(registry.paragraph_types);
+  if (paragraphTypes.length > 0) {
+    const header = "// \u2500\u2500\u2500 Paragraph Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+    const defs = paragraphTypes.map(
+      (p) => generateTableDef(
+        p.db.table_name,
+        tableNameToVarName(p.db.table_name),
+        p.system_fields,
+        p.fields
+      )
+    );
+    sections.push(header + "\n" + defs.join("\n\n"));
+  }
+  const contentTypes = Object.values(registry.content_types);
+  if (contentTypes.length > 0) {
+    const header = "// \u2500\u2500\u2500 Content Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+    const defs = contentTypes.map(
+      (c) => generateTableDef(
+        c.db.table_name,
+        tableNameToVarName(c.db.table_name),
+        c.system_fields,
+        c.fields
+      )
+    );
+    sections.push(header + "\n" + defs.join("\n\n"));
+  }
+  const junctionSection = generateJunctionTables(registry);
+  if (junctionSection) sections.push(junctionSection);
+  return sections.join("\n\n");
+}
+
+// src/seeder/index.ts
+import { and, eq, inArray, sql as sql2 } from "drizzle-orm";
+import * as s from "drizzle-orm/pg-core";
+var base_paths = s.pgTable("base_paths", {
+  id: s.uuid("id").primaryKey().defaultRandom(),
+  name: s.varchar("name", { length: 255 }).notNull().unique(),
+  path: s.varchar("path", { length: 1024 }).notNull().unique(),
+  created_at: s.timestamp("created_at").defaultNow().notNull(),
+  updated_at: s.timestamp("updated_at").defaultNow().notNull()
+});
+var roles = s.pgTable("roles", {
+  id: s.uuid("id").primaryKey().defaultRandom(),
+  name: s.varchar("name", { length: 255 }).notNull().unique(),
+  label: s.varchar("label", { length: 255 }).notNull(),
+  is_system: s.boolean("is_system").notNull().default(false),
+  hierarchy_level: s.integer("hierarchy_level").notNull().unique(),
+  permissions: s.text("permissions").array().notNull(),
+  created_at: s.timestamp("created_at").defaultNow().notNull(),
+  updated_at: s.timestamp("updated_at").defaultNow().notNull()
+});
+var users = s.pgTable("users", {
+  id: s.uuid("id").primaryKey().defaultRandom(),
+  email: s.varchar("email", { length: 255 }).notNull().unique(),
+  password_hash: s.varchar("password_hash", { length: 255 }).notNull(),
+  role_id: s.uuid("role_id").notNull().references(() => roles.id, { onDelete: "restrict" }),
+  token_version: s.integer("token_version").notNull().default(0),
+  created_at: s.timestamp("created_at").defaultNow().notNull(),
+  updated_at: s.timestamp("updated_at").defaultNow().notNull()
+});
+async function checkBasePathsInUse(db, basePathNames) {
+  const rows = await db.select({ id: base_paths.id, name: base_paths.name }).from(base_paths).where(inArray(base_paths.name, basePathNames));
+  if (rows.length === 0) return [];
+  const ids = rows.map((r) => `'${r.id}'`).join(", ");
+  const tablesResult = await db.execute(
+    sql2`SELECT table_name
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND column_name = 'base_path_id'`
+  );
+  const inUse = [];
+  for (const row of tablesResult.rows) {
+    const tableName = row.table_name;
+    const countResult = await db.execute(
+      sql2.raw(
+        `SELECT COUNT(*) as count FROM "${tableName}"
+         WHERE base_path_id IN (${ids})`
+      )
+    );
+    const count = parseInt(
+      countResult.rows[0].count,
+      10
+    );
+    if (count > 0) inUse.push(tableName);
+  }
+  return inUse;
+}
+async function seedRoles(db, parsedRoles, dryRun) {
+  const existing = await db.select({ name: roles.name }).from(roles);
+  const existingNames = new Set(existing.map((r) => r.name));
+  const incomingNames = new Set(parsedRoles.roles.map((r) => r.name));
+  const toDelete = [...existingNames].filter((n) => !incomingNames.has(n));
+  if (toDelete.length > 0) {
+    const systemRoles = await db.select({ name: roles.name }).from(roles).where(and(inArray(roles.name, toDelete), eq(roles.is_system, true)));
+    if (systemRoles.length > 0) {
+      throw new Error(
+        `SEEDER_SYSTEM_ROLE: Cannot remove system role(s) [${systemRoles.map((r) => r.name).join(", ")}] from roles.json \u2014 they are marked is_system and are protected from deletion. Re-seed the role with is_system: false first if you intend to remove it.`
+      );
+    }
+    const affected = await db.select({ id: users.id, email: users.email }).from(users).innerJoin(roles, eq(users.role_id, roles.id)).where(inArray(roles.name, toDelete));
+    if (affected.length > 0) {
+      throw new Error(
+        `SEEDER_ROLE_IN_USE: Cannot remove role(s) [${toDelete.join(", ")}] from roles.json \u2014 ${affected.length} user(s) are still assigned to them: ${affected.map((u) => u.email).join(", ")}. Reassign those users to another role before removing it from roles.json.`
+      );
+    }
+    if (!dryRun) {
+      await db.delete(roles).where(inArray(roles.name, toDelete));
+    }
+  }
+  const inserted = [];
+  const updated = [];
+  for (const role of parsedRoles.roles) {
+    if (!existingNames.has(role.name)) inserted.push(role.name);
+    else updated.push(role.name);
+  }
+  if (!dryRun) {
+    await db.insert(roles).values(
+      parsedRoles.roles.map((r) => ({
+        name: r.name,
+        label: r.label,
+        is_system: r.is_system ?? false,
+        hierarchy_level: r.hierarchy_level,
+        permissions: r.permissions
+      }))
+    ).onConflictDoUpdate({
+      target: roles.name,
+      set: {
+        label: sql2`excluded.label`,
+        is_system: sql2`excluded.is_system`,
+        hierarchy_level: sql2`excluded.hierarchy_level`,
+        permissions: sql2`excluded.permissions`,
+        updated_at: sql2`now()`
+      }
+    });
+  }
+  return {
+    inserted: inserted.length,
+    updated: updated.length,
+    deleted: toDelete.length
+  };
+}
+async function seedBasePaths(db, parsedRoutes, dryRun) {
+  const existing = await db.select({ name: base_paths.name }).from(base_paths);
+  const existingNames = new Set(existing.map((r) => r.name));
+  const incomingNames = new Set(parsedRoutes.base_paths.map((r) => r.name));
+  const toDelete = [...existingNames].filter((n) => !incomingNames.has(n));
+  if (toDelete.length > 0) {
+    const inUse = await checkBasePathsInUse(db, toDelete);
+    if (inUse.length > 0) {
+      throw new Error(
+        `SEEDER_BASE_PATH_IN_USE: Cannot remove base path(s) [${toDelete.join(", ")}] from routes.json \u2014 content items are still referencing them (${inUse.join(", ")}). Update or delete that content before removing the base path.`
+      );
+    }
+    if (!dryRun) {
+      await db.delete(base_paths).where(inArray(base_paths.name, toDelete));
+    }
+  }
+  const inserted = [];
+  const updated = [];
+  for (const bp of parsedRoutes.base_paths) {
+    if (!existingNames.has(bp.name)) inserted.push(bp.name);
+    else updated.push(bp.name);
+  }
+  if (!dryRun) {
+    await db.insert(base_paths).values(parsedRoutes.base_paths).onConflictDoUpdate({
+      target: base_paths.name,
+      set: {
+        path: sql2`excluded.path`,
+        updated_at: sql2`now()`
+      }
+    });
+  }
+  return {
+    inserted: inserted.length,
+    updated: updated.length,
+    deleted: toDelete.length
+  };
+}
+async function seedSystemTables(db, registry, options = {}) {
+  const dryRun = options.dryRun ?? false;
+  const rolesResult = await seedRoles(db, registry.roles, dryRun);
+  const basePathsResult = await seedBasePaths(db, registry.routes, dryRun);
+  return {
+    roles: rolesResult,
+    base_paths: basePathsResult
+  };
+}
+
+// src/migrations/index.ts
+import { execSync, spawnSync } from "child_process";
+import crypto from "crypto";
+import path from "path";
+import fs from "fs/promises";
+import { sql as sql3 } from "drizzle-orm";
+function resolvedPathEnv() {
+  const root = process.cwd();
+  const localBin = path.join(root, "node_modules", ".bin");
+  const existing = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean).map((entry) => path.isAbsolute(entry) ? entry : path.resolve(root, entry));
+  return { ...process.env, PATH: [localBin, ...existing].join(path.delimiter) };
+}
+async function runDevMigration(configPath) {
+  execSync(`drizzle-kit push --config=${configPath}`, {
+    stdio: "inherit",
+    cwd: path.dirname(configPath),
+    env: resolvedPathEnv()
+  });
+}
+async function generateMigration(configPath, migrationsFolder) {
+  let beforeFiles = [];
+  try {
+    const entries = await fs.readdir(migrationsFolder);
+    beforeFiles = entries.filter((f) => f.endsWith(".sql"));
+  } catch {
+  }
+  execSync(`drizzle-kit generate --config=${configPath}`, {
+    stdio: "inherit",
+    cwd: path.dirname(configPath),
+    env: resolvedPathEnv()
+  });
+  let afterFiles = [];
+  try {
+    const entries = await fs.readdir(migrationsFolder);
+    afterFiles = entries.filter((f) => f.endsWith(".sql"));
+  } catch {
+  }
+  const beforeSet = new Set(beforeFiles);
+  return afterFiles.filter((f) => !beforeSet.has(f));
+}
+async function applyMigrations(configPath, db, options) {
+  const { migrationsTable, migrationsFolder } = options;
+  await db.execute(
+    sql3.raw(
+      `CREATE TABLE IF NOT EXISTS "${migrationsTable}" (id integer, hash text NOT NULL, created_at bigint)`
+    )
+  );
+  await db.execute(
+    sql3.raw(`ALTER TABLE "${migrationsTable}" ADD COLUMN IF NOT EXISTS id integer`)
+  );
+  const statusBefore = await getMigrationStatus(db, options);
+  if (statusBefore.pending.length > 0) {
+    let journalEntries = [];
+    try {
+      const journalPath = path.join(migrationsFolder, "meta", "_journal.json");
+      const raw = await fs.readFile(journalPath, "utf-8");
+      journalEntries = JSON.parse(raw).entries;
+    } catch {
+    }
+    for (const pendingFile of statusBefore.pending) {
+      const sqlPath = path.join(migrationsFolder, pendingFile);
+      let sqlContent;
+      try {
+        sqlContent = await fs.readFile(sqlPath, "utf-8");
+      } catch {
+        continue;
+      }
+      const tableMatch = sqlContent.match(/CREATE TABLE (?:IF NOT EXISTS )?"([^"]+)"/);
+      if (!tableMatch) continue;
+      const tableName = tableMatch[1];
+      const checkResult = await db.execute(
+        sql3.raw(`SELECT to_regclass('"${tableName}"') AS t`)
+      );
+      const tableExists = checkResult.rows[0]?.t !== null;
+      if (!tableExists) continue;
+      const entry = journalEntries.find((e) => `${e.tag}.sql` === pendingFile);
+      if (!entry) continue;
+      const hash = crypto.createHash("sha256").update(sqlContent).digest("hex");
+      await db.execute(
+        sql3.raw(
+          `INSERT INTO "${migrationsTable}" (hash, created_at) SELECT '${hash}', ${entry.when} WHERE NOT EXISTS (SELECT 1 FROM "${migrationsTable}" WHERE created_at = ${entry.when})`
+        )
+      );
+    }
+  }
+  const statusAfter = await getMigrationStatus(db, options);
+  if (statusAfter.pending.length === 0) {
+    return { applied: statusAfter.applied.length, skipped: 0 };
+  }
+  const result = spawnSync(
+    "drizzle-kit",
+    ["migrate", `--config=${configPath}`],
+    {
+      cwd: path.dirname(configPath),
+      // inherit lets drizzle-kit write its spinner and errors directly to the
+      // terminal in real time — capturing stdout/stderr swallows ANSI overwrites
+      // and hides the actual error message.
+      stdio: "inherit",
+      env: { ...resolvedPathEnv(), NODE_NO_WARNINGS: "1" }
+    }
+  );
+  if (result.error) {
+    throw new Error(`Failed to spawn drizzle-kit: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `drizzle-kit migrate exited with status ${String(result.status ?? 1)} \u2014 see output above for details`
+    );
+  }
+  const status = await getMigrationStatus(db, options);
+  return {
+    applied: status.applied.length,
+    skipped: 0
+  };
+}
+async function getMigrationStatus(db, options) {
+  const { migrationsTable, migrationsFolder } = options;
+  let journalEntries;
+  try {
+    const journalPath = path.join(migrationsFolder, "meta", "_journal.json");
+    const raw = await fs.readFile(journalPath, "utf-8");
+    const journal = JSON.parse(raw);
+    journalEntries = journal.entries;
+  } catch {
+    return { applied: [], pending: [] };
+  }
+  const appliedWhenSet = /* @__PURE__ */ new Set();
+  try {
+    const result = await db.execute(
+      sql3.raw(`SELECT created_at FROM "${migrationsTable}"`)
+    );
+    for (const row of result.rows) {
+      appliedWhenSet.add(Number(row.created_at));
+    }
+  } catch {
+  }
+  const applied = [];
+  const pending = [];
+  for (const entry of journalEntries) {
+    const filename = `${entry.tag}.sql`;
+    if (appliedWhenSet.has(entry.when)) {
+      applied.push(filename);
+    } else {
+      pending.push(filename);
+    }
+  }
+  return { applied, pending };
+}
+
+// src/migrations/scanner.ts
+import { readFileSync } from "fs";
+import path2 from "path";
+function formatDropColumn(line) {
+  const upper = line.toUpperCase();
+  const tableStart = upper.indexOf("ALTER TABLE") + "ALTER TABLE".length;
+  const dropIdx = upper.indexOf("DROP COLUMN");
+  const colStart = dropIdx + "DROP COLUMN".length;
+  if (tableStart < 0 || dropIdx < 0) return line.trim();
+  const tableName = line.slice(tableStart, dropIdx).trim().replace(/"/g, "").replace(/;/g, "");
+  const colName = (line.slice(colStart).trim().replace(/"/g, "").split(/\s+/)[0] ?? "").replace(/;/g, "");
+  if (!tableName || !colName) return line.trim();
+  return `DROP COLUMN ${tableName}.${colName}`;
+}
+function formatDropTable(line) {
+  const upper = line.toUpperCase();
+  const tableStart = upper.indexOf("DROP TABLE") + "DROP TABLE".length;
+  if (tableStart < "DROP TABLE".length) return line.trim();
+  const tableName = (line.slice(tableStart).trim().replace(/"/g, "").split(/\s+/)[0] ?? "").replace(/;/g, "");
+  if (!tableName) return line.trim();
+  return `DROP TABLE ${tableName}`;
+}
+function formatAlterColumnType(line) {
+  const upper = line.toUpperCase();
+  const tableStart = upper.indexOf("ALTER TABLE") + "ALTER TABLE".length;
+  const alterColIdx = upper.indexOf("ALTER COLUMN");
+  const colStart = alterColIdx + "ALTER COLUMN".length;
+  const typeIdx = upper.indexOf(" TYPE ", colStart);
+  if (tableStart < 0 || alterColIdx < 0 || typeIdx < 0) return line.trim();
+  const tableName = line.slice(tableStart, alterColIdx).trim().replace(/"/g, "");
+  const colName = line.slice(colStart, typeIdx).trim().replace(/"/g, "");
+  const newType = (line.slice(typeIdx + " TYPE ".length).trim().split(/\s+/)[0] ?? "").replace(/;/g, "");
+  if (!tableName || !colName || !newType) return line.trim();
+  return `ALTER COLUMN ${tableName}.${colName} TYPE ${newType}`;
+}
+function scanMigrationFiles(filePaths) {
+  const operations = [];
+  for (const filePath of filePaths) {
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const filename = path2.basename(filePath);
+    for (const line of lines) {
+      const upper = line.trim().toUpperCase();
+      if (upper.includes("DROP COLUMN")) {
+        operations.push({
+          file: filename,
+          operation: formatDropColumn(line),
+          pattern: "DROP_COLUMN"
+        });
+      } else if (upper.includes("DROP TABLE")) {
+        operations.push({
+          file: filename,
+          operation: formatDropTable(line),
+          pattern: "DROP_TABLE"
+        });
+      } else if (upper.includes("ALTER COLUMN") && upper.includes(" TYPE ")) {
+        operations.push({
+          file: filename,
+          operation: formatAlterColumnType(line),
+          pattern: "ALTER_COLUMN_TYPE"
+        });
+      }
+    }
+  }
+  return {
+    hasDestructiveOperations: operations.length > 0,
+    operations
+  };
+}
+export {
+  applyMigrations,
+  createPostgresAdapter,
+  generateMigration,
+  generateSchemaFile,
+  getMigrationStatus,
+  runDevMigration,
+  scanMigrationFiles,
+  seedSystemTables,
+  sql4 as sql
+};
+//# sourceMappingURL=index.mjs.map