feat(db): auto-transform drizzle-kit output for DSQL compatibility

check-dsql-compat.ts now auto-fixes:
- statement-breakpoint → blank lines (runner splits on \n\n)
- CREATE INDEX → CREATE INDEX ASYNC
- Removes REFERENCES / FOREIGN KEY lines

Still errors on unfixable patterns: ALTER COLUMN TYPE, DROP COLUMN, SERIAL.

Author: konokenj

AGENTS.md

@@ -66,13 +66,13 @@ Schema changes:
 # 1. Edit schema
 #    packages/db/src/schema.ts
 
-# 2. Generate migration SQL + DSQL compatibility check
+# 2. Generate migration SQL (auto-transforms for DSQL compatibility)
 pnpm --filter @repo/db run generate
+#    Auto-transforms: statement-breakpoint → blank lines, CREATE INDEX → ASYNC, FK removal
+#    Errors on unfixable patterns: ALTER COLUMN TYPE, DROP COLUMN, SERIAL
 
-# 3. Review and fix the generated SQL in packages/db/migrations/
+# 3. Review the generated SQL in packages/db/migrations/
 #    - Add IF NOT EXISTS for idempotency
-#    - Replace CREATE INDEX with CREATE INDEX ASYNC
-#    - Replace --> statement-breakpoint with blank lines (runner splits on \n\n)
 
 # 4. Apply to dev cluster
 pnpm --filter @repo/db run migrate

packages/db/src/check-dsql-compat.ts

@@ -1,36 +1,66 @@
-// Validate migration SQL files for DSQL compatibility.
-// Run after drizzle-kit generate to catch incompatible DDL before commit.
+// Transform drizzle-kit generated SQL for DSQL compatibility, then validate.
+// Automatically fixes what can be fixed, errors on what cannot.
+//
+// Auto-transforms:
+//   - "--> statement-breakpoint" → blank line (runner splits on \n\n)
+//   - "CREATE INDEX" → "CREATE INDEX ASYNC"
+//   - Removes REFERENCES / FOREIGN KEY clauses
+//
+// Errors (cannot auto-fix):
+//   - ALTER COLUMN TYPE
+//   - DROP COLUMN
+//   - SERIAL types
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const migrationsDir = path.join(__dirname, '..', 'migrations');
 
-const rules: { pattern: RegExp; message: string }[] = [
-  { pattern: /CREATE\s+INDEX\s+(?!.*ASYNC)/i, message: 'CREATE INDEX must use ASYNC keyword' },
-  { pattern: /REFERENCES\s+/i, message: 'FOREIGN KEY / REFERENCES not supported' },
-  { pattern: /FOREIGN\s+KEY/i, message: 'FOREIGN KEY not supported' },
-  { pattern: /ALTER\s+.*\s+TYPE\s+/i, message: 'ALTER COLUMN TYPE not supported' },
-  { pattern: /DROP\s+COLUMN/i, message: 'DROP COLUMN not supported' },
-  { pattern: /\bSERIAL\b/i, message: 'SERIAL types not supported (use UUID)' },
-];
-
 const files = fs.readdirSync(migrationsDir).filter((f) => f.endsWith('.sql'));
+let transformed = 0;
 let errors = 0;
 
 for (const file of files) {
-  const content = fs.readFileSync(path.join(migrationsDir, file), 'utf8');
-  for (const { pattern, message } of rules) {
-    if (pattern.test(content)) {
+  const filePath = path.join(migrationsDir, file);
+  const original = fs.readFileSync(filePath, 'utf8');
+  let sql = original;
+
+  // Auto-transform: statement-breakpoint → blank line
+  sql = sql.replace(/--> statement-breakpoint\n/g, '\n');
+
+  // Auto-transform: CREATE INDEX → CREATE INDEX ASYNC (skip if already ASYNC)
+  sql = sql.replace(/CREATE\s+INDEX(?!\s+ASYNC)/gi, 'CREATE INDEX ASYNC');
+
+  // Auto-transform: remove lines with REFERENCES or FOREIGN KEY
+  sql = sql
+    .split('\n')
+    .filter((line) => !/REFERENCES\s+/i.test(line) && !/FOREIGN\s+KEY/i.test(line))
+    .join('\n');
+
+  if (sql !== original) {
+    fs.writeFileSync(filePath, sql);
+    console.log(`TRANSFORMED: ${file}`);
+    transformed++;
+  }
+
+  // Validate: errors that cannot be auto-fixed
+  const unfixable: { pattern: RegExp; message: string }[] = [
+    { pattern: /ALTER\s+.*\s+TYPE\s+/i, message: 'ALTER COLUMN TYPE not supported' },
+    { pattern: /DROP\s+COLUMN/i, message: 'DROP COLUMN not supported' },
+    { pattern: /\bSERIAL\b/i, message: 'SERIAL types not supported (use UUID)' },
+  ];
+  for (const { pattern, message } of unfixable) {
+    if (pattern.test(sql)) {
       console.error(`ERROR: ${file} — ${message}`);
       errors++;
     }
   }
 }
 
+if (transformed > 0) console.log(`\n${transformed} file(s) auto-transformed for DSQL compatibility.`);
 if (errors > 0) {
-  console.error(`\n${errors} DSQL compatibility error(s). Fix the SQL before committing.`);
+  console.error(`\n${errors} unfixable error(s). These require manual migration scripts.`);
   process.exit(1);
 }
 console.log('All migration files DSQL-compatible.');