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

package/src/migrations/generate.ts

@@ -16,6 +16,7 @@ import {
   not,
   summonByName,
   typeToField,
+  validateCheckConstraint,
 } from '../models/utils';
 import { getColumnName } from '../resolvers';
 import { Value } from '../values';
@@ -37,6 +38,8 @@ export class MigrationGenerator {
   });
   private schema: SchemaInspectorType;
   private columns: Record<string, Column[]> = {};
+  /** table name -> constraint name -> check clause expression */
+  private existingCheckConstraints: Record<string, Map<string, string>> = {};
   private uuidUsed?: boolean;
   private nowUsed?: boolean;
   public needsMigration = false;
@@ -59,6 +62,26 @@ export class MigrationGenerator {
       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: { table_name: string; constraint_name: string; check_clause: string }[] =
+      'rows' in checkResult && Array.isArray((checkResult as { rows: unknown }).rows)
+        ? (checkResult as { rows: { table_name: string; constraint_name: string; check_clause: string }[] }).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: Callbacks = [];
     const down: Callbacks = [];
 
@@ -148,6 +171,21 @@ 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);
           });
@@ -196,6 +234,40 @@ export class MigrationGenerator {
             (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)) {
@@ -691,6 +763,32 @@ export class MigrationGenerator {
     this.writer.writeLine(`table.renameColumn('${from}', '${to}');`);
   }
 
+  private getCheckConstraintName(model: EntityModel, entry: { kind: string; name: string }, index: number): string {
+    return `${model.name}_${entry.name}_${entry.kind}_${index}`;
+  }
+
+  private normalizeCheckExpression(expr: string): string {
+    return expr.replace(/\s+/g, ' ').trim();
+  }
+
+  /** Escape expression for embedding inside a template literal in generated code */
+  private escapeExpressionForRaw(expr: string): string {
+    return expr.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+  }
+
+  private addCheckConstraint(table: string, constraintName: string, expression: string) {
+    const escaped = this.escapeExpressionForRaw(expression);
+    this.writer.writeLine(
+      `await knex.raw(\`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" CHECK (${escaped})\`);`,
+    );
+    this.writer.blankLine();
+  }
+
+  private dropCheckConstraint(table: string, constraintName: string) {
+    this.writer.writeLine(`await knex.raw('ALTER TABLE "${table}" DROP CONSTRAINT "${constraintName}"');`);
+    this.writer.blankLine();
+  }
+
   private value(value: Value) {
     if (typeof value === 'string') {
       return `'${value}'`;

package/src/models/model-definitions.ts

@@ -165,6 +165,8 @@ export type ModelDefinition = {
        */
       manyToManyRelation?: boolean;
 
+      constraints?: { kind: 'check'; name: string; expression: string }[];
+
       // temporary fields for the generation of migrations
       deleted?: true;
       oldName?: string;

package/src/models/models.ts

@@ -3,7 +3,6 @@ import cloneDeep from 'lodash/cloneDeep';
 import kebabCase from 'lodash/kebabCase';
 import omit from 'lodash/omit';
 import pick from 'lodash/pick';
-import { isRelation } from '.';
 import {
   CustomFieldDefinition,
   EnumFieldDefinition,
@@ -33,7 +32,15 @@ import {
   ObjectFieldDefinition,
   RelationFieldDefinition,
 } from './model-definitions';
-import { get, getLabel, isManyToManyRelationEntityModel, summonByName, typeToField } from './utils';
+import {
+  get,
+  getLabel,
+  isManyToManyRelationEntityModel,
+  isRelation,
+  summonByName,
+  typeToField,
+  validateCheckConstraint,
+} from './utils';
 
 // These might one day become classes
 
@@ -350,6 +357,8 @@ export class EntityModel extends Model {
   defaultOrderBy?: OrderBy[];
   fields: EntityField[];
 
+  constraints?: { kind: 'check'; name: string; expression: string }[];
+
   // temporary fields for the generation of migrations
   deleted?: true;
   oldName?: string;
@@ -379,6 +388,13 @@ export class EntityModel 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);
+        }
+      }
+    }
   }
 
   public getField(name: string) {

package/src/models/utils.ts

@@ -1,7 +1,7 @@
 import camelCase from 'lodash/camelCase';
 import lodashGet from 'lodash/get';
 import startCase from 'lodash/startCase';
-import { EntityModelDefinition } from '..';
+import { EntityModelDefinition, getColumnName } from '..';
 import {
   CustomField,
   EntityField,
@@ -217,3 +217,40 @@ export const isManyToManyRelationEntityModel = ({
 
   return manyToManyRelation;
 };
+
+/**
+ * Extract column name candidates from a PostgreSQL CHECK constraint expression.
+ * Uses only double-quoted identifiers to avoid false positives (e.g. SQL functions).
+ * Matches the same naming as getColumnName in resolvers/utils (used for DB column names).
+ */
+export const extractColumnReferencesFromCheckExpression = (expression: string): string[] => {
+  const normalized = expression.replace(/\s+/g, ' ').trim();
+  const quotedIdentifiers: string[] = [];
+  const re = /"([^"]+)"/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(normalized)) !== null) {
+    quotedIdentifiers.push(match[1]);
+  }
+
+  return [...new Set(quotedIdentifiers)];
+};
+
+/**
+ * Validate that every column referenced in the check constraint expression exists on the model.
+ * Throws with a clear message if an inferred column is not found.
+ */
+export const validateCheckConstraint = (model: EntityModel, constraint: { name: string; expression: string }): void => {
+  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}`,
+      );
+    }
+  }
+};

package/src/resolvers/arguments.ts

@@ -114,7 +114,7 @@ export function normalizeValue(value: Value, type: TypeNode, schema: GraphQLSche
 }
 
 export const normalizeValueByTypeDefinition = (value: Value, type: Maybe<TypeDefinitionNode>, schema: GraphQLSchema) => {
-  if (!type || type.kind !== Kind.INPUT_OBJECT_TYPE_DEFINITION) {
+  if (type?.kind !== Kind.INPUT_OBJECT_TYPE_DEFINITION) {
     return value;
   }
 

package/tests/unit/constraints.spec.ts

@@ -0,0 +1,83 @@
+import { ModelDefinitions, Models } from '../../src/models';
+import { extractColumnReferencesFromCheckExpression, validateCheckConstraint } from '../../src/models/utils';
+
+describe('check constraints', () => {
+  const modelDefinitions: ModelDefinitions = [
+    {
+      kind: 'entity',
+      name: 'Product',
+      fields: [
+        { name: 'score', type: 'Int' },
+        { name: 'status', type: 'String' },
+        { name: 'parent', kind: 'relation', type: 'Product', toOne: true, reverse: 'children' },
+      ],
+    },
+  ];
+  const models = new Models(modelDefinitions);
+  const productModel = models.entities.find((e) => e.name === 'Product')!;
+
+  describe('extractColumnReferencesFromCheckExpression', () => {
+    it('returns empty array when expression has no double-quoted identifiers', () => {
+      expect(extractColumnReferencesFromCheckExpression('1 = 1')).toEqual([]);
+      expect(extractColumnReferencesFromCheckExpression("status = 'active'")).toEqual([]);
+    });
+
+    it('extracts single double-quoted column name', () => {
+      expect(extractColumnReferencesFromCheckExpression('"score" >= 0')).toEqual(['score']);
+    });
+
+    it('extracts multiple double-quoted column names and deduplicates', () => {
+      expect(extractColumnReferencesFromCheckExpression('"score" >= 0 AND "status" = \'ok\' AND "score" < 100')).toEqual([
+        'score',
+        'status',
+      ]);
+    });
+
+    it('normalizes whitespace before extracting', () => {
+      expect(extractColumnReferencesFromCheckExpression('  "score"   >=   0  ')).toEqual(['score']);
+    });
+  });
+
+  describe('validateCheckConstraint', () => {
+    it('does not throw when expression has no column references', () => {
+      expect(() => validateCheckConstraint(productModel, { name: 'dummy', expression: '1 = 1' })).not.toThrow();
+    });
+
+    it('does not throw when all referenced columns exist on the model', () => {
+      expect(() => validateCheckConstraint(productModel, { name: 'valid', expression: '"score" >= 0' })).not.toThrow();
+      expect(() =>
+        validateCheckConstraint(productModel, {
+          name: 'valid',
+          expression: '"score" >= 0 AND "status" IS NOT NULL',
+        }),
+      ).not.toThrow();
+    });
+
+    it('uses relation column name (foreignKey) when validating', () => {
+      expect(() =>
+        validateCheckConstraint(productModel, {
+          name: 'valid',
+          expression: '"parentId" IS NOT NULL',
+        }),
+      ).not.toThrow();
+    });
+
+    it('throws when expression references a column that does not exist', () => {
+      expect(() =>
+        validateCheckConstraint(productModel, {
+          name: 'bad',
+          expression: '"unknown_column" >= 0',
+        }),
+      ).toThrow(/Constraint "bad" references column "unknown_column" which does not exist on model Product/);
+    });
+
+    it('error message includes valid column names', () => {
+      expect(() =>
+        validateCheckConstraint(productModel, {
+          name: 'bad',
+          expression: '"nope" = 1',
+        }),
+      ).toThrow(/Valid columns:.*\bscore\b.*\bstatus\b/);
+    });
+  });
+});