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

package/src/schema/generate.ts

@@ -1,6 +1,14 @@
 import { DefinitionNode, DocumentNode, GraphQLSchema, buildASTSchema, print } from 'graphql';
 import { Models } from '../models/models';
-import { isGenerateAsField, isQueriableField, isRootModel, not, typeToField } from '../models/utils';
+import {
+  and,
+  isCreatable,
+  isQueriableField,
+  isRootModel,
+  isStoredInDatabase,
+  isUpdatable,
+  typeToField,
+} from '../models/utils';
 import { Field, document, enm, iface, input, object, scalar, union } from './utils';
 
 export const generateDefinitions = ({
@@ -133,19 +141,16 @@ export const generateDefinitions = ({
           types.push(
             input(
               `Create${model.name}`,
-              model.fields
-                .filter(({ creatable }) => creatable)
-                .filter(not(isGenerateAsField))
-                .map((field) =>
-                  field.kind === 'relation'
-                    ? { name: `${field.name}Id`, type: 'ID', nonNull: field.nonNull }
-                    : {
-                        name: field.name,
-                        type: field.kind === 'json' ? `Create${field.type}` : field.type,
-                        list: field.list,
-                        nonNull: field.nonNull && field.defaultValue === undefined,
-                      },
-                ),
+              model.fields.filter(and(isCreatable, isStoredInDatabase)).map((field) =>
+                field.kind === 'relation'
+                  ? { name: `${field.name}Id`, type: 'ID', nonNull: field.nonNull }
+                  : {
+                      name: field.name,
+                      type: field.kind === 'json' ? `Create${field.type}` : field.type,
+                      list: field.list,
+                      nonNull: field.nonNull && field.defaultValue === undefined,
+                    },
+              ),
             ),
           );
         }
@@ -154,18 +159,15 @@ export const generateDefinitions = ({
           types.push(
             input(
               `Update${model.name}`,
-              model.fields
-                .filter(({ updatable }) => updatable)
-                .filter(not(isGenerateAsField))
-                .map((field) =>
-                  field.kind === 'relation'
-                    ? { name: `${field.name}Id`, type: 'ID' }
-                    : {
-                        name: field.name,
-                        type: field.kind === 'json' ? `Update${field.type}` : field.type,
-                        list: field.list,
-                      },
-                ),
+              model.fields.filter(and(isUpdatable, isStoredInDatabase)).map((field) =>
+                field.kind === 'relation'
+                  ? { name: `${field.name}Id`, type: 'ID' }
+                  : {
+                      name: field.name,
+                      type: field.kind === 'json' ? `Update${field.type}` : field.type,
+                      list: field.list,
+                    },
+              ),
             ),
           );
         }

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();
+    });
+  });
 });

package/tests/unit/generate-as.spec.ts

@@ -1,7 +1,7 @@
 import { Kind } from 'graphql';
 import { generateDBModels } from '../../src/db/generate';
 import {
-  isGenerateAsField,
+  isDynamicField,
   isStoredInDatabase,
 } from '../../src/models/utils';
 import { ModelDefinitions, Models } from '../../src/models';
@@ -42,10 +42,10 @@ jest.mock('code-block-writer', () => {
 });
 
 describe('generateAs helpers', () => {
-  describe('isGenerateAsField', () => {
+  describe('isDynamicField', () => {
     it('returns false when field.generateAs is undefined', () => {
       const field: EntityField = { name: 'price', type: 'Float' };
-      expect(isGenerateAsField(field)).toBe(false);
+      expect(isDynamicField(field)).toBe(false);
     });
 
     it('returns true when field has generateAs with type expression', () => {
@@ -54,7 +54,7 @@ describe('generateAs helpers', () => {
         type: 'Float',
         generateAs: { expression: 'price * quantity', type: 'expression' },
       };
-      expect(isGenerateAsField(field)).toBe(true);
+      expect(isDynamicField(field)).toBe(true);
     });
 
     it('returns true when field has generateAs with type stored', () => {
@@ -63,7 +63,7 @@ describe('generateAs helpers', () => {
         type: 'Float',
         generateAs: { expression: 'price * quantity', type: 'stored' },
       };
-      expect(isGenerateAsField(field)).toBe(true);
+      expect(isDynamicField(field)).toBe(true);
     });
 
     it('returns true when field has generateAs with type virtual', () => {
@@ -72,7 +72,7 @@ describe('generateAs helpers', () => {
         type: 'Float',
         generateAs: { expression: 'price * quantity', type: 'virtual' },
       };
-      expect(isGenerateAsField(field)).toBe(true);
+      expect(isDynamicField(field)).toBe(true);
     });
   });
 

package/tests/utils/functions.ts

@@ -0,0 +1 @@
+export const functions: string[] = [];