@danielhritcu/zenstack-custom 1.1.0

package/dist/drizzle/index.js

@@ -0,0 +1,917 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/drizzle/define.ts
+import { SQL, sql } from "drizzle-orm";
+import { pgEnum as drizzlePgEnum } from "drizzle-orm/pg-core";
+var ENUM_MAP = Symbol.for("drizzle:EnumMap");
+function toPgEnum(record) {
+  return Object.values(record);
+}
+__name(toPgEnum, "toPgEnum");
+function pgOrmEnum(name, values) {
+  const pgValues = Object.values(values);
+  const result = drizzlePgEnum(name, pgValues);
+  result[ENUM_MAP] = values;
+  return result;
+}
+__name(pgOrmEnum, "pgOrmEnum");
+var pgTypes = {
+  date: /* @__PURE__ */ __name(() => "date", "date"),
+  uuid: /* @__PURE__ */ __name(() => "uuid", "uuid"),
+  text: /* @__PURE__ */ __name(() => "text", "text"),
+  integer: /* @__PURE__ */ __name(() => "integer", "integer"),
+  bigint: /* @__PURE__ */ __name(() => "bigint", "bigint"),
+  boolean: /* @__PURE__ */ __name(() => "boolean", "boolean"),
+  numeric: /* @__PURE__ */ __name(() => "numeric", "numeric"),
+  timestamptz: /* @__PURE__ */ __name(() => "timestamptz", "timestamptz"),
+  timestamp: /* @__PURE__ */ __name(() => "timestamp", "timestamp"),
+  jsonb: /* @__PURE__ */ __name(() => "jsonb", "jsonb"),
+  json: /* @__PURE__ */ __name(() => "json", "json")
+};
+var CustomObject = class extends SQL {
+  static {
+    __name(this, "CustomObject");
+  }
+  name;
+  type;
+  schema;
+  qualifiedName;
+  constructor(name, type, schema) {
+    const qn = schema ? `${schema}.${name}` : name;
+    super(sql.raw(qn).queryChunks), this.name = name, this.type = type, this.schema = schema;
+    this.qualifiedName = qn;
+  }
+  getSQL() {
+    return sql.raw(this.qualifiedName);
+  }
+};
+var PgFunction = class extends CustomObject {
+  static {
+    __name(this, "PgFunction");
+  }
+  opts;
+  constructor(name, opts) {
+    super(name, "function", opts.schema), this.opts = opts;
+  }
+  toSQL(dialect) {
+    const args = this.opts.args ? Object.entries(this.opts.args(pgTypes)).map(([n, type]) => `${n} ${type}`).join(", ") : "";
+    const language = this.opts.language ?? "plpgsql";
+    const body = dialect.sqlToQuery(this.opts.body()).sql;
+    const lines = [
+      `CREATE OR REPLACE FUNCTION ${this.qualifiedName}(${args})`,
+      `RETURNS ${this.opts.returns}`,
+      `LANGUAGE ${language}`
+    ];
+    if (this.opts.security === "definer") lines.push("SECURITY DEFINER");
+    if (this.opts.searchPath) lines.push(`SET search_path = ${this.opts.searchPath}`);
+    lines.push(`AS $function$
+${body}
+$function$;`);
+    return lines.join("\n");
+  }
+};
+var TriggerFunction = class extends PgFunction {
+  static {
+    __name(this, "TriggerFunction");
+  }
+  triggerOpts;
+  constructor(name, triggerOpts) {
+    super(name, {
+      returns: "trigger",
+      schema: triggerOpts.schema,
+      language: triggerOpts.language,
+      security: triggerOpts.security,
+      searchPath: triggerOpts.searchPath,
+      body: triggerOpts.body
+    }), this.triggerOpts = triggerOpts;
+  }
+};
+var PgTrigger = class extends CustomObject {
+  static {
+    __name(this, "PgTrigger");
+  }
+  opts;
+  tableName;
+  constructor(name, opts) {
+    super(name, "trigger", opts.schema), this.opts = opts;
+    this.tableName = opts.on[Symbol.for("drizzle:Name")];
+  }
+  toSQL(dialect) {
+    const tableName = this.tableName;
+    const eventParts = this.opts.events.map((e) => {
+      if (typeof e === "string") return e.toUpperCase();
+      const cols = e.update.map((c) => c.name).join(", ");
+      return `UPDATE OF ${cols}`;
+    });
+    const lines = [
+      `CREATE OR REPLACE TRIGGER ${this.name}`,
+      `${this.opts.timing.toUpperCase()} ${eventParts.join(" OR ")}`,
+      `ON ${tableName}`,
+      `FOR EACH ${this.opts.forEach.toUpperCase()}`
+    ];
+    if (this.opts.condition) {
+      const cond = dialect.sqlToQuery(this.opts.condition).sql;
+      lines.push(`WHEN (${cond})`);
+    }
+    lines.push(`EXECUTE FUNCTION ${this.opts.execute.qualifiedName}();`);
+    return lines.join("\n");
+  }
+};
+var PgExtension = class extends CustomObject {
+  static {
+    __name(this, "PgExtension");
+  }
+  opts;
+  constructor(name, opts = {}) {
+    super(name, "extension"), this.opts = opts;
+  }
+  toSQL() {
+    const schema = this.opts.schema ? ` SCHEMA ${this.opts.schema}` : "";
+    return `CREATE EXTENSION IF NOT EXISTS "${this.name}"${schema};`;
+  }
+};
+function pgExtension(name, opts = {}) {
+  return new PgExtension(name, opts);
+}
+__name(pgExtension, "pgExtension");
+var PgCronJob = class extends CustomObject {
+  static {
+    __name(this, "PgCronJob");
+  }
+  opts;
+  constructor(name, opts) {
+    super(name, "cron"), this.opts = opts;
+  }
+  toSQL(dialect) {
+    const cmd = dialect.sqlToQuery(this.opts.command()).sql;
+    const escapedName = this.name.replace(/'/g, "''");
+    const escapedSchedule = this.opts.schedule.replace(/'/g, "''");
+    return `SELECT cron.schedule('${escapedName}', '${escapedSchedule}', $$${cmd}$$);`;
+  }
+};
+function pgCron(name, opts) {
+  return new PgCronJob(name, opts);
+}
+__name(pgCron, "pgCron");
+function pgFunction(name, opts) {
+  if (opts.returns === "trigger" && "triggersOn" in opts) {
+    return new TriggerFunction(name, opts);
+  }
+  return new PgFunction(name, opts);
+}
+__name(pgFunction, "pgFunction");
+function pgTrigger(name, opts) {
+  return new PgTrigger(name, opts);
+}
+__name(pgTrigger, "pgTrigger");
+
+// src/drizzle/cols.ts
+import { sql as sql3 } from "drizzle-orm";
+import { customType, foreignKey, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+// src/drizzle/rls.ts
+import { sql as sql2 } from "drizzle-orm";
+import { pgPolicy } from "drizzle-orm/pg-core";
+var currentAppSlug = sql2`current_setting('rls.app')`;
+var hasAppSlug = sql2`(select ${currentAppSlug} is not null)`;
+var currentUser = sql2`current_setting('rls.user')`;
+var hasUser = sql2`(select ${currentUser} is not null)`;
+var hasBypassEnabled = sql2`(select current_setting('rls.bypass') = 'enabled')`;
+var TRUE = sql2`true`;
+var FALSE = sql2`false`;
+var defaultPolicy = /* @__PURE__ */ __name((name, { table, policies }) => {
+  const isSameAppSlug = sql2`${currentAppSlug} = ${table.appSlug}`;
+  const selectPolicy = pgPolicy(`rls.${name}.select`, {
+    as: "permissive",
+    for: "select",
+    using: sql2`${isSameAppSlug} or ${hasBypassEnabled}`
+  });
+  const insertPolicy = pgPolicy(`rls.${name}.insert`, {
+    as: "permissive",
+    for: "insert",
+    withCheck: sql2`${hasAppSlug} or ${hasBypassEnabled}`
+  });
+  const updatePolicy = pgPolicy(`rls.${name}.update`, {
+    as: "permissive",
+    for: "update",
+    using: sql2`${isSameAppSlug} or ${hasBypassEnabled}`
+  });
+  const deletePolicy = pgPolicy(`rls.${name}.delete`, {
+    as: "permissive",
+    for: "delete",
+    using: sql2`${hasBypassEnabled} or ${isSameAppSlug}`
+  });
+  const ctx = {
+    currentAppSlug,
+    currentUser,
+    hasAppSlug,
+    hasUser,
+    isSameAppSlug,
+    hasBypass: hasBypassEnabled,
+    TRUE,
+    FALSE
+  };
+  return [
+    typeof policies?.select === "function" ? pgPolicy(`rls.${name}.select`, {
+      as: "permissive",
+      for: "select",
+      using: policies.select(ctx)
+    }) : selectPolicy,
+    typeof policies?.insert === "function" ? pgPolicy(`rls.${name}.insert`, {
+      as: "permissive",
+      for: "insert",
+      withCheck: policies.insert(ctx)
+    }) : insertPolicy,
+    typeof policies?.update === "function" ? pgPolicy(`rls.${name}.update`, {
+      as: "permissive",
+      for: "update",
+      withCheck: policies.update(ctx)
+    }) : updatePolicy,
+    typeof policies?.delete === "function" ? pgPolicy(`rls.${name}.delete`, {
+      as: "permissive",
+      for: "delete",
+      using: policies.delete(ctx)
+    }) : deletePolicy
+  ].filter(Boolean);
+}, "defaultPolicy");
+
+// src/drizzle/cols.ts
+var colNumeric = /* @__PURE__ */ __name((name) => {
+  return customType({
+    dataType: /* @__PURE__ */ __name(() => "numeric", "dataType"),
+    fromDriver: Number,
+    toDriver: /* @__PURE__ */ __name((value) => sql3`${value.toString()}::numeric`, "toDriver")
+  })(name);
+}, "colNumeric");
+var colAppSlug = /* @__PURE__ */ __name((name) => text(name).default(currentAppSlug), "colAppSlug");
+var colTimestamp = /* @__PURE__ */ __name((name) => timestamp(name, {
+  withTimezone: true,
+  mode: "date"
+}), "colTimestamp");
+var colCreatedAt = /* @__PURE__ */ __name((name) => colTimestamp(name).defaultNow().notNull(), "colCreatedAt");
+var colUpdatedAt = /* @__PURE__ */ __name((name) => colTimestamp(name).defaultNow().notNull(), "colUpdatedAt");
+var colDeletedAt = /* @__PURE__ */ __name((name) => colTimestamp(name), "colDeletedAt");
+var colId = /* @__PURE__ */ __name((name) => uuid(name).defaultRandom().primaryKey().notNull(), "colId");
+var auditColumns = /* @__PURE__ */ __name(() => ({
+  createdBy: text("created_by").default(currentUser).notNull(),
+  updatedBy: text("updated_by").default(currentUser).notNull(),
+  createdAt: colCreatedAt("created_at"),
+  updatedAt: colUpdatedAt("updated_at"),
+  deletedAt: colDeletedAt("deleted_at")
+}), "auditColumns");
+var appSlugForeignKey = /* @__PURE__ */ __name((table, tableName, appsTable) => foreignKey({
+  columns: [
+    table.appSlug
+  ],
+  foreignColumns: [
+    appsTable.slug
+  ],
+  name: `${tableName}_app_slug_fkey`
+}).onUpdate("cascade").onDelete("cascade"), "appSlugForeignKey");
+
+// src/drizzle/generate.ts
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import { gunzipSync, gzipSync } from "zlib";
+import { PgDialect } from "drizzle-orm/pg-core";
+function parseFlags(argv = process.argv, env = process.env) {
+  const dryRun = argv.includes("--dry-run") || env["DRY_RUN"] === "1";
+  const verbose = argv.includes("--verbose") || env["VERBOSE"] === "1" || dryRun;
+  const fix = argv.includes("--fix");
+  return {
+    dryRun,
+    verbose,
+    fix
+  };
+}
+__name(parseFlags, "parseFlags");
+function computeHash(sql4) {
+  const hash = createHash("sha256").update(sql4).digest("hex");
+  return `sha256:${hash}`;
+}
+__name(computeHash, "computeHash");
+function categorizeChanges(prev, curr) {
+  const allKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(prev),
+    ...Object.keys(curr)
+  ]);
+  const changes = [];
+  for (const key of [
+    ...allKeys
+  ].sort()) {
+    if (!(key in prev)) {
+      changes.push({
+        key,
+        category: "added"
+      });
+    } else if (!(key in curr)) {
+      changes.push({
+        key,
+        category: "removed"
+      });
+    } else if (prev[key] !== curr[key]) {
+      changes.push({
+        key,
+        category: "modified"
+      });
+    }
+  }
+  return changes;
+}
+__name(categorizeChanges, "categorizeChanges");
+function formatChangeSummary(changes) {
+  if (changes.length === 0) return "";
+  const prefixes = {
+    added: "+",
+    modified: "~",
+    removed: "-"
+  };
+  const labels = {
+    added: "new",
+    modified: "modified",
+    removed: "removed"
+  };
+  const lines = changes.map(({ key, category }) => `  ${prefixes[category]} ${key} (${labels[category]})`);
+  return `Custom SQL changes:
+${lines.join("\n")}`;
+}
+__name(formatChangeSummary, "formatChangeSummary");
+function simpleDiff(prev, curr) {
+  const prevLines = prev.split("\n");
+  const currLines = curr.split("\n");
+  const result = [];
+  let pi = 0;
+  let ci = 0;
+  while (pi < prevLines.length || ci < currLines.length) {
+    if (pi >= prevLines.length) {
+      result.push(`+${currLines[ci]}`);
+      ci++;
+    } else if (ci >= currLines.length) {
+      result.push(`-${prevLines[pi]}`);
+      pi++;
+    } else if (prevLines[pi] === currLines[ci]) {
+      result.push(` ${prevLines[pi]}`);
+      pi++;
+      ci++;
+    } else {
+      result.push(`-${prevLines[pi]}`);
+      result.push(`+${currLines[ci]}`);
+      pi++;
+      ci++;
+    }
+  }
+  return result.join("\n");
+}
+__name(simpleDiff, "simpleDiff");
+function indent(text2) {
+  return text2.split("\n").map((line) => `  ${line}`).join("\n");
+}
+__name(indent, "indent");
+function formatVerboseOutput(changes, currentObjects, prevObjects) {
+  const sections = [];
+  for (const { key, category } of changes) {
+    if (category === "added") {
+      const sql4 = currentObjects[key]?.sql ?? "";
+      sections.push(`+ ${key} (new)
+${indent(sql4)}`);
+    } else if (category === "modified") {
+      const currSql = currentObjects[key]?.sql ?? "";
+      const prevSql = prevObjects[key]?.sql ?? "";
+      if (prevSql) {
+        const diff = simpleDiff(prevSql, currSql);
+        sections.push(`~ ${key} (modified)
+  --- previous
+  +++ current
+${indent(diff)}`);
+      } else {
+        sections.push(`~ ${key} (modified \u2014 previous SQL not stored, showing current)
+${indent(currSql)}`);
+      }
+    } else {
+      sections.push(`- ${key} (removed)`);
+    }
+  }
+  return sections.join("\n");
+}
+__name(formatVerboseOutput, "formatVerboseOutput");
+function readJournal(migrationsDir) {
+  const journalPath = join(migrationsDir, "meta", "_journal.json");
+  return JSON.parse(readFileSync(journalPath, "utf-8"));
+}
+__name(readJournal, "readJournal");
+function timestampFromTag(tag) {
+  return tag.match(/^(\d+)/)?.[1] ?? tag;
+}
+__name(timestampFromTag, "timestampFromTag");
+function nowTimestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = /* @__PURE__ */ __name((n) => String(n).padStart(2, "0"), "p");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+__name(nowTimestamp, "nowTimestamp");
+function getLatestSnapshotPath(migrationsDir, journal) {
+  if (journal.entries.length === 0) return null;
+  const latest = journal.entries[journal.entries.length - 1];
+  return join(migrationsDir, "meta", `${timestampFromTag(latest.tag)}_snapshot.json`);
+}
+__name(getLatestSnapshotPath, "getLatestSnapshotPath");
+function readSnapshotCustomObjects(snapshotPath) {
+  const snapshot = JSON.parse(readFileSync(snapshotPath, "utf-8"));
+  const raw = snapshot.customObjects ?? {};
+  const result = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string") {
+      result[key] = {
+        hash: value,
+        sql: ""
+      };
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+__name(readSnapshotCustomObjects, "readSnapshotCustomObjects");
+function writeSnapshotCustomObjects(snapshotPath, objects) {
+  const snapshot = JSON.parse(readFileSync(snapshotPath, "utf-8"));
+  snapshot.customObjects = objects;
+  writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2) + "\n");
+}
+__name(writeSnapshotCustomObjects, "writeSnapshotCustomObjects");
+function stableStringify(obj) {
+  if (obj === null || typeof obj !== "object") return JSON.stringify(obj);
+  if (Array.isArray(obj)) return `[${obj.map(stableStringify).join(",")}]`;
+  const sorted = Object.keys(obj).sort();
+  const entries = sorted.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+  return `{${entries.join(",")}}`;
+}
+__name(stableStringify, "stableStringify");
+function packToSgz(migrationsDir) {
+  const metaDir = join(migrationsDir, "meta");
+  if (!existsSync(metaDir)) return;
+  const snapshotFiles = readdirSync(metaDir).filter((f) => f.endsWith("_snapshot.json"));
+  const sqlFiles = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql"));
+  for (const file of snapshotFiles) {
+    const timestamp2 = timestampFromTag(file);
+    const sqlFile = sqlFiles.find((f) => f.startsWith(timestamp2));
+    if (!sqlFile) continue;
+    const sqlStem = sqlFile.replace(/\.sql$/, "");
+    const normalized = stableStringify(JSON.parse(readFileSync(join(metaDir, file), "utf-8")));
+    const compressed = gzipSync(normalized, {
+      level: 9
+    });
+    writeFileSync(join(migrationsDir, `${sqlStem}.sgz`), compressed);
+  }
+}
+__name(packToSgz, "packToSgz");
+function unpackFromSgz(migrationsDir) {
+  const metaDir = join(migrationsDir, "meta");
+  mkdirSync(metaDir, {
+    recursive: true
+  });
+  const sgzFiles = readdirSync(migrationsDir).filter((f) => f.endsWith(".sgz")).sort();
+  const sqlFiles = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql"));
+  const entries = [];
+  for (let i = 0; i < sgzFiles.length; i++) {
+    const stem = sgzFiles[i].replace(/\.sgz$/, "");
+    const timestamp2 = timestampFromTag(stem);
+    const decompressed = gunzipSync(readFileSync(join(migrationsDir, sgzFiles[i])));
+    writeFileSync(join(metaDir, `${timestamp2}_snapshot.json`), decompressed);
+    const sqlFile = sqlFiles.find((f) => f.startsWith(timestamp2));
+    const tag = sqlFile ? sqlFile.replace(/\.sql$/, "") : stem;
+    entries.push({
+      idx: i,
+      version: "7",
+      when: parseInt(timestamp2, 10),
+      tag,
+      breakpoints: true
+    });
+  }
+  const journal = {
+    version: "7",
+    dialect: "postgresql",
+    entries
+  };
+  writeFileSync(join(metaDir, "_journal.json"), JSON.stringify(journal, null, 2) + "\n");
+}
+__name(unpackFromSgz, "unpackFromSgz");
+function cleanMeta(migrationsDir) {
+  const metaDir = join(migrationsDir, "meta");
+  if (existsSync(metaDir)) rmSync(metaDir, {
+    recursive: true
+  });
+}
+__name(cleanMeta, "cleanMeta");
+function listSgzFiles(migrationsDir) {
+  return readdirSync(migrationsDir).filter((f) => f.endsWith(".sgz")).sort();
+}
+__name(listSgzFiles, "listSgzFiles");
+function validateTimestamps(migrationsDir) {
+  const duplicates = [];
+  let prevTimestamp = "";
+  for (const file of listSgzFiles(migrationsDir)) {
+    const ts = timestampFromTag(file);
+    if (ts === prevTimestamp) duplicates.push(file);
+    prevTimestamp = ts;
+  }
+  return duplicates;
+}
+__name(validateTimestamps, "validateTimestamps");
+function validateOrder(migrationsDir) {
+  const sgzFiles = listSgzFiles(migrationsDir);
+  const issues = [];
+  let prevContentId = "";
+  for (const file of sgzFiles) {
+    const content = JSON.parse(gunzipSync(readFileSync(join(migrationsDir, file))).toString());
+    if (prevContentId !== "" && content.prevId !== prevContentId) {
+      issues.push({
+        file,
+        expected: prevContentId,
+        actual: content.prevId
+      });
+    }
+    prevContentId = content.id;
+  }
+  return issues;
+}
+__name(validateOrder, "validateOrder");
+function fixOrder(migrationsDir, issues) {
+  let lastUsedTs = "";
+  for (const issue of issues) {
+    const sgzPath = join(migrationsDir, issue.file);
+    const sqlFile = issue.file.replace(/\.sgz$/, ".sql");
+    const sqlPath = join(migrationsDir, sqlFile);
+    let sqlContent = "";
+    try {
+      sqlContent = readFileSync(sqlPath, "utf-8");
+    } catch {
+    }
+    const snapshot = JSON.parse(gunzipSync(readFileSync(sgzPath)).toString());
+    snapshot.prevId = issue.expected;
+    const suffix = sqlFile.replace(/^\d+/, "");
+    try {
+      unlinkSync(sqlPath);
+    } catch {
+    }
+    unlinkSync(sgzPath);
+    let ts = findTimestampAfterDependency(migrationsDir, issue.expected);
+    if (ts <= lastUsedTs) ts = String(Number(lastUsedTs) + 1);
+    lastUsedTs = ts;
+    const newStem = `${ts}${suffix.replace(/\.sql$/, "")}`;
+    writeFileSync(join(migrationsDir, `${newStem}.sql`), sqlContent);
+    writeFileSync(join(migrationsDir, `${newStem}.sgz`), gzipSync(stableStringify(snapshot), {
+      level: 9
+    }));
+  }
+}
+__name(fixOrder, "fixOrder");
+function findTimestampAfterDependency(migrationsDir, expectedId) {
+  for (const file of listSgzFiles(migrationsDir)) {
+    const content = JSON.parse(gunzipSync(readFileSync(join(migrationsDir, file))).toString());
+    if (content.id === expectedId) {
+      const depTs = timestampFromTag(file);
+      return String(Number(depTs) + 1);
+    }
+  }
+  return nowTimestamp();
+}
+__name(findTimestampAfterDependency, "findTimestampAfterDependency");
+function collectCustomObjects(moduleExports) {
+  return Object.values(moduleExports).filter((v) => v instanceof CustomObject);
+}
+__name(collectCustomObjects, "collectCustomObjects");
+function serializeCustomObject(obj, dialect) {
+  return obj.toSQL(dialect);
+}
+__name(serializeCustomObject, "serializeCustomObject");
+function generateDropSQL(key, createSQL) {
+  const [type] = key.split(":");
+  switch (type) {
+    case "function": {
+      const m = createSQL.match(/CREATE OR REPLACE FUNCTION\s+(\S+)\s*\(/);
+      return m ? `DROP FUNCTION IF EXISTS ${m[1]};` : null;
+    }
+    case "trigger": {
+      const m = createSQL.match(/CREATE OR REPLACE TRIGGER\s+(\S+)[\s\S]*?ON\s+(\S+)/);
+      return m ? `DROP TRIGGER IF EXISTS ${m[1]} ON ${m[2]};` : null;
+    }
+    case "extension": {
+      const m = createSQL.match(/CREATE EXTENSION IF NOT EXISTS\s+"([^"]+)"/);
+      return m ? `DROP EXTENSION IF EXISTS "${m[1]}";` : null;
+    }
+    case "cron": {
+      const m = createSQL.match(/cron\.schedule\('([^']+)'/);
+      return m ? `SELECT cron.unschedule('${m[1]}');` : null;
+    }
+    default:
+      return null;
+  }
+}
+__name(generateDropSQL, "generateDropSQL");
+function findNewMigrationFile(migrationsDir, beforeFiles) {
+  const afterFiles = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql"));
+  const newFile = afterFiles.find((f) => !beforeFiles.has(f));
+  return newFile ? join(migrationsDir, newFile) : null;
+}
+__name(findNewMigrationFile, "findNewMigrationFile");
+async function generate(migrationsDir, schemaModules, flags = {
+  dryRun: false,
+  verbose: false,
+  fix: false
+}) {
+  const duplicates = validateTimestamps(migrationsDir);
+  if (duplicates.length > 0) {
+    console.error("Duplicate migration timestamps detected:");
+    for (const file of duplicates) console.error(`  ${file}`);
+    console.error("Resolve manually \u2014 each migration must have a unique timestamp.");
+    process.exit(1);
+  }
+  const orderIssues = validateOrder(migrationsDir);
+  if (orderIssues.length > 0) {
+    if (!flags.fix) {
+      console.error("Migration order issues detected:");
+      for (const issue of orderIssues) {
+        console.error(`  ${issue.file}: expected prevId="${issue.expected}", actual="${issue.actual}"`);
+      }
+      console.error("Run with --fix to repair.");
+      process.exit(1);
+    }
+    if (flags.dryRun) {
+      console.log("Would fix migration order:");
+      for (const issue of orderIssues) {
+        console.log(`  ${issue.file}: re-timestamp, set prevId="${issue.expected}"`);
+      }
+    } else {
+      fixOrder(migrationsDir, orderIssues);
+      console.log(`Fixed ${orderIssues.length} migration order issue(s).`);
+    }
+  }
+  const dialect = new PgDialect();
+  unpackFromSgz(migrationsDir);
+  try {
+    const journal = readJournal(migrationsDir);
+    const snapshotPath = getLatestSnapshotPath(migrationsDir, journal);
+    const prevObjects = snapshotPath ? readSnapshotCustomObjects(snapshotPath) : {};
+    let beforeFiles = /* @__PURE__ */ new Set();
+    if (!flags.dryRun) {
+      beforeFiles = new Set(readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")));
+      console.log("Running drizzle-kit generate...");
+      try {
+        execSync("pnpm drizzle generate", {
+          stdio: "inherit"
+        });
+      } catch {
+        throw new Error("drizzle-kit generate failed. Aborting.");
+      }
+    }
+    const allObjects = schemaModules.flatMap(collectCustomObjects);
+    const typeOrder = [
+      "function",
+      "trigger",
+      "extension",
+      "cron"
+    ];
+    const ordered = allObjects.filter((o) => typeOrder.includes(o.type)).sort((a, b) => typeOrder.indexOf(a.type) - typeOrder.indexOf(b.type) || a.name.localeCompare(b.name));
+    const currentObjects = {};
+    for (const obj of ordered) {
+      const sqlStr = serializeCustomObject(obj, dialect);
+      const triggerTable = obj instanceof PgTrigger ? `.${obj.tableName}` : "";
+      const key = `${obj.type}:${obj.name}${triggerTable}`;
+      currentObjects[key] = {
+        hash: computeHash(sqlStr),
+        sql: sqlStr
+      };
+    }
+    const prevHashes = Object.fromEntries(Object.entries(prevObjects).map(([key, entry]) => [
+      key,
+      entry.hash
+    ]));
+    const currentHashes = Object.fromEntries(Object.entries(currentObjects).map(([key, entry]) => [
+      key,
+      entry.hash
+    ]));
+    const changes = categorizeChanges(prevHashes, currentHashes);
+    if (changes.length === 0) {
+      console.log("No custom SQL changes detected.");
+      if (!flags.dryRun) {
+        const latestJournal = readJournal(migrationsDir);
+        const latestSnapshotPath = getLatestSnapshotPath(migrationsDir, latestJournal);
+        if (latestSnapshotPath) writeSnapshotCustomObjects(latestSnapshotPath, currentObjects);
+        packToSgz(migrationsDir);
+      }
+      return;
+    }
+    console.log(formatChangeSummary(changes));
+    if (flags.verbose) {
+      console.log("");
+      console.log(formatVerboseOutput(changes, currentObjects, prevObjects));
+    }
+    if (flags.dryRun) {
+      console.log("\n=== DRY RUN: No files were written ===");
+      return;
+    }
+    let migrationFile = findNewMigrationFile(migrationsDir, beforeFiles);
+    if (!migrationFile) {
+      console.log("No drizzle migration was created. Creating custom migration...");
+      execSync("pnpm drizzle generate --custom", {
+        stdio: "inherit"
+      });
+      migrationFile = findNewMigrationFile(migrationsDir, beforeFiles);
+      if (!migrationFile) throw new Error("Failed to create custom migration file");
+    }
+    const createKeys = changes.filter((c) => c.category !== "removed").map((c) => c.key);
+    const createStatements = createKeys.map((key) => `-- @drizzle-custom ${key}
+${currentObjects[key].sql}`);
+    const removedKeys = changes.filter((c) => c.category === "removed").map((c) => c.key);
+    const dropStatements = removedKeys.map((key) => {
+      const dropSql = generateDropSQL(key, prevObjects[key]?.sql ?? "");
+      return dropSql ? `-- @drizzle-custom ${key} (removed)
+${dropSql}` : null;
+    }).filter(Boolean);
+    const allStatements = [
+      ...dropStatements,
+      ...createStatements
+    ].join("\n\n");
+    appendFileSync(migrationFile, `
+-- Custom SQL objects
+${allStatements}
+`);
+    if (dropStatements.length > 0) {
+      const dropNames = removedKeys.join(", ");
+      appendFileSync(migrationFile, `
+-- TODO: Review dropped objects (${dropNames})
+-- If they have dependants (triggers, cron jobs, etc.), add DROP/UPDATE statements below.
+-- Run 'pnpm dev:init' to verify this migration applies cleanly.
+
+`);
+      console.log(`\u26A0 ${dropStatements.length} object(s) dropped \u2014 check migration for dependency TODOs`);
+    }
+    const total = createKeys.length + dropStatements.length;
+    console.log(`Appended ${total} custom SQL statement(s) to ${migrationFile}`);
+    const updatedJournal = readJournal(migrationsDir);
+    const updatedSnapshotPath = getLatestSnapshotPath(migrationsDir, updatedJournal);
+    if (updatedSnapshotPath) {
+      writeSnapshotCustomObjects(updatedSnapshotPath, currentObjects);
+      console.log(`Updated custom hashes in ${updatedSnapshotPath}`);
+    }
+    packToSgz(migrationsDir);
+  } finally {
+    cleanMeta(migrationsDir);
+  }
+}
+__name(generate, "generate");
+function drop(migrationsDir) {
+  unpackFromSgz(migrationsDir);
+  try {
+    execSync("pnpm drizzle drop", {
+      stdio: "inherit"
+    });
+    packToSgz(migrationsDir);
+    for (const f of readdirSync(migrationsDir)) {
+      if (!f.endsWith(".sgz")) continue;
+      if (!existsSync(join(migrationsDir, f.replace(".sgz", ".sql")))) {
+        unlinkSync(join(migrationsDir, f));
+      }
+    }
+  } finally {
+    cleanMeta(migrationsDir);
+  }
+}
+__name(drop, "drop");
+function custom(migrationsDir) {
+  unpackFromSgz(migrationsDir);
+  try {
+    execSync("pnpm drizzle generate --custom", {
+      stdio: "inherit"
+    });
+    packToSgz(migrationsDir);
+  } finally {
+    cleanMeta(migrationsDir);
+  }
+}
+__name(custom, "custom");
+async function loadSchemaModules(schemaDir) {
+  const sourceNames = [
+    "functions",
+    "triggers",
+    "extensions",
+    "cron"
+  ];
+  const importTasks = [];
+  for (const name of sourceNames) {
+    const dirPath = join(schemaDir, name);
+    const filePath = join(schemaDir, `${name}.ts`);
+    if (existsSync(dirPath) && statSync(dirPath).isDirectory()) {
+      const scanDir = /* @__PURE__ */ __name((dir, prefix) => {
+        for (const entry of readdirSync(dir)) {
+          const fullPath = join(dir, entry);
+          if (statSync(fullPath).isDirectory()) {
+            scanDir(fullPath, `${prefix}${entry}/`);
+          } else if (entry.endsWith(".ts") && !entry.includes(".test.") && !entry.includes(".spec.")) {
+            importTasks.push(import(fullPath).catch((err) => {
+              const msg = err instanceof Error ? err.message : String(err);
+              console.error(`Failed to load ${prefix}${entry}: ${msg}`);
+              process.exit(1);
+            }));
+          }
+        }
+      }, "scanDir");
+      scanDir(dirPath, `${name}/`);
+    } else if (existsSync(filePath)) {
+      importTasks.push(import(filePath).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Failed to load ${name}.ts: ${msg}`);
+        process.exit(1);
+      }));
+    }
+  }
+  return Promise.all(importTasks);
+}
+__name(loadSchemaModules, "loadSchemaModules");
+async function syncMeta(migrationsDir, schemaModules) {
+  const dialect = new PgDialect();
+  const allObjects = schemaModules.flatMap(collectCustomObjects);
+  const ordered = allObjects.sort((a, b) => a.type.localeCompare(b.type) || a.name.localeCompare(b.name));
+  const currentObjects = {};
+  for (const obj of ordered) {
+    const sqlStr = serializeCustomObject(obj, dialect);
+    const triggerTable = obj instanceof PgTrigger ? `.${obj.tableName}` : "";
+    currentObjects[`${obj.type}:${obj.name}${triggerTable}`] = {
+      hash: computeHash(sqlStr),
+      sql: sqlStr
+    };
+  }
+  const sgzFiles = listSgzFiles(migrationsDir);
+  if (sgzFiles.length === 0) {
+    console.error("No .sgz files found. Nothing to sync.");
+    process.exit(1);
+  }
+  const latestSgz = sgzFiles[sgzFiles.length - 1];
+  const sgzPath = join(migrationsDir, latestSgz);
+  const snap = JSON.parse(gunzipSync(readFileSync(sgzPath)).toString());
+  snap.customObjects = currentObjects;
+  writeFileSync(sgzPath, gzipSync(stableStringify(snap), {
+    level: 9
+  }));
+  console.log(`Synced ${Object.keys(currentObjects).length} custom objects into ${latestSgz}`);
+}
+__name(syncMeta, "syncMeta");
+export {
+  CustomObject,
+  ENUM_MAP,
+  FALSE,
+  PgCronJob,
+  PgExtension,
+  PgFunction,
+  PgTrigger,
+  TriggerFunction,
+  appSlugForeignKey,
+  auditColumns,
+  categorizeChanges,
+  cleanMeta,
+  colAppSlug,
+  colCreatedAt,
+  colDeletedAt,
+  colId,
+  colNumeric,
+  colTimestamp,
+  colUpdatedAt,
+  collectCustomObjects,
+  computeHash,
+  currentAppSlug,
+  currentUser,
+  custom,
+  defaultPolicy,
+  drop,
+  fixOrder,
+  formatChangeSummary,
+  formatVerboseOutput,
+  generate,
+  generateDropSQL,
+  getLatestSnapshotPath,
+  hasAppSlug,
+  hasBypassEnabled,
+  loadSchemaModules,
+  packToSgz,
+  parseFlags,
+  pgCron,
+  pgExtension,
+  pgFunction,
+  pgOrmEnum,
+  pgTrigger,
+  pgTypes,
+  readJournal,
+  readSnapshotCustomObjects,
+  serializeCustomObject,
+  simpleDiff,
+  syncMeta,
+  toPgEnum,
+  unpackFromSgz,
+  validateOrder,
+  validateTimestamps,
+  writeSnapshotCustomObjects
+};
+//# sourceMappingURL=index.js.map