@stacksjs/database 0.70.240 → 0.70.241

package/dist/migrations.d.ts

@@ -131,6 +131,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 +207,7 @@ declare interface MigrationPlanColumn {
     table?: string
     column?: string
   }
+  enumValues?: string[]
 }
 declare interface MigrationPlanTable {
   table?: string

package/dist/migrations.js

@@ -751,9 +751,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 +795,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(`DO $$ BEGIN CREATE TYPE "${name}" AS ENUM (${literals}); EXCEPTION WHEN duplicate_object THEN null; END $$;`);
+    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.241",
   "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.241",
+    "@stacksjs/config": "0.70.241",
+    "@stacksjs/logging": "0.70.241",
+    "@stacksjs/router": "0.70.241",
     "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.241",
+    "@stacksjs/query-builder": "0.70.241",
+    "@stacksjs/storage": "0.70.241",
+    "@stacksjs/strings": "0.70.241",
+    "@stacksjs/utils": "0.70.241"
   }
 }