@smartive/graphql-magic 23.5.0 → 23.6.0-next.2

package/.github/workflows/docs.yml

@@ -8,12 +8,12 @@ jobs:
   docs:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           persist-credentials: false
 
       - name: Setup Node
-        uses: actions/setup-node@v6
+        uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6
         with:
           node-version: '24'
       - name: Install and Build
@@ -22,7 +22,7 @@ jobs:
           npm install
           npm run build
       - name: Deploy
-        uses: JamesIves/github-pages-deploy-action@v4
+        uses: JamesIves/github-pages-deploy-action@d92aa235d04922e8f08b40ce78cc5442fcfbfa2f # v4
         with:
           branch: gh-pages
           folder: docs/build

package/.github/workflows/release.yml

@@ -19,10 +19,10 @@ jobs:
     name: build and release
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: true
-      - uses: actions/setup-node@v6
+      - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6
         with:
           node-version: 24
           registry-url: 'https://registry.npmjs.org'

package/.github/workflows/testing.yml

@@ -44,7 +44,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
       - name: Install dependencies
         run: npm ci
       - name: Lint

package/CHANGELOG.md

@@ -1,5 +1,5 @@
-## [23.5.0](https://github.com/smartive/graphql-magic/compare/v23.4.1...v23.5.0) (2026-02-09)
+## [23.6.0-next.2](https://github.com/smartive/graphql-magic/compare/v23.6.0-next.1...v23.6.0-next.2) (2026-02-23)
 
-### Features
+### Bug Fixes
 
-* Functions migration generator ([0525bb5](https://github.com/smartive/graphql-magic/commit/0525bb5d182bdd258fd6408be32bfb9ce5146faa))
+* Simplify type checking in normalizeValueByTypeDefinition function ([0a06610](https://github.com/smartive/graphql-magic/commit/0a066109c83114b4b0c06afd8531addb4fbbac17))

package/dist/bin/gqm.cjs

@@ -357,6 +357,7 @@ var EntityModel = class extends Model {
   displayField;
   defaultOrderBy;
   fields;
+  constraints;
   // temporary fields for the generation of migrations
   deleted;
   oldName;
@@ -384,6 +385,13 @@ var EntityModel = class extends Model {
     for (const field of definition.fields) {
       this.fieldsByName[field.name] = field;
     }
+    if (this.constraints?.length) {
+      for (const constraint of this.constraints) {
+        if (constraint.kind === "check") {
+          validateCheckConstraint(this, constraint);
+        }
+      }
+    }
   }
   getField(name2) {
     return get(this.fieldsByName, name2);
@@ -607,6 +615,31 @@ var isManyToManyRelationEntityModel = ({
   }
   return manyToManyRelation;
 };
+var extractColumnReferencesFromCheckExpression = (expression) => {
+  const normalized = expression.replace(/\s+/g, " ").trim();
+  const quotedIdentifiers = [];
+  const re = /"([^"]+)"/g;
+  let match;
+  while ((match = re.exec(normalized)) !== null) {
+    quotedIdentifiers.push(match[1]);
+  }
+  return [...new Set(quotedIdentifiers)];
+};
+var validateCheckConstraint = (model, constraint) => {
+  const identifiers = extractColumnReferencesFromCheckExpression(constraint.expression);
+  if (identifiers.length === 0) {
+    return;
+  }
+  const validColumnNames = new Set(model.fields.map((f) => getColumnName(f)));
+  for (const identifier of identifiers) {
+    if (!validColumnNames.has(identifier)) {
+      const validList = [...validColumnNames].sort().join(", ");
+      throw new Error(
+        `Constraint "${constraint.name}" references column "${identifier}" which does not exist on model ${model.name}. Valid columns: ${validList}`
+      );
+    }
+  }
+};
 
 // src/db/generate.ts
 var import_code_block_writer = __toESM(require("code-block-writer"), 1);
@@ -976,6 +1009,8 @@ var MigrationGenerator = class {
   });
   schema;
   columns = {};
+  /** table name -> constraint name -> check clause expression */
+  existingCheckConstraints = {};
   uuidUsed;
   nowUsed;
   needsMigration = false;
@@ -987,6 +1022,22 @@ var MigrationGenerator = class {
     for (const table of tables) {
       this.columns[table] = await schema.columnInfo(table);
     }
+    const checkResult = await schema.knex.raw(
+      `SELECT tc.table_name, tc.constraint_name, cc.check_clause
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.check_constraints cc
+         ON tc.constraint_schema = cc.constraint_schema AND tc.constraint_name = cc.constraint_name
+       WHERE tc.table_schema = ? AND tc.constraint_type = ?`,
+      ["public", "CHECK"]
+    );
+    const rows = "rows" in checkResult && Array.isArray(checkResult.rows) ? checkResult.rows : [];
+    for (const row of rows) {
+      const tableName = row.table_name;
+      if (!this.existingCheckConstraints[tableName]) {
+        this.existingCheckConstraints[tableName] = /* @__PURE__ */ new Map();
+      }
+      this.existingCheckConstraints[tableName].set(row.constraint_name, row.check_clause);
+    }
     const up = [];
     const down = [];
     this.createEnums(
@@ -1061,6 +1112,20 @@ var MigrationGenerator = class {
               }
             });
           });
+          if (model.constraints?.length) {
+            for (let i = 0; i < model.constraints.length; i++) {
+              const entry = model.constraints[i];
+              if (entry.kind === "check") {
+                validateCheckConstraint(model, entry);
+                const table = model.name;
+                const constraintName = this.getCheckConstraintName(model, entry, i);
+                const expression = entry.expression;
+                up.push(() => {
+                  this.addCheckConstraint(table, constraintName, expression);
+                });
+              }
+            }
+          }
           down.push(() => {
             this.dropTable(model.name);
           });
@@ -1095,6 +1160,37 @@ var MigrationGenerator = class {
             (field) => (!field.generateAs || field.generateAs.type === "expression") && this.hasChanged(model, field)
           );
           this.updateFields(model, existingFields, up, down);
+          if (model.constraints?.length) {
+            const existingMap = this.existingCheckConstraints[model.name];
+            for (let i = 0; i < model.constraints.length; i++) {
+              const entry = model.constraints[i];
+              if (entry.kind !== "check") {
+                continue;
+              }
+              validateCheckConstraint(model, entry);
+              const table = model.name;
+              const constraintName = this.getCheckConstraintName(model, entry, i);
+              const newExpression = entry.expression;
+              const existingExpression = existingMap?.get(constraintName);
+              if (existingExpression === void 0) {
+                up.push(() => {
+                  this.addCheckConstraint(table, constraintName, newExpression);
+                });
+                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);
+                });
+                down.push(() => {
+                  this.dropCheckConstraint(table, constraintName);
+                  this.addCheckConstraint(table, constraintName, existingExpression);
+                });
+              }
+            }
+          }
         }
         if (isUpdatableModel(model)) {
           if (!tables.includes(`${model.name}Revision`)) {
@@ -1466,6 +1562,27 @@ var MigrationGenerator = class {
   renameColumn(from, to) {
     this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
   }
+  getCheckConstraintName(model, entry, index) {
+    return `${model.name}_${entry.name}_${entry.kind}_${index}`;
+  }
+  normalizeCheckExpression(expr) {
+    return expr.replace(/\s+/g, " ").trim();
+  }
+  /** 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) {
+    const escaped = this.escapeExpressionForRaw(expression);
+    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();
+  }
   value(value2) {
     if (typeof value2 === "string") {
       return `'${value2}'`;

package/dist/cjs/index.cjs

@@ -79,6 +79,7 @@ __export(index_exports, {
   document: () => document,
   enm: () => enm,
   execute: () => execute,
+  extractColumnReferencesFromCheckExpression: () => extractColumnReferencesFromCheckExpression,
   extractFunctionBody: () => extractFunctionBody,
   fetchDisplay: () => fetchDisplay,
   fetchManyToManyDisplay: () => fetchManyToManyDisplay,
@@ -194,6 +195,7 @@ __export(index_exports, {
   updateEntities: () => updateEntities,
   updateEntity: () => updateEntity,
   updateFunctions: () => updateFunctions,
+  validateCheckConstraint: () => validateCheckConstraint,
   value: () => value
 });
 module.exports = __toCommonJS(index_exports);
@@ -618,6 +620,7 @@ var EntityModel = class extends Model {
   displayField;
   defaultOrderBy;
   fields;
+  constraints;
   // temporary fields for the generation of migrations
   deleted;
   oldName;
@@ -645,6 +648,13 @@ var EntityModel = class extends Model {
     for (const field of definition.fields) {
       this.fieldsByName[field.name] = field;
     }
+    if (this.constraints?.length) {
+      for (const constraint of this.constraints) {
+        if (constraint.kind === "check") {
+          validateCheckConstraint(this, constraint);
+        }
+      }
+    }
   }
   getField(name2) {
     return get(this.fieldsByName, name2);
@@ -913,6 +923,31 @@ var isManyToManyRelationEntityModel = ({
   }
   return manyToManyRelation;
 };
+var extractColumnReferencesFromCheckExpression = (expression) => {
+  const normalized = expression.replace(/\s+/g, " ").trim();
+  const quotedIdentifiers = [];
+  const re = /"([^"]+)"/g;
+  let match;
+  while ((match = re.exec(normalized)) !== null) {
+    quotedIdentifiers.push(match[1]);
+  }
+  return [...new Set(quotedIdentifiers)];
+};
+var validateCheckConstraint = (model, constraint) => {
+  const identifiers = extractColumnReferencesFromCheckExpression(constraint.expression);
+  if (identifiers.length === 0) {
+    return;
+  }
+  const validColumnNames = new Set(model.fields.map((f) => getColumnName(f)));
+  for (const identifier of identifiers) {
+    if (!validColumnNames.has(identifier)) {
+      const validList = [...validColumnNames].sort().join(", ");
+      throw new Error(
+        `Constraint "${constraint.name}" references column "${identifier}" which does not exist on model ${model.name}. Valid columns: ${validList}`
+      );
+    }
+  }
+};
 
 // src/client/queries.ts
 var fieldIsSearchable = (model, fieldName) => {
@@ -1201,7 +1236,7 @@ function normalizeValue(value2, type, schema) {
   }
 }
 var normalizeValueByTypeDefinition = (value2, type, schema) => {
-  if (!type || type.kind !== import_graphql3.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+  if (type?.kind !== import_graphql3.Kind.INPUT_OBJECT_TYPE_DEFINITION) {
     return value2;
   }
   if (value2 === null || value2 === void 0) {
@@ -2980,6 +3015,8 @@ var MigrationGenerator = class {
   });
   schema;
   columns = {};
+  /** table name -> constraint name -> check clause expression */
+  existingCheckConstraints = {};
   uuidUsed;
   nowUsed;
   needsMigration = false;
@@ -2991,6 +3028,22 @@ var MigrationGenerator = class {
     for (const table of tables) {
       this.columns[table] = await schema.columnInfo(table);
     }
+    const checkResult = await schema.knex.raw(
+      `SELECT tc.table_name, tc.constraint_name, cc.check_clause
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.check_constraints cc
+         ON tc.constraint_schema = cc.constraint_schema AND tc.constraint_name = cc.constraint_name
+       WHERE tc.table_schema = ? AND tc.constraint_type = ?`,
+      ["public", "CHECK"]
+    );
+    const rows = "rows" in checkResult && Array.isArray(checkResult.rows) ? checkResult.rows : [];
+    for (const row of rows) {
+      const tableName = row.table_name;
+      if (!this.existingCheckConstraints[tableName]) {
+        this.existingCheckConstraints[tableName] = /* @__PURE__ */ new Map();
+      }
+      this.existingCheckConstraints[tableName].set(row.constraint_name, row.check_clause);
+    }
     const up = [];
     const down = [];
     this.createEnums(
@@ -3065,6 +3118,20 @@ var MigrationGenerator = class {
               }
             });
           });
+          if (model.constraints?.length) {
+            for (let i = 0; i < model.constraints.length; i++) {
+              const entry = model.constraints[i];
+              if (entry.kind === "check") {
+                validateCheckConstraint(model, entry);
+                const table = model.name;
+                const constraintName = this.getCheckConstraintName(model, entry, i);
+                const expression = entry.expression;
+                up.push(() => {
+                  this.addCheckConstraint(table, constraintName, expression);
+                });
+              }
+            }
+          }
           down.push(() => {
             this.dropTable(model.name);
           });
@@ -3099,6 +3166,37 @@ var MigrationGenerator = class {
             (field) => (!field.generateAs || field.generateAs.type === "expression") && this.hasChanged(model, field)
           );
           this.updateFields(model, existingFields, up, down);
+          if (model.constraints?.length) {
+            const existingMap = this.existingCheckConstraints[model.name];
+            for (let i = 0; i < model.constraints.length; i++) {
+              const entry = model.constraints[i];
+              if (entry.kind !== "check") {
+                continue;
+              }
+              validateCheckConstraint(model, entry);
+              const table = model.name;
+              const constraintName = this.getCheckConstraintName(model, entry, i);
+              const newExpression = entry.expression;
+              const existingExpression = existingMap?.get(constraintName);
+              if (existingExpression === void 0) {
+                up.push(() => {
+                  this.addCheckConstraint(table, constraintName, newExpression);
+                });
+                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);
+                });
+                down.push(() => {
+                  this.dropCheckConstraint(table, constraintName);
+                  this.addCheckConstraint(table, constraintName, existingExpression);
+                });
+              }
+            }
+          }
         }
         if (isUpdatableModel(model)) {
           if (!tables.includes(`${model.name}Revision`)) {
@@ -3470,6 +3568,27 @@ var MigrationGenerator = class {
   renameColumn(from, to) {
     this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
   }
+  getCheckConstraintName(model, entry, index) {
+    return `${model.name}_${entry.name}_${entry.kind}_${index}`;
+  }
+  normalizeCheckExpression(expr) {
+    return expr.replace(/\s+/g, " ").trim();
+  }
+  /** 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) {
+    const escaped = this.escapeExpressionForRaw(expression);
+    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();
+  }
   value(value2) {
     if (typeof value2 === "string") {
       return `'${value2}'`;
@@ -4446,6 +4565,7 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql6.buildAST
   document,
   enm,
   execute,
+  extractColumnReferencesFromCheckExpression,
   extractFunctionBody,
   fetchDisplay,
   fetchManyToManyDisplay,
@@ -4561,5 +4681,6 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql6.buildAST
   updateEntities,
   updateEntity,
   updateFunctions,
+  validateCheckConstraint,
   value
 });

package/dist/esm/migrations/generate.d.ts

@@ -7,6 +7,8 @@ export declare class MigrationGenerator {
     private writer;
     private schema;
     private columns;
+    /** table name -> constraint name -> check clause expression */
+    private existingCheckConstraints;
     private uuidUsed?;
     private nowUsed?;
     needsMigration: boolean;
@@ -28,6 +30,12 @@ export declare class MigrationGenerator {
     private dropTable;
     private renameTable;
     private renameColumn;
+    private getCheckConstraintName;
+    private normalizeCheckExpression;
+    /** Escape expression for embedding inside a template literal in generated code */
+    private escapeExpressionForRaw;
+    private addCheckConstraint;
+    private dropCheckConstraint;
     private value;
     private columnRaw;
     private column;

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, isUpdatableField, isUpdatableModel, modelNeedsTable, not, summonByName, typeToField, } from '../models/utils';
+import { and, get, isCreatableModel, isInherited, isUpdatableField, isUpdatableModel, modelNeedsTable, not, summonByName, typeToField, validateCheckConstraint, } from '../models/utils';
 import { getColumnName } from '../resolvers';
 import { getDatabaseFunctions, normalizeAggregateDefinition, normalizeFunctionBody, } from './update-functions';
 export class MigrationGenerator {
@@ -14,6 +14,8 @@ export class MigrationGenerator {
     });
     schema;
     columns = {};
+    /** table name -> constraint name -> check clause expression */
+    existingCheckConstraints = {};
     uuidUsed;
     nowUsed;
     needsMigration = false;
@@ -31,6 +33,21 @@ export class MigrationGenerator {
         for (const table of tables) {
             this.columns[table] = await schema.columnInfo(table);
         }
+        const checkResult = await schema.knex.raw(`SELECT tc.table_name, tc.constraint_name, cc.check_clause
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.check_constraints cc
+         ON tc.constraint_schema = cc.constraint_schema AND tc.constraint_name = cc.constraint_name
+       WHERE tc.table_schema = ? AND tc.constraint_type = ?`, ['public', 'CHECK']);
+        const rows = 'rows' in checkResult && Array.isArray(checkResult.rows)
+            ? checkResult.rows
+            : [];
+        for (const row of rows) {
+            const tableName = row.table_name;
+            if (!this.existingCheckConstraints[tableName]) {
+                this.existingCheckConstraints[tableName] = new Map();
+            }
+            this.existingCheckConstraints[tableName].set(row.constraint_name, row.check_clause);
+        }
         const up = [];
         const down = [];
         this.createEnums(this.models.enums.filter((enm) => !enums.includes(lowerFirst(enm.name))), up, down);
@@ -106,6 +123,20 @@ export class MigrationGenerator {
                             }
                         });
                     });
+                    if (model.constraints?.length) {
+                        for (let i = 0; i < model.constraints.length; i++) {
+                            const entry = model.constraints[i];
+                            if (entry.kind === 'check') {
+                                validateCheckConstraint(model, entry);
+                                const table = model.name;
+                                const constraintName = this.getCheckConstraintName(model, entry, i);
+                                const expression = entry.expression;
+                                up.push(() => {
+                                    this.addCheckConstraint(table, constraintName, expression);
+                                });
+                            }
+                        }
+                    }
                     down.push(() => {
                         this.dropTable(model.name);
                     });
@@ -139,6 +170,38 @@ 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 existingMap = this.existingCheckConstraints[model.name];
+                        for (let i = 0; i < model.constraints.length; i++) {
+                            const entry = model.constraints[i];
+                            if (entry.kind !== 'check') {
+                                continue;
+                            }
+                            validateCheckConstraint(model, entry);
+                            const table = model.name;
+                            const constraintName = this.getCheckConstraintName(model, entry, i);
+                            const newExpression = entry.expression;
+                            const existingExpression = existingMap?.get(constraintName);
+                            if (existingExpression === undefined) {
+                                up.push(() => {
+                                    this.addCheckConstraint(table, constraintName, newExpression);
+                                });
+                                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);
+                                });
+                                down.push(() => {
+                                    this.dropCheckConstraint(table, constraintName);
+                                    this.addCheckConstraint(table, constraintName, existingExpression);
+                                });
+                            }
+                        }
+                    }
                 }
                 if (isUpdatableModel(model)) {
                     if (!tables.includes(`${model.name}Revision`)) {
@@ -524,6 +587,25 @@ export class MigrationGenerator {
     renameColumn(from, to) {
         this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
     }
+    getCheckConstraintName(model, entry, index) {
+        return `${model.name}_${entry.name}_${entry.kind}_${index}`;
+    }
+    normalizeCheckExpression(expr) {
+        return expr.replace(/\s+/g, ' ').trim();
+    }
+    /** 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) {
+        const escaped = this.escapeExpressionForRaw(expression);
+        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();
+    }
     value(value) {
         if (typeof value === 'string') {
             return `'${value}'`;