@stacksjs/database 0.70.240 → 0.70.243

package/dist/migrations.d.ts

@@ -42,6 +42,20 @@ export declare function prepareMigrationModelsDir(): { modelsDir: string, skip:
  * applied while its first column had never been created.
  */
 export declare function sqlStatementsOf(content: string): string[];
+/**
+ * Make a Postgres `CREATE TYPE … AS ENUM` statement safe to run twice.
+ *
+ * `CREATE TYPE` has no `IF NOT EXISTS`, so a corpus containing one can only be
+ * applied to a database that has never seen it. Every other way a migration run
+ * can be interrupted - a partially recorded ledger, a schema restored from a
+ * dump, a database built before the ledger existed - leaves `buddy migrate`
+ * dead on the first enum it meets, with an error naming a type that is already
+ * exactly right.
+ *
+ * The guard is a `DO` block catching `duplicate_object`, which needs a
+ * dollar-quoted body - hence the splitter above having to understand one.
+ */
+export declare function guardPostgresEnumTypes(sql: string): string;
 export declare function preprocessSqliteMigrations(): void;
 /**
  * Public bootstrap entry point.
@@ -131,6 +145,21 @@ export declare function generateMigrations(options?: GenerateMigrationsOptions):
  */
 export declare function referencesUndefinedType(statement: string, dangling: string[]): boolean;
 export declare function findDanglingTypeReferences(statements: string[]): string[];
+/**
+ * Define the enum types an ALTER needs but nothing in the batch creates.
+ *
+ * Postgres enum columns are backed by a named type, and bun-query-builder names
+ * it `<table>_<column>_type` when it creates the table. A column that becomes an
+ * enum *later* gets an `ALTER … TYPE "<table>_<column>_type"` naming a type that
+ * was never created, because the `CREATE TYPE` only ever accompanied a
+ * `CREATE TABLE`.
+ *
+ * The values are right there in the plan - the model declared them - so the type
+ * can be created instead of the statement being thrown away. Throwing it away
+ * left the column as it was, so a model change quietly did not happen and the
+ * next diff proposed the same thing again forever.
+ */
+export declare function createMissingEnumTypes(dangling: string[], plan: MigrationPlanLike | undefined): { statements: string[], defined: string[] };
 /**
  * SQLite supports a nullable foreign key on `ADD COLUMN`, but not a later
  * `ADD CONSTRAINT`. bun-query-builder emits the new relation column without
@@ -192,6 +221,7 @@ declare interface MigrationPlanColumn {
     table?: string
     column?: string
   }
+  enumValues?: string[]
 }
 declare interface MigrationPlanTable {
   table?: string

package/dist/migrations.js

@@ -96,9 +96,70 @@ export function prepareMigrationModelsDir() {
   };
 }
 export function sqlStatementsOf(content) {
-  return content.split(`
-`).map((line) => line.replace(/--.*$/, "")).join(`
-`).split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+  const statements = [];
+  let current = "", quote = null, dollarTag = null;
+  for (let i = 0;i < content.length; i++) {
+    const char = content[i];
+    if (dollarTag) {
+      current += char;
+      if (char === "$" && content.startsWith(dollarTag, i)) {
+        current += content.slice(i + 1, i + dollarTag.length);
+        i += dollarTag.length - 1;
+        dollarTag = null;
+      }
+      continue;
+    }
+    if (quote) {
+      current += char;
+      if (quote === "single" && char === "'" || quote === "double" && char === '"')
+        quote = null;
+      continue;
+    }
+    if (char === "-" && content[i + 1] === "-") {
+      const newline = content.indexOf(`
+`, i);
+      if (newline === -1)
+        break;
+      i = newline - 1;
+      continue;
+    }
+    const dollar = char === "$" ? /^\$[A-Za-z_]*\$/.exec(content.slice(i)) : null;
+    if (dollar) {
+      dollarTag = dollar[0];
+      current += dollarTag;
+      i += dollarTag.length - 1;
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+      current += char;
+      continue;
+    }
+    if (char === '"') {
+      quote = "double";
+      current += char;
+      continue;
+    }
+    if (char === ";") {
+      const trimmed = current.trim();
+      if (trimmed.length > 0)
+        statements.push(trimmed);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  const trailing = current.trim();
+  if (trailing.length > 0)
+    statements.push(trailing);
+  return statements;
+}
+export function guardPostgresEnumTypes(sql) {
+  return sql.replace(/CREATE\s+TYPE\s+("?[\w.]+"?)\s+AS\s+ENUM\s*\(([^)]*)\)/gi, (match, name, members, offset, whole) => {
+    if (/\bBEGIN\s*$/i.test(whole.slice(Math.max(0, offset - 40), offset)))
+      return match;
+    return `DO $stacks$ BEGIN CREATE TYPE ${name} AS ENUM (${members}); EXCEPTION WHEN duplicate_object THEN null; END $stacks$`;
+  });
 }
 export function preprocessSqliteMigrations() {
   const migrationsDir = join(process.cwd(), "database", "migrations");
@@ -484,9 +545,9 @@ function makeMigrationsIdempotent() {
     } catch {
       continue;
     }
-    if (!/\bADD\s+(?:COLUMN|CONSTRAINT)\b/i.test(sql))
+    if (!(/\bADD\s+(?:COLUMN|CONSTRAINT)\b/i.test(sql) || /\bCREATE\s+TYPE\b/i.test(sql)))
       continue;
-    const next = idempotentSql(sql);
+    const next = guardPostgresEnumTypes(idempotentSql(sql));
     if (next !== sql)
       try {
         writeFileSync(p, next);
@@ -751,9 +812,17 @@ export async function generateMigrations(options = {}) {
     if (result.hasChanges && sqlStatements.length > 0) {
       const dangling = findDanglingTypeReferences(sqlStatements);
       if (dangling.length > 0) {
-        const before = sqlStatements.length;
-        sqlStatements = sqlStatements.filter((statement) => !referencesUndefinedType(statement, dangling));
-        log.warn(`[migration] Skipped ${before - sqlStatements.length} generated statement(s) referencing enum type(s) nothing creates (${dangling.slice(0, 3).join(", ")}${dangling.length > 3 ? ", \u2026" : ""}). This is a bug in the migration generator, not in your models.`);
+        const created = createMissingEnumTypes(dangling, result.plan);
+        if (created.statements.length > 0) {
+          sqlStatements = [...created.statements, ...sqlStatements];
+          log.debug(`[migration] Created ${created.statements.length} enum type(s) an ALTER needed: ${created.defined.join(", ")}`);
+        }
+        const unresolved = dangling.filter((name) => !created.defined.includes(name));
+        if (unresolved.length > 0) {
+          const before = sqlStatements.length;
+          sqlStatements = sqlStatements.filter((statement) => !referencesUndefinedType(statement, unresolved));
+          log.warn(`[migration] Skipped ${before - sqlStatements.length} generated statement(s) referencing enum type(s) nothing creates and no model defines values for (${unresolved.slice(0, 3).join(", ")}${unresolved.length > 3 ? ", \u2026" : ""}).`);
+        }
       }
     }
     if (result.hasChanges) {
@@ -787,6 +856,30 @@ export function findDanglingTypeReferences(statements) {
   }
   return [...referenced].filter((name) => !defined.has(name)).sort();
 }
+export function createMissingEnumTypes(dangling, plan) {
+  if (dangling.length === 0)
+    return { statements: [], defined: [] };
+  const values = new Map;
+  for (const table of plan?.tables ?? []) {
+    if (!table.table)
+      continue;
+    for (const column of table.columns ?? []) {
+      if (!column.name || !column.enumValues?.length)
+        continue;
+      values.set(`${table.table}_${column.name}_type`, column.enumValues);
+    }
+  }
+  const statements = [], defined = [];
+  for (const name of dangling) {
+    const members = values.get(name);
+    if (!members?.length)
+      continue;
+    const literals = members.map((member) => `'${String(member).replaceAll("'", "''")}'`).join(", ");
+    statements.push(`${guardPostgresEnumTypes(`CREATE TYPE "${name}" AS ENUM (${literals})`)};`);
+    defined.push(name);
+  }
+  return { statements, defined };
+}
 export function inlineSqliteAddedColumnReferences(statements, plan) {
   const references = new Map;
   for (const table of plan?.tables ?? []) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/database",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.240",
+  "version": "0.70.243",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "contributors": [
@@ -54,19 +54,19 @@
   },
   "dependencies": {
     "@stacksjs/ts-validation": "^0.5.0",
-    "bun-query-builder": "^0.2.2",
+    "bun-query-builder": "^0.2.3",
     "dynamodb-tooling": "^0.3.2"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.240",
-    "@stacksjs/config": "0.70.240",
-    "@stacksjs/logging": "0.70.240",
-    "@stacksjs/router": "0.70.240",
+    "@stacksjs/cli": "0.70.243",
+    "@stacksjs/config": "0.70.243",
+    "@stacksjs/logging": "0.70.243",
+    "@stacksjs/router": "0.70.243",
     "better-dx": "^0.2.17",
-    "@stacksjs/path": "0.70.240",
-    "@stacksjs/query-builder": "0.70.240",
-    "@stacksjs/storage": "0.70.240",
-    "@stacksjs/strings": "0.70.240",
-    "@stacksjs/utils": "0.70.240"
+    "@stacksjs/path": "0.70.243",
+    "@stacksjs/query-builder": "0.70.243",
+    "@stacksjs/storage": "0.70.243",
+    "@stacksjs/strings": "0.70.243",
+    "@stacksjs/utils": "0.70.243"
   }
 }