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

package/src/db/generate.ts

@@ -1,5 +1,15 @@
 import CodeBlockWriter from 'code-block-writer';
-import { EntityField, get, getColumnName, isCustomField, isInTable, isRootModel, not } from '..';
+import {
+  EntityField,
+  get,
+  getColumnName,
+  isCustomField,
+  isGenerateAsField,
+  isInTable,
+  isRootModel,
+  isStoredInDatabase,
+  not,
+} from '..';
 import { Models } from '../models/models';
 import { DATE_CLASS, DATE_CLASS_IMPORT, DateLibrary } from '../utils/dates';
 
@@ -60,7 +70,7 @@ export const generateDBModels = (models: Models, dateLibrary: DateLibrary) => {
     writer
       .write(`export type ${model.name} = `)
       .inlineBlock(() => {
-        for (const field of fields.filter(not(isCustomField))) {
+        for (const field of fields.filter(not(isCustomField)).filter(isStoredInDatabase)) {
           writer
             .write(`'${getColumnName(field)}': ${getFieldType(field, dateLibrary)}${field.nonNull ? '' : ' | null'};`)
             .newLine();
@@ -71,7 +81,7 @@ export const generateDBModels = (models: Models, dateLibrary: DateLibrary) => {
     writer
       .write(`export type ${model.name}Initializer = `)
       .inlineBlock(() => {
-        for (const field of fields.filter(not(isCustomField)).filter(isInTable)) {
+        for (const field of fields.filter(not(isCustomField)).filter(isInTable).filter(not(isGenerateAsField))) {
           writer
             .write(
               `'${getColumnName(field)}'${field.nonNull && field.defaultValue === undefined ? '' : '?'}: ${getFieldType(
@@ -88,7 +98,7 @@ export const generateDBModels = (models: Models, dateLibrary: DateLibrary) => {
     writer
       .write(`export type ${model.name}Mutator = `)
       .inlineBlock(() => {
-        for (const field of fields.filter(not(isCustomField)).filter(isInTable)) {
+        for (const field of fields.filter(not(isCustomField)).filter(isInTable).filter(not(isGenerateAsField))) {
           writer
             .write(
               `'${getColumnName(field)}'?: ${getFieldType(field, dateLibrary, true)}${field.list ? ' | string' : ''}${
@@ -104,7 +114,7 @@ export const generateDBModels = (models: Models, dateLibrary: DateLibrary) => {
       writer
         .write(`export type ${model.name}Seed = `)
         .inlineBlock(() => {
-          for (const field of fields.filter(not(isCustomField))) {
+          for (const field of fields.filter(not(isCustomField)).filter(not(isGenerateAsField))) {
             if (model.parent && field.name === 'type') {
               continue;
             }

package/src/migrations/generate.ts

@@ -9,6 +9,7 @@ import {
   and,
   get,
   isCreatableModel,
+  isGenerateAsField,
   isInherited,
   isUpdatableField,
   isUpdatableModel,
@@ -300,7 +301,7 @@ export class MigrationGenerator {
 
                           for (const { name, kind } of model.fields
                             .filter(isUpdatableField)
-                            .filter((f) => !(f.generateAs?.type === 'expression'))) {
+                            .filter(not(isGenerateAsField))) {
                             const col = kind === 'relation' ? `${name}Id` : name;
 
                             writer.writeLine(`${col}: row.${col},`);
@@ -332,10 +333,10 @@ export class MigrationGenerator {
 
             const missingRevisionFields = model.fields
               .filter(isUpdatableField)
+              .filter(not(isGenerateAsField))
               .filter(
                 ({ name, ...field }) =>
                   field.kind !== 'custom' &&
-                  !(field.generateAs?.type === 'expression') &&
                   !this.getColumn(revisionTable, field.kind === 'relation' ? field.foreignKey || `${name}Id` : name),
               );
 
@@ -534,7 +535,7 @@ export class MigrationGenerator {
     });
 
     if (isUpdatableModel(model)) {
-      const updatableFields = fields.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === 'expression'));
+      const updatableFields = fields.filter(isUpdatableField).filter(not(isGenerateAsField));
       if (!updatableFields.length) {
         return;
       }
@@ -588,7 +589,7 @@ export class MigrationGenerator {
     });
 
     if (isUpdatableModel(model)) {
-      const updatableFields = fields.filter(isUpdatableField).filter((f) => !(f.generateAs?.type === 'expression'));
+      const updatableFields = fields.filter(isUpdatableField).filter(not(isGenerateAsField));
       if (!updatableFields.length) {
         return;
       }
@@ -632,9 +633,7 @@ export class MigrationGenerator {
         }
       }
 
-      for (const field of model.fields
-        .filter(and(isUpdatableField, not(isInherited)))
-        .filter((f) => !(f.generateAs?.type === 'expression'))) {
+      for (const field of model.fields.filter(and(isUpdatableField, not(isInherited))).filter(not(isGenerateAsField))) {
         this.column(field, { setUnique: false, setDefault: false });
       }
     });

package/src/models/utils.ts

@@ -88,6 +88,12 @@ export const isQueriableField = ({ queriable }: EntityField) => queriable !== fa
 
 export const isCustomField = (field: EntityField): field is CustomField => field.kind === 'custom';
 
+/** True if field is computed (generateAs); not user-settable in insert/update. */
+export const isGenerateAsField = (field: EntityField) => !!field.generateAs;
+
+/** True if field exists as a column in the DB (excludes expression-only fields). */
+export const isStoredInDatabase = (field: EntityField) => field.generateAs?.type !== 'expression';
+
 export const isVisible = ({ hidden }: EntityField) => hidden !== true;
 
 export const isSimpleField = and(not(isRelation), not(isCustomField));

package/src/permissions/check.ts

@@ -2,7 +2,7 @@ import { Knex } from 'knex';
 import { FullContext } from '../context';
 import { NotFoundError, PermissionError } from '../errors';
 import { EntityModel } from '../models/models';
-import { get, isRelation } from '../models/utils';
+import { get, isGenerateAsField, isRelation, not } from '../models/utils';
 import { AliasGenerator, getColumnName, hash, ors } from '../resolvers/utils';
 import { PermissionAction, PermissionLink, PermissionStack } from './generate';
 
@@ -155,9 +155,9 @@ export const checkCanWrite = async (
   const query = ctx.knex.first();
   let linked = false;
 
-  for (const field of model.fields.filter(
-    (field) => field.generated || (action === 'CREATE' ? field.creatable : field.updatable),
-  )) {
+  for (const field of model.fields
+    .filter(not(isGenerateAsField))
+    .filter((field) => field.generated || (action === 'CREATE' ? field.creatable : field.updatable))) {
     const fieldPermissions = field[action === 'CREATE' ? 'creatable' : 'updatable'];
     const role = getRole(ctx);
     if (

package/src/resolvers/mutations.ts

@@ -4,7 +4,7 @@ import { Context } from '../context';
 import { ForbiddenError, GraphQLError } from '../errors';
 import { EntityField, EntityModel } from '../models/models';
 import { Entity, MutationContext, Trigger } from '../models/mutation-hook';
-import { get, isPrimitive, it, typeToField } from '../models/utils';
+import { get, isGenerateAsField, isPrimitive, it, not, typeToField } from '../models/utils';
 import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
 import { anyDateToLuxon } from '../utils';
 import { resolve } from './resolver';
@@ -87,7 +87,7 @@ export const createEntity = async (
     if (model.parent) {
       const rootInput = {};
       const childInput = { id };
-      for (const field of model.fields) {
+      for (const field of model.fields.filter(not(isGenerateAsField))) {
         const columnName = field.kind === 'relation' ? `${field.name}Id` : field.name;
         if (columnName in normalizedInput) {
           if (field.inherited) {
@@ -100,7 +100,12 @@ export const createEntity = async (
       await ctx.knex(model.parent).insert(rootInput);
       await ctx.knex(model.name).insert(childInput);
     } else {
-      await ctx.knex(model.name).insert(normalizedInput);
+      const insertData = { ...normalizedInput };
+      for (const field of model.fields.filter(isGenerateAsField)) {
+        const columnName = field.kind === 'relation' ? `${field.name}Id` : field.name;
+        delete insertData[columnName];
+      }
+      await ctx.knex(model.name).insert(insertData);
     }
     await createRevision(model, normalizedInput, ctx);
     await ctx.mutationHook?.({
@@ -555,7 +560,7 @@ export const createRevision = async (model: EntityModel, data: Entity, ctx: Muta
     }
     const childRevisionData = { id: revisionId };
 
-    for (const field of model.fields.filter(({ updatable }) => updatable)) {
+    for (const field of model.fields.filter(({ updatable }) => updatable).filter(not(isGenerateAsField))) {
       const col = field.kind === 'relation' ? `${field.name}Id` : field.name;
       let value;
       if (field.nonNull && (!(col in data) || col === undefined || col === null)) {
@@ -631,7 +636,7 @@ const doUpdate = async (model: EntityModel, currentEntity: Entity, update: Entit
   if (model.parent) {
     const rootInput = {};
     const childInput = {};
-    for (const field of model.fields) {
+    for (const field of model.fields.filter(not(isGenerateAsField))) {
       const columnName = field.kind === 'relation' ? `${field.name}Id` : field.name;
       if (columnName in update) {
         if (field.inherited) {
@@ -648,7 +653,12 @@ const doUpdate = async (model: EntityModel, currentEntity: Entity, update: Entit
       await ctx.knex(model.name).where({ id: currentEntity.id }).update(childInput);
     }
   } else {
-    await ctx.knex(model.name).where({ id: currentEntity.id }).update(update);
+    const updateData = { ...update };
+    for (const field of model.fields.filter(isGenerateAsField)) {
+      const columnName = field.kind === 'relation' ? `${field.name}Id` : field.name;
+      delete updateData[columnName];
+    }
+    await ctx.knex(model.name).where({ id: currentEntity.id }).update(updateData);
   }
   await createRevision(model, { ...currentEntity, ...update }, ctx);
 };

package/src/schema/generate.ts

@@ -1,6 +1,6 @@
 import { DefinitionNode, DocumentNode, GraphQLSchema, buildASTSchema, print } from 'graphql';
 import { Models } from '../models/models';
-import { isQueriableField, isRootModel, typeToField } from '../models/utils';
+import { isGenerateAsField, isQueriableField, isRootModel, not, typeToField } from '../models/utils';
 import { Field, document, enm, iface, input, object, scalar, union } from './utils';
 
 export const generateDefinitions = ({
@@ -135,6 +135,7 @@ export const generateDefinitions = ({
               `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 }
@@ -155,6 +156,7 @@ export const generateDefinitions = ({
               `Update${model.name}`,
               model.fields
                 .filter(({ updatable }) => updatable)
+                .filter(not(isGenerateAsField))
                 .map((field) =>
                   field.kind === 'relation'
                     ? { name: `${field.name}Id`, type: 'ID' }

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

@@ -0,0 +1,238 @@
+import { Kind } from 'graphql';
+import { generateDBModels } from '../../src/db/generate';
+import {
+  isGenerateAsField,
+  isStoredInDatabase,
+} from '../../src/models/utils';
+import { ModelDefinitions, Models } from '../../src/models';
+import type { EntityField } from '../../src/models/models';
+import { generateDefinitions } from '../../src/schema/generate';
+
+jest.mock('code-block-writer', () => {
+  const Writer = class {
+    private _out = '';
+
+    write(s: string) {
+      this._out += s;
+      return this;
+    }
+
+    blankLine() {
+      this._out += '\n';
+      return this;
+    }
+
+    newLine() {
+      this._out += '\n';
+      return this;
+    }
+
+    inlineBlock(fn: () => void) {
+      this._out += ' {\n';
+      fn();
+      this._out += '}';
+      return this;
+    }
+
+    toString() {
+      return this._out;
+    }
+  };
+  return { __esModule: true, default: { default: Writer } };
+});
+
+describe('generateAs helpers', () => {
+  describe('isGenerateAsField', () => {
+    it('returns false when field.generateAs is undefined', () => {
+      const field: EntityField = { name: 'price', type: 'Float' };
+      expect(isGenerateAsField(field)).toBe(false);
+    });
+
+    it('returns true when field has generateAs with type expression', () => {
+      const field: EntityField = {
+        name: 'total',
+        type: 'Float',
+        generateAs: { expression: 'price * quantity', type: 'expression' },
+      };
+      expect(isGenerateAsField(field)).toBe(true);
+    });
+
+    it('returns true when field has generateAs with type stored', () => {
+      const field: EntityField = {
+        name: 'total',
+        type: 'Float',
+        generateAs: { expression: 'price * quantity', type: 'stored' },
+      };
+      expect(isGenerateAsField(field)).toBe(true);
+    });
+
+    it('returns true when field has generateAs with type virtual', () => {
+      const field: EntityField = {
+        name: 'total',
+        type: 'Float',
+        generateAs: { expression: 'price * quantity', type: 'virtual' },
+      };
+      expect(isGenerateAsField(field)).toBe(true);
+    });
+  });
+
+  describe('isStoredInDatabase', () => {
+    it('returns true when field has no generateAs (normal column)', () => {
+      const field: EntityField = { name: 'price', type: 'Float' };
+      expect(isStoredInDatabase(field)).toBe(true);
+    });
+
+    it('returns false when field has generateAs.type expression', () => {
+      const field: EntityField = {
+        name: 'total',
+        type: 'Float',
+        generateAs: { expression: 'price * quantity', type: 'expression' },
+      };
+      expect(isStoredInDatabase(field)).toBe(false);
+    });
+
+    it('returns true when field has generateAs.type stored', () => {
+      const field: EntityField = {
+        name: 'total',
+        type: 'Float',
+        generateAs: { expression: 'price * quantity', type: 'stored' },
+      };
+      expect(isStoredInDatabase(field)).toBe(true);
+    });
+
+    it('returns true when field has generateAs.type virtual', () => {
+      const field: EntityField = {
+        name: 'total',
+        type: 'Float',
+        generateAs: { expression: 'price * quantity', type: 'virtual' },
+      };
+      expect(isStoredInDatabase(field)).toBe(true);
+    });
+  });
+});
+
+describe('generateDBModels', () => {
+  const productModelDefinitions: ModelDefinitions = [
+    {
+      kind: 'entity',
+      name: 'Product',
+      fields: [
+        { name: 'price', type: 'Float' },
+        { name: 'quantity', type: 'Int' },
+        {
+          name: 'totalExpression',
+          type: 'Float',
+          generateAs: { expression: 'price * quantity', type: 'expression' },
+        },
+        {
+          name: 'totalStored',
+          type: 'Float',
+          generateAs: { expression: 'price * quantity', type: 'stored' },
+        },
+      ],
+    },
+  ];
+
+  it('entity type includes normal and stored columns but not expression-only fields', () => {
+    const models = new Models(productModelDefinitions);
+    const output = generateDBModels(models, 'luxon');
+
+    expect(output).toContain("'price'");
+    expect(output).toContain("'quantity'");
+    expect(output).toContain("'totalStored'");
+    expect(output).not.toContain("'totalExpression'");
+  });
+
+  it('Initializer includes only user-settable fields (excludes all generateAs)', () => {
+    const models = new Models(productModelDefinitions);
+    const output = generateDBModels(models, 'luxon');
+
+    const start = output.indexOf('export type ProductInitializer');
+    const end = output.indexOf('export type', start + 1);
+    const block = end === -1 ? output.slice(start) : output.slice(start, end);
+    expect(block).toContain("'price'");
+    expect(block).toContain("'quantity'");
+    expect(block).not.toContain("'totalExpression'");
+    expect(block).not.toContain("'totalStored'");
+  });
+
+  it('Mutator includes only user-settable fields (excludes all generateAs)', () => {
+    const models = new Models(productModelDefinitions);
+    const output = generateDBModels(models, 'luxon');
+
+    const start = output.indexOf('export type ProductMutator');
+    const end = output.indexOf('export type', start + 1);
+    const block = end === -1 ? output.slice(start) : output.slice(start, end);
+    expect(block).toContain("'price'");
+    expect(block).toContain("'quantity'");
+    expect(block).not.toContain("'totalExpression'");
+    expect(block).not.toContain("'totalStored'");
+  });
+
+  it('Seed type excludes all generateAs fields', () => {
+    const models = new Models(productModelDefinitions);
+    const output = generateDBModels(models, 'luxon');
+
+    const start = output.indexOf('export type ProductSeed');
+    const end = output.indexOf('export type', start + 1);
+    const block = end === -1 ? output.slice(start) : output.slice(start, end);
+    expect(block).toContain("'price'");
+    expect(block).toContain("'quantity'");
+    expect(block).not.toContain("'totalExpression'");
+    expect(block).not.toContain("'totalStored'");
+  });
+});
+
+describe('generateDefinitions Create/Update inputs', () => {
+  const itemModelDefinitions: ModelDefinitions = [
+    { kind: 'entity', name: 'User', fields: [{ name: 'id', type: 'ID' }] },
+    {
+      kind: 'entity',
+      name: 'Item',
+      creatable: true,
+      updatable: true,
+      fields: [
+        { name: 'name', type: 'String', creatable: true, updatable: true },
+        {
+          name: 'computed',
+          type: 'Int',
+          creatable: true,
+          updatable: true,
+          generateAs: { expression: '1', type: 'expression' },
+        },
+      ],
+    },
+  ];
+
+  it('Create input does not include generateAs fields', () => {
+    const models = new Models(itemModelDefinitions);
+    const definitions = generateDefinitions(models);
+
+    const createInput = definitions.find(
+      (d) => d.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION && d.name?.value === 'CreateItem',
+    );
+    expect(createInput).toBeDefined();
+    expect(createInput!.kind).toBe(Kind.INPUT_OBJECT_TYPE_DEFINITION);
+
+    const fields = (createInput as { fields?: readonly { name: { value: string } }[] }).fields ?? [];
+    const fieldNames = fields.map((f) => f.name.value);
+    expect(fieldNames).toContain('name');
+    expect(fieldNames).not.toContain('computed');
+  });
+
+  it('Update input does not include generateAs fields', () => {
+    const models = new Models(itemModelDefinitions);
+    const definitions = generateDefinitions(models);
+
+    const updateInput = definitions.find(
+      (d) => d.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION && d.name?.value === 'UpdateItem',
+    );
+    expect(updateInput).toBeDefined();
+    expect(updateInput!.kind).toBe(Kind.INPUT_OBJECT_TYPE_DEFINITION);
+
+    const fields = (updateInput as { fields?: readonly { name: { value: string } }[] }).fields ?? [];
+    const fieldNames = fields.map((f) => f.name.value);
+    expect(fieldNames).toContain('name');
+    expect(fieldNames).not.toContain('computed');
+  });
+});