@smartive/graphql-magic 23.7.0-next.5 → 23.7.0

package/dist/esm/migrations/generate.js

@@ -1,7 +1,7 @@
 import CodeBlockWriter from 'code-block-writer';
 import { SchemaInspector } from 'knex-schema-inspector';
 import lowerFirst from 'lodash/lowerFirst';
-import { and, get, isCreatableModel, isInherited, isStoredInDatabase, isUpdatableField, isUpdatableModel, modelNeedsTable, not, summonByName, typeToField, validateCheckConstraint, validateExcludeConstraint, } from '../models/utils';
+import { and, get, isCreatableModel, isInherited, isStoredInDatabase, isUpdatableField, isUpdatableModel, modelNeedsTable, not, summonByName, typeToField, validateCheckConstraint, } from '../models/utils';
 import { getColumnName } from '../resolvers';
 import { getDatabaseFunctions, normalizeAggregateDefinition, normalizeFunctionBody, } from './update-functions';
 export class MigrationGenerator {
@@ -16,10 +16,6 @@ export class MigrationGenerator {
     columns = {};
     /** table name -> constraint name -> check clause expression */
     existingCheckConstraints = {};
-    /** table name -> constraint name -> { normalized, raw } */
-    existingExcludeConstraints = {};
-    /** table name -> constraint name -> { normalized, raw } */
-    existingConstraintTriggers = {};
     uuidUsed;
     nowUsed;
     needsMigration = false;
@@ -52,54 +48,8 @@ export class MigrationGenerator {
             }
             this.existingCheckConstraints[tableName].set(row.constraint_name, row.check_clause);
         }
-        const excludeResult = await schema.knex.raw(`SELECT c.conrelid::regclass::text as table_name, c.conname as constraint_name, pg_get_constraintdef(c.oid) as constraint_def
-       FROM pg_constraint c
-       JOIN pg_namespace n ON c.connamespace = n.oid
-       WHERE n.nspname = 'public' AND c.contype = 'x'`);
-        const excludeRows = 'rows' in excludeResult && Array.isArray(excludeResult.rows)
-            ? excludeResult.rows
-            : [];
-        for (const row of excludeRows) {
-            const tableName = row.table_name.split('.').pop()?.replace(/^"|"$/g, '') ?? row.table_name;
-            if (!this.existingExcludeConstraints[tableName]) {
-                this.existingExcludeConstraints[tableName] = new Map();
-            }
-            this.existingExcludeConstraints[tableName].set(row.constraint_name, {
-                normalized: this.normalizeExcludeDef(row.constraint_def),
-                raw: row.constraint_def,
-            });
-        }
-        const triggerResult = await schema.knex.raw(`SELECT c.conrelid::regclass::text as table_name, c.conname as constraint_name, pg_get_triggerdef(t.oid) as trigger_def
-       FROM pg_constraint c
-       JOIN pg_trigger t ON t.tgconstraint = c.oid
-       JOIN pg_namespace n ON c.connamespace = n.oid
-       WHERE n.nspname = 'public' AND c.contype = 't'`);
-        const triggerRows = 'rows' in triggerResult && Array.isArray(triggerResult.rows)
-            ? triggerResult.rows
-            : [];
-        for (const row of triggerRows) {
-            const tableName = row.table_name.split('.').pop()?.replace(/^"|"$/g, '') ?? row.table_name;
-            if (!this.existingConstraintTriggers[tableName]) {
-                this.existingConstraintTriggers[tableName] = new Map();
-            }
-            this.existingConstraintTriggers[tableName].set(row.constraint_name, {
-                normalized: this.normalizeTriggerDef(row.trigger_def),
-                raw: row.trigger_def,
-            });
-        }
         const up = [];
         const down = [];
-        const wantsBtreeGist = models.entities.some((model) => model.constraints?.some((c) => c.kind === 'exclude' && c.elements.some((el) => 'column' in el && el.operator === '=')));
-        if (wantsBtreeGist) {
-            const extResult = await schema.knex('pg_extension').where('extname', 'btree_gist').select('oid').first();
-            const btreeGistInstalled = !!extResult;
-            if (!btreeGistInstalled) {
-                up.unshift(() => {
-                    this.writer.writeLine(`await knex.raw('CREATE EXTENSION IF NOT EXISTS btree_gist');`);
-                    this.writer.blankLine();
-                });
-            }
-        }
         this.createEnums(this.models.enums.filter((enm) => !enums.includes(lowerFirst(enm.name))), up, down);
         await this.handleFunctions(up, down);
         for (const model of models.entities) {
@@ -179,24 +129,10 @@ export class MigrationGenerator {
                             if (entry.kind === 'check') {
                                 validateCheckConstraint(model, entry);
                                 const table = model.name;
-                                const constraintName = this.getConstraintName(model, entry, i);
+                                const constraintName = this.getCheckConstraintName(model, entry, i);
+                                const expression = entry.expression;
                                 up.push(() => {
-                                    this.addCheckConstraint(table, constraintName, entry.expression, entry.deferrable);
-                                });
-                            }
-                            else if (entry.kind === 'exclude') {
-                                validateExcludeConstraint(model, entry);
-                                const table = model.name;
-                                const constraintName = this.getConstraintName(model, entry, i);
-                                up.push(() => {
-                                    this.addExcludeConstraint(table, constraintName, entry);
-                                });
-                            }
-                            else if (entry.kind === 'constraint_trigger') {
-                                const table = model.name;
-                                const constraintName = this.getConstraintName(model, entry, i);
-                                up.push(() => {
-                                    this.addConstraintTrigger(table, constraintName, entry);
+                                    this.addCheckConstraint(table, constraintName, expression);
                                 });
                             }
                         }
@@ -235,84 +171,32 @@ export class MigrationGenerator {
                     const existingFields = model.fields.filter((field) => (!field.generateAs || field.generateAs.type === 'expression') && this.hasChanged(model, field));
                     this.updateFields(model, existingFields, up, down);
                     if (model.constraints?.length) {
-                        const existingCheckMap = this.existingCheckConstraints[model.name];
-                        const existingExcludeMap = this.existingExcludeConstraints[model.name];
-                        const existingTriggerMap = this.existingConstraintTriggers[model.name];
                         for (let i = 0; i < model.constraints.length; i++) {
                             const entry = model.constraints[i];
-                            const table = model.name;
-                            const constraintName = this.getConstraintName(model, entry, i);
-                            if (entry.kind === 'check') {
-                                validateCheckConstraint(model, entry);
-                                const newExpression = entry.expression;
-                                const existingExpression = existingCheckMap?.get(constraintName);
-                                if (existingExpression === undefined) {
-                                    up.push(() => {
-                                        this.addCheckConstraint(table, constraintName, newExpression, entry.deferrable);
-                                    });
-                                    down.push(() => {
-                                        this.dropCheckConstraint(table, constraintName);
-                                    });
-                                }
-                                else if (this.normalizeCheckExpression(existingExpression) !== this.normalizeCheckExpression(newExpression)) {
-                                    up.push(() => {
-                                        this.dropCheckConstraint(table, constraintName);
-                                        this.addCheckConstraint(table, constraintName, newExpression, entry.deferrable);
-                                    });
-                                    down.push(() => {
-                                        this.dropCheckConstraint(table, constraintName);
-                                        this.addCheckConstraint(table, constraintName, existingExpression);
-                                    });
-                                }
+                            if (entry.kind !== 'check') {
+                                continue;
                             }
-                            else if (entry.kind === 'exclude') {
-                                validateExcludeConstraint(model, entry);
-                                const newDef = this.normalizeExcludeDef(this.buildExcludeDef(entry));
-                                const existing = existingExcludeMap?.get(constraintName);
-                                if (existing === undefined) {
-                                    up.push(() => {
-                                        this.addExcludeConstraint(table, constraintName, entry);
-                                    });
-                                    down.push(() => {
-                                        this.dropExcludeConstraint(table, constraintName);
-                                    });
-                                }
-                                else if (existing.normalized !== newDef) {
-                                    up.push(() => {
-                                        this.dropExcludeConstraint(table, constraintName);
-                                        this.addExcludeConstraint(table, constraintName, entry);
-                                    });
-                                    down.push(() => {
-                                        this.dropExcludeConstraint(table, constraintName);
-                                        const escaped = this.escapeExpressionForRaw(existing.raw);
-                                        this.writer.writeLine(`await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" ${escaped}\`);`);
-                                        this.writer.blankLine();
-                                    });
-                                }
+                            validateCheckConstraint(model, entry);
+                            const table = model.name;
+                            const constraintName = this.getCheckConstraintName(model, entry, i);
+                            const existingConstraint = this.findExistingConstraint(table, entry, constraintName);
+                            if (!existingConstraint) {
+                                up.push(() => {
+                                    this.addCheckConstraint(table, constraintName, entry.expression);
+                                });
+                                down.push(() => {
+                                    this.dropCheckConstraint(table, constraintName);
+                                });
                             }
-                            else if (entry.kind === 'constraint_trigger') {
-                                const newDef = this.normalizeTriggerDef(this.buildConstraintTriggerDef(table, constraintName, entry));
-                                const existing = existingTriggerMap?.get(constraintName);
-                                if (existing === undefined) {
-                                    up.push(() => {
-                                        this.addConstraintTrigger(table, constraintName, entry);
-                                    });
-                                    down.push(() => {
-                                        this.dropConstraintTrigger(table, constraintName);
-                                    });
-                                }
-                                else if (existing.normalized !== newDef) {
-                                    up.push(() => {
-                                        this.dropConstraintTrigger(table, constraintName);
-                                        this.addConstraintTrigger(table, constraintName, entry);
-                                    });
-                                    down.push(() => {
-                                        this.dropConstraintTrigger(table, constraintName);
-                                        const escaped = existing.raw.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
-                                        this.writer.writeLine(`await knex.raw(\`${escaped}\`);`);
-                                        this.writer.blankLine();
-                                    });
-                                }
+                            else if (!(await this.equalExpressions(table, existingConstraint.constraintName, existingConstraint.expression, entry.expression))) {
+                                up.push(() => {
+                                    this.dropCheckConstraint(table, existingConstraint.constraintName);
+                                    this.addCheckConstraint(table, constraintName, entry.expression);
+                                });
+                                down.push(() => {
+                                    this.dropCheckConstraint(table, constraintName);
+                                    this.addCheckConstraint(table, existingConstraint.constraintName, existingConstraint.expression);
+                                });
                             }
                         }
                     }
@@ -695,180 +579,160 @@ export class MigrationGenerator {
     renameColumn(from, to) {
         this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
     }
-    getConstraintName(model, entry, index) {
+    getCheckConstraintName(model, entry, index) {
         return `${model.name}_${entry.name}_${entry.kind}_${index}`;
     }
-    static SQL_KEYWORDS = new Set([
-        'and',
-        'or',
-        'not',
-        'in',
-        'is',
-        'null',
-        'true',
-        'false',
-        'between',
-        'like',
-        'exists',
-        'all',
-        'any',
-        'asc',
-        'desc',
-        'with',
-        'using',
-        'as',
-        'on',
-        'infinity',
-        'extract',
-        'current_date',
-        'current_timestamp',
-    ]);
-    static LITERAL_PLACEHOLDER = '\uE000';
-    normalizeSqlIdentifiers(s) {
-        const literals = [];
-        let result = s.replace(/'([^']|'')*'/g, (lit) => {
-            literals.push(lit);
-            return `${MigrationGenerator.LITERAL_PLACEHOLDER}${literals.length - 1}${MigrationGenerator.LITERAL_PLACEHOLDER}`;
-        });
-        result = result.replace(/"([^"]*)"/g, (_, ident) => `"${ident.toLowerCase()}"`);
-        result = result.replace(/\b([a-zA-Z_][a-zA-Z0-9_]*)\b(?!\s*\()/g, (match) => MigrationGenerator.SQL_KEYWORDS.has(match.toLowerCase()) ? match : `"${match.toLowerCase()}"`);
-        for (let i = 0; i < literals.length; i++) {
-            result = result.replace(new RegExp(`${MigrationGenerator.LITERAL_PLACEHOLDER}${i}${MigrationGenerator.LITERAL_PLACEHOLDER}`, 'g'), literals[i]);
+    normalizeCheckExpression(expr) {
+        let normalized = expr.replace(/\s+/g, ' ').trim();
+        while (this.isWrappedByOuterParentheses(normalized)) {
+            normalized = normalized.slice(1, -1).trim();
         }
-        return result;
+        return normalized;
     }
-    stripOuterParens(s) {
-        while (s.length >= 2 && s.startsWith('(') && s.endsWith(')')) {
-            let depth = 0;
-            let match = true;
-            for (let i = 0; i < s.length; i++) {
-                if (s[i] === '(') {
-                    depth++;
+    isWrappedByOuterParentheses(expr) {
+        if (!expr.startsWith('(') || !expr.endsWith(')')) {
+            return false;
+        }
+        let depth = 0;
+        let inSingleQuote = false;
+        for (let i = 0; i < expr.length; i++) {
+            const char = expr[i];
+            const next = expr[i + 1];
+            if (char === "'") {
+                if (inSingleQuote && next === "'") {
+                    i++;
+                    continue;
                 }
-                else if (s[i] === ')') {
-                    depth--;
+                inSingleQuote = !inSingleQuote;
+                continue;
+            }
+            if (inSingleQuote) {
+                continue;
+            }
+            if (char === '(') {
+                depth++;
+            }
+            else if (char === ')') {
+                depth--;
+                if (depth === 0 && i !== expr.length - 1) {
+                    return false;
                 }
-                if (depth === 0 && i < s.length - 1) {
-                    match = false;
-                    break;
+                if (depth < 0) {
+                    return false;
                 }
             }
-            if (!match || depth !== 0) {
-                break;
+        }
+        return depth === 0;
+    }
+    findExistingConstraint(table, entry, preferredConstraintName) {
+        const existingMap = this.existingCheckConstraints[table];
+        if (!existingMap) {
+            return null;
+        }
+        const preferredExpression = existingMap.get(preferredConstraintName);
+        if (preferredExpression !== undefined) {
+            return {
+                constraintName: preferredConstraintName,
+                expression: preferredExpression,
+            };
+        }
+        const normalizedNewExpression = this.normalizeCheckExpression(entry.expression);
+        const constraintPrefix = `${table}_${entry.name}_${entry.kind}_`;
+        for (const [constraintName, expression] of existingMap.entries()) {
+            if (!constraintName.startsWith(constraintPrefix)) {
+                continue;
+            }
+            if (this.normalizeCheckExpression(expression) !== normalizedNewExpression) {
+                continue;
             }
-            s = s.slice(1, -1).trim();
+            return { constraintName, expression };
         }
-        return s;
+        return null;
     }
-    splitAtTopLevel(s, sep) {
-        const parts = [];
-        let depth = 0;
-        let start = 0;
-        const sepLen = sep.length;
-        for (let i = 0; i <= s.length - sepLen; i++) {
-            if (s[i] === '(') {
-                depth++;
+    async equalExpressions(table, constraintName, existingExpression, newExpression) {
+        try {
+            const [canonicalExisting, canonicalNew] = await Promise.all([
+                this.canonicalizeCheckExpressionWithPostgres(table, existingExpression),
+                this.canonicalizeCheckExpressionWithPostgres(table, newExpression),
+            ]);
+            return canonicalExisting === canonicalNew;
+        }
+        catch (error) {
+            console.warn(`Failed to canonicalize check constraint "${constraintName}" on table "${table}". Treating it as changed.`, error);
+            return false;
+        }
+    }
+    async canonicalizeCheckExpressionWithPostgres(table, expression) {
+        const sourceTableIdentifier = table
+            .split('.')
+            .map((part) => this.quoteIdentifier(part))
+            .join('.');
+        const uniqueSuffix = `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+        const tableSlug = table.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        const tempTableName = `gqm_tmp_check_${tableSlug}_${uniqueSuffix}`;
+        const tempTableIdentifier = this.quoteIdentifier(tempTableName);
+        const constraintName = `gqm_tmp_check_${uniqueSuffix}`;
+        const constraintIdentifier = this.quoteIdentifier(constraintName);
+        const trx = await this.knex.transaction();
+        try {
+            await trx.raw(`CREATE TEMP TABLE ${tempTableIdentifier} (LIKE ${sourceTableIdentifier}) ON COMMIT DROP`);
+            await trx.raw(`ALTER TABLE ${tempTableIdentifier} ADD CONSTRAINT ${constraintIdentifier} CHECK (${expression})`);
+            const result = await trx.raw(`SELECT pg_get_constraintdef(c.oid, true) AS constraint_definition
+         FROM pg_constraint c
+         JOIN pg_class t
+           ON t.oid = c.conrelid
+         WHERE t.relname = ?
+           AND c.conname = ?
+         ORDER BY c.oid DESC
+         LIMIT 1`, [tempTableName, constraintName]);
+            const rows = 'rows' in result && Array.isArray(result.rows)
+                ? result.rows
+                : [];
+            const definition = rows[0]?.constraint_definition;
+            if (!definition) {
+                throw new Error(`Could not read canonical check definition for expression: ${expression}`);
             }
-            else if (s[i] === ')') {
-                depth--;
+            return this.normalizeCheckExpression(this.extractCheckExpressionFromDefinition(definition));
+        }
+        finally {
+            try {
+                await trx.rollback();
             }
-            if (depth === 0 && s.slice(i, i + sepLen).toLowerCase() === sep.toLowerCase()) {
-                parts.push(s.slice(start, i).trim());
-                start = i + sepLen;
-                i += sepLen - 1;
+            catch {
+                // no-op: transaction may already be closed by driver after failure
             }
         }
-        parts.push(s.slice(start).trim());
-        return parts.filter(Boolean);
     }
-    normalizeCheckExpression(expr) {
-        let s = expr.replace(/\s+/g, ' ').trim();
-        const normalizeParts = (str, separator) => this.splitAtTopLevel(str, separator)
-            .map((p) => this.stripOuterParens(p))
-            .join(separator);
-        s = this.stripOuterParens(s);
-        s = normalizeParts(s, ' OR ');
-        s = this.stripOuterParens(s);
-        s = normalizeParts(s, ' AND ');
-        s = s
-            .replace(/\s*\(\s*/g, '(')
-            .replace(/\s*\)\s*/g, ')')
-            .replace(/\s+AND\s+/gi, ' AND ')
-            .replace(/\s+OR\s+/gi, ' OR ')
-            .trim();
-        return this.normalizeSqlIdentifiers(s);
+    extractCheckExpressionFromDefinition(definition) {
+        const trimmed = definition.trim();
+        const match = trimmed.match(/^CHECK\s*\(([\s\S]*)\)$/i);
+        if (!match) {
+            return trimmed;
+        }
+        return match[1];
     }
-    normalizeExcludeDef(def) {
-        const s = def
-            .replace(/\s+/g, ' ')
-            .replace(/\s*\(\s*/g, '(')
-            .replace(/\s*\)\s*/g, ')')
-            .trim();
-        return this.normalizeSqlIdentifiers(s);
+    quoteIdentifier(identifier) {
+        return `"${identifier.replace(/"/g, '""')}"`;
     }
-    normalizeTriggerDef(def) {
-        return def
-            .replace(/\s+/g, ' ')
-            .replace(/\s*\(\s*/g, '(')
-            .replace(/\s*\)\s*/g, ')')
-            .replace(/\bON\s+[a-zA-Z_][a-zA-Z0-9_]*\./gi, 'ON ')
-            .trim();
+    quoteQualifiedIdentifier(identifier) {
+        return identifier
+            .split('.')
+            .map((part) => this.quoteIdentifier(part))
+            .join('.');
     }
     /** Escape expression for embedding inside a template literal in generated code */
     escapeExpressionForRaw(expr) {
         return expr.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
     }
-    addCheckConstraint(table, constraintName, expression, deferrable) {
+    addCheckConstraint(table, constraintName, expression) {
         const escaped = this.escapeExpressionForRaw(expression);
-        const deferrableClause = deferrable ? ` DEFERRABLE ${deferrable}` : '';
-        this.writer.writeLine(`await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" CHECK (${escaped})${deferrableClause}\`);`);
+        this.writer.writeLine(`await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" CHECK (${escaped})\`);`);
         this.writer.blankLine();
     }
     dropCheckConstraint(table, constraintName) {
         this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
         this.writer.blankLine();
     }
-    buildExcludeDef(entry) {
-        const elementsStr = entry.elements
-            .map((el) => ('column' in el ? `"${el.column}" WITH ${el.operator}` : `${el.expression} WITH ${el.operator}`))
-            .join(', ');
-        const whereClause = entry.where ? ` WHERE (${entry.where})` : '';
-        const deferrableClause = entry.deferrable ? ` DEFERRABLE ${entry.deferrable}` : '';
-        return `EXCLUDE USING ${entry.using} (${elementsStr})${whereClause}${deferrableClause}`;
-    }
-    addExcludeConstraint(table, constraintName, entry) {
-        const def = this.buildExcludeDef(entry);
-        const escaped = this.escapeExpressionForRaw(def);
-        this.writer.writeLine(`await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" ${escaped}\`);`);
-        this.writer.blankLine();
-    }
-    dropExcludeConstraint(table, constraintName) {
-        this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
-        this.writer.blankLine();
-    }
-    buildConstraintTriggerDef(table, constraintName, entry) {
-        const eventsStr = entry.events.join(' OR ');
-        const deferrableClause = entry.deferrable ? ` DEFERRABLE ${entry.deferrable}` : '';
-        const argsStr = entry.function.args?.length ? entry.function.args.map((a) => `"${a}"`).join(', ') : '';
-        const executeClause = argsStr
-            ? `EXECUTE FUNCTION ${entry.function.name}(${argsStr})`
-            : `EXECUTE FUNCTION ${entry.function.name}()`;
-        return `CREATE CONSTRAINT TRIGGER "${constraintName}" ${entry.when} ${eventsStr} ON "${table}"${deferrableClause} FOR EACH ${entry.forEach} ${executeClause}`;
-    }
-    addConstraintTrigger(table, constraintName, entry) {
-        const eventsStr = entry.events.join(' OR ');
-        const deferrableClause = entry.deferrable ? ` DEFERRABLE ${entry.deferrable}` : '';
-        const argsStr = entry.function.args?.length ? entry.function.args.map((a) => `"${a}"`).join(', ') : '';
-        const executeClause = argsStr
-            ? `EXECUTE FUNCTION ${entry.function.name}(${argsStr})`
-            : `EXECUTE FUNCTION ${entry.function.name}()`;
-        this.writer.writeLine(`await knex.raw(\`CREATE CONSTRAINT TRIGGER "${constraintName}" ${entry.when} ${eventsStr} ON "${table}"${deferrableClause} FOR EACH ${entry.forEach} ${executeClause}\`);`);
-        this.writer.blankLine();
-    }
-    dropConstraintTrigger(table, constraintName) {
-        this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
-        this.writer.blankLine();
-    }
     value(value) {
         if (typeof value === 'string') {
             return `'${value}'`;