@smartive/graphql-magic 23.6.1 → 23.7.0-next.2

package/src/models/model-definitions.ts

@@ -165,7 +165,26 @@ export type ModelDefinition = {
        */
       manyToManyRelation?: boolean;
 
-      constraints?: { kind: 'check'; name: string; expression: string }[];
+      constraints?: (
+        | { kind: 'check'; name: string; expression: string; deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE' }
+        | {
+            kind: 'exclude';
+            name: string;
+            using: 'gist';
+            elements: ({ column: string; operator: '=' } | { expression: string; operator: '&&' })[];
+            where?: string;
+            deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
+          }
+        | {
+            kind: 'constraint_trigger';
+            name: string;
+            when: 'AFTER' | 'BEFORE';
+            events: ('INSERT' | 'UPDATE')[];
+            forEach: 'ROW' | 'STATEMENT';
+            deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
+            function: { name: string; args?: string[] };
+          }
+      )[];
 
       // temporary fields for the generation of migrations
       deleted?: true;

package/src/models/models.ts

@@ -40,6 +40,7 @@ import {
   summonByName,
   typeToField,
   validateCheckConstraint,
+  validateExcludeConstraint,
 } from './utils';
 
 // These might one day become classes
@@ -357,7 +358,7 @@ export class EntityModel extends Model {
   defaultOrderBy?: OrderBy[];
   fields: EntityField[];
 
-  constraints?: { kind: 'check'; name: string; expression: string }[];
+  constraints?: EntityModelDefinition['constraints'];
 
   // temporary fields for the generation of migrations
   deleted?: true;
@@ -392,6 +393,8 @@ export class EntityModel extends Model {
       for (const constraint of this.constraints) {
         if (constraint.kind === 'check') {
           validateCheckConstraint(this, constraint);
+        } else if (constraint.kind === 'exclude') {
+          validateExcludeConstraint(this, constraint);
         }
       }
     }

package/src/models/utils.ts

@@ -259,3 +259,23 @@ export const validateCheckConstraint = (model: EntityModel, constraint: { name:
     }
   }
 };
+
+export const validateExcludeConstraint = (
+  model: EntityModel,
+  constraint: {
+    name: string;
+    elements: ({ column: string; operator: string } | { expression: string; operator: string })[];
+  },
+): void => {
+  const validColumnNames = new Set(model.fields.map((f) => getColumnName(f)));
+  for (const el of constraint.elements) {
+    if ('column' in el) {
+      if (!validColumnNames.has(el.column)) {
+        const validList = [...validColumnNames].sort().join(', ');
+        throw new Error(
+          `Exclude constraint "${constraint.name}" references column "${el.column}" which does not exist on model ${model.name}. Valid columns: ${validList}`,
+        );
+      }
+    }
+  }
+};

package/tests/unit/constraints.spec.ts

@@ -1,7 +1,11 @@
 import { ModelDefinitions, Models } from '../../src/models';
-import { extractColumnReferencesFromCheckExpression, validateCheckConstraint } from '../../src/models/utils';
+import {
+  extractColumnReferencesFromCheckExpression,
+  validateCheckConstraint,
+  validateExcludeConstraint,
+} from '../../src/models/utils';
 
-describe('check constraints', () => {
+describe('constraints', () => {
   const modelDefinitions: ModelDefinitions = [
     {
       kind: 'entity',
@@ -80,4 +84,96 @@ describe('check constraints', () => {
       ).toThrow(/Valid columns:.*\bscore\b.*\bstatus\b/);
     });
   });
+
+  describe('validateExcludeConstraint', () => {
+    it('does not throw when column elements reference valid columns', () => {
+      expect(() =>
+        validateExcludeConstraint(productModel, {
+          name: 'valid',
+          elements: [
+            { column: 'score', operator: '=' },
+            { expression: 'tsrange("startDate", "endDate")', operator: '&&' },
+          ],
+        }),
+      ).not.toThrow();
+    });
+
+    it('does not throw when only expression elements', () => {
+      expect(() =>
+        validateExcludeConstraint(productModel, {
+          name: 'valid',
+          elements: [{ expression: 'tsrange(now(), now())', operator: '&&' }],
+        }),
+      ).not.toThrow();
+    });
+
+    it('uses relation column name when validating', () => {
+      expect(() =>
+        validateExcludeConstraint(productModel, {
+          name: 'valid',
+          elements: [{ column: 'parentId', operator: '=' }],
+        }),
+      ).not.toThrow();
+    });
+
+    it('throws when column element references missing column', () => {
+      expect(() =>
+        validateExcludeConstraint(productModel, {
+          name: 'bad',
+          elements: [{ column: 'unknown_column', operator: '=' }],
+        }),
+      ).toThrow(
+        /Exclude constraint "bad" references column "unknown_column" which does not exist on model Product/,
+      );
+    });
+  });
+
+  describe('exclude and constraint_trigger constraints', () => {
+    const allocationDefinitions: ModelDefinitions = [
+      {
+        kind: 'entity',
+        name: 'PortfolioAllocation',
+        fields: [
+          { name: 'portfolio', kind: 'relation', type: 'Portfolio', reverse: 'allocations' },
+          { name: 'startDate', type: 'DateTime' },
+          { name: 'endDate', type: 'DateTime' },
+          { name: 'deleted', type: 'Boolean', nonNull: true, defaultValue: false },
+        ],
+        constraints: [
+          {
+            kind: 'exclude',
+            name: 'no_overlap_per_portfolio',
+            using: 'gist',
+            elements: [
+              { column: 'portfolioId', operator: '=' },
+              {
+                expression: 'tsrange("startDate", COALESCE("endDate", \'infinity\'::timestamptz))',
+                operator: '&&',
+              },
+            ],
+            where: '"deleted" = false',
+            deferrable: 'INITIALLY DEFERRED',
+          },
+          {
+            kind: 'constraint_trigger',
+            name: 'contiguous_periods',
+            when: 'AFTER',
+            events: ['INSERT', 'UPDATE'],
+            forEach: 'ROW',
+            deferrable: 'INITIALLY DEFERRED',
+            function: { name: 'contiguous_periods_check' },
+          },
+        ],
+      },
+      {
+        kind: 'entity',
+        name: 'Portfolio',
+        fields: [{ name: 'name', type: 'String' }],
+      },
+    ];
+
+    it('constructs models with exclude and constraint_trigger without throwing', () => {
+      expect(() => new Models(allocationDefinitions)).not.toThrow();
+    });
+  });
 });