@smartive/graphql-magic 5.1.2 → 7.0.0

package/src/resolvers/mutations.ts

@@ -3,8 +3,9 @@ import { DateTime } from 'luxon';
 import { v4 as uuid } from 'uuid';
 import { Context, FullContext } from '../context';
 import { ForbiddenError, GraphQLError } from '../errors';
-import { Entity, Model, ModelField } from '../models/models';
-import { get, isEnumList, it, summonByName, typeToField } from '../models/utils';
+import { Model, ModelField } from '../models/models';
+import { Entity, FullEntity } from '../models/mutation-hook';
+import { get, isEnumList, isPrimitive, it, summonByName, typeToField } from '../models/utils';
 import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
 import { resolve } from './resolver';
 import { AliasGenerator } from './utils';
@@ -106,7 +107,7 @@ const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolea
   const mutations: Callbacks = [];
   const afterHooks: Callbacks = [];
 
-  const deleteCascade = async (currentModel: Model, entity: Entity) => {
+  const deleteCascade = async (currentModel: Model, entity: FullEntity) => {
     if (entity.deleted) {
       return;
     }
@@ -220,7 +221,7 @@ const restore = async (model: Model, { where }: { where: any }, ctx: FullContext
   const mutations: Callbacks = [];
   const afterHooks: Callbacks = [];
 
-  const restoreCascade = async (currentModel: Model, relatedEntity: Entity) => {
+  const restoreCascade = async (currentModel: Model, relatedEntity: FullEntity) => {
     if (!relatedEntity.deleted || !relatedEntity.deletedAt || !relatedEntity.deletedAt.equals(entity.deletedAt)) {
       return;
     }
@@ -265,7 +266,7 @@ const restore = async (model: Model, { where }: { where: any }, ctx: FullContext
 
 const createRevision = async (model: Model, data: Entity, ctx: Context) => {
   if (model.updatable) {
-    const revisionData = {
+    const revisionData: Entity = {
       id: uuid(),
       [`${typeToField(model.name)}Id`]: data.id,
       createdAt: ctx.now,
@@ -276,10 +277,10 @@ const createRevision = async (model: Model, data: Entity, ctx: Context) => {
       revisionData.deleted = data.deleted || false;
     }
 
-    for (const { type, name, nonNull, ...field } of model.fields.filter(({ updatable }) => updatable)) {
+    for (const { kind: type, name, nonNull, ...field } of model.fields.filter(({ updatable }) => updatable)) {
       const col = type === 'relation' ? `${name}Id` : name;
       if (nonNull && (!(col in data) || col === undefined || col === null)) {
-        revisionData[col] = get(field, 'default');
+        revisionData[col] = get(field, 'defaultValue');
       } else {
         revisionData[col] = data[col];
       }
@@ -314,4 +315,4 @@ const sanitize = (ctx: FullContext, model: Model, data: Entity) => {
 };
 
 const isEndOfDay = (field?: ModelField) =>
-  field.type === 'DateTime' && field?.endOfDay === true && field?.dateTimeType === 'date' && field?.type === 'DateTime';
+  isPrimitive(field) && field.type === 'DateTime' && field?.endOfDay === true && field?.dateTimeType === 'date';

package/src/resolvers/node.ts

@@ -113,7 +113,7 @@ export const getSimpleFields = (node: ResolverNode) => {
       return true;
     }
 
-    return node.model.fields.some(({ type, name }) => type === 'json' && name === selection.name.value);
+    return node.model.fields.some(({ kind: type, name }) => type === 'json' && name === selection.name.value);
   });
 };
 
@@ -165,7 +165,7 @@ export const getJoins = (node: ResolverNode, toMany: boolean) => {
       foreignKey = reverseRelation.foreignKey;
     } else {
       const modelField = baseModel.fieldsByName[fieldName];
-      if (modelField?.type !== 'relation') {
+      if (modelField?.kind !== 'relation') {
         continue;
       }
       foreignKey = modelField.foreignKey;

package/src/resolvers/resolver.ts

@@ -115,7 +115,7 @@ const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins: Joins
         .filter((n) => {
           const field = node.model.fields.find(({ name }) => name === n.name.value);
 
-          if (!field || field.type === 'relation' || field.type === 'raw') {
+          if (!field || field.kind === 'relation' || field.kind === 'raw') {
             return false;
           }
 

package/src/schema/generate.ts

@@ -1,4 +1,4 @@
-import { buildASTSchema, DefinitionNode, DocumentNode, GraphQLSchema, print } from 'graphql';
+import { DefinitionNode, DocumentNode, GraphQLSchema, buildASTSchema, print } from 'graphql';
 import flatMap from 'lodash/flatMap';
 import { RawModels } from '../models/models';
 import {
@@ -12,7 +12,7 @@ import {
   isScalarModel,
   typeToField,
 } from '../models/utils';
-import { document, enm, Field, input, object, scalar } from './utils';
+import { Field, document, enm, input, object, scalar } from './utils';
 
 export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
   const models = getModels(rawModels);
@@ -30,17 +30,13 @@ export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
     ...rawModels
       .filter(isRawObjectModel)
       .filter((model) =>
-        models.some(
-          (m) => m.creatable && m.fields.some((f) => f.creatable && f.type === 'json' && f.typeName === model.name)
-        )
+        models.some((m) => m.creatable && m.fields.some((f) => f.creatable && f.kind === 'json' && f.type === model.name))
       )
       .map((model) => input(`Create${model.name}`, model.fields)),
     ...rawModels
       .filter(isRawObjectModel)
       .filter((model) =>
-        models.some(
-          (m) => m.creatable && m.fields.some((f) => f.creatable && f.type === 'json' && f.typeName === model.name)
-        )
+        models.some((m) => m.creatable && m.fields.some((f) => f.creatable && f.kind === 'json' && f.type === model.name))
       )
       .map((model) => input(`Update${model.name}`, model.fields)),
 
@@ -52,10 +48,7 @@ export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
             [
               ...model.fields.filter(isQueriableField).map((field) => ({
                 ...field,
-                type:
-                  field.type === 'relation' || field.type === 'enum' || field.type === 'raw' || field.type === 'json'
-                    ? field.typeName
-                    : field.type,
+                type: field.type,
                 args: [...(field.args || [])],
                 directives: field.directives,
               })),
@@ -79,33 +72,33 @@ export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
           ),
           input(`${model.name}Where`, [
             ...model.fields
-              .filter(({ type, unique, filterable }) => (unique || filterable) && type !== 'relation')
-              .map(({ type, name, filterable }) => ({
-                name,
-                type,
+              .filter(({ kind, unique, filterable }) => (unique || filterable) && kind !== 'relation')
+              .map((field) => ({
+                name: field.name,
+                type: field.type,
                 list: true,
-                default: typeof filterable === 'object' ? filterable.default : undefined,
+                default: typeof field.filterable === 'object' ? field.filterable.default : undefined,
               })),
             ...flatMap(
               model.fields.filter(({ comparable }) => comparable),
-              ({ name, type }) => [
-                { name: `${name}_GT`, type },
-                { name: `${name}_GTE`, type },
-                { name: `${name}_LT`, type },
-                { name: `${name}_LTE`, type },
+              (field) => [
+                { name: `${field.name}_GT`, type: field.type },
+                { name: `${field.name}_GTE`, type: field.type },
+                { name: `${field.name}_LT`, type: field.type },
+                { name: `${field.name}_LTE`, type: field.type },
               ]
             ),
             ...model.fields
               .filter(isRelation)
               .filter(({ filterable }) => filterable)
-              .map(({ name, typeName }) => ({
+              .map(({ name, type }) => ({
                 name,
-                type: `${typeName}Where`,
+                type: `${type}Where`,
               })),
           ]),
           input(
             `${model.name}WhereUnique`,
-            model.fields.filter(({ unique }) => unique).map(({ name, type }) => ({ name, type }))
+            model.fields.filter(({ unique }) => unique).map((field) => ({ name: field.name, type: field.type }))
           ),
           ...(model.fields.some(({ orderable }) => orderable)
             ? [
@@ -123,19 +116,14 @@ export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
               `Create${model.name}`,
               model.fields
                 .filter(({ creatable }) => creatable)
-                .map(({ name, nonNull, list, default: defaultValue, ...field }) =>
-                  field.type === 'relation'
-                    ? { name: `${name}Id`, type: 'ID', nonNull }
+                .map((field) =>
+                  field.kind === 'relation'
+                    ? { name: `${field.name}Id`, type: 'ID', nonNull: field.nonNull }
                     : {
-                        name,
-                        type:
-                          field.type === 'enum'
-                            ? field.typeName
-                            : field.type === 'json'
-                            ? `Create${field.typeName}`
-                            : field.type,
-                        list,
-                        nonNull: nonNull && defaultValue === undefined,
+                        name: field.name,
+                        type: field.kind === 'json' ? `Create${field.type}` : field.type,
+                        list: field.list,
+                        nonNull: field.nonNull && field.defaultValue === undefined,
                       }
                 )
             )
@@ -148,18 +136,13 @@ export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
               `Update${model.name}`,
               model.fields
                 .filter(({ updatable }) => updatable)
-                .map(({ name, list, ...field }) =>
-                  field.type === 'relation'
-                    ? { name: `${name}Id`, type: 'ID' }
+                .map((field) =>
+                  field.kind === 'relation'
+                    ? { name: `${field.name}Id`, type: 'ID' }
                     : {
-                        name,
-                        type:
-                          field.type === 'enum'
-                            ? field.typeName
-                            : field.type === 'json'
-                            ? `Update${field.typeName}`
-                            : field.type,
-                        list,
+                        name: field.name,
+                        type: field.kind === 'json' ? `Update${field.type}` : field.type,
+                        list: field.list,
                       }
                 )
             )

package/src/schema/utils.ts

@@ -30,7 +30,7 @@ export type Field = {
   description?: string;
   list?: boolean;
   nonNull?: boolean;
-  default?: Value;
+  defaultValue?: Value;
   args?: Field[];
   directives?: Directive[];
 };
@@ -90,7 +90,7 @@ export const inputValues = (fields: Field[]): InputValueDefinitionNode[] =>
       kind: 'InputValueDefinition',
       name: name(field.name),
       type: fieldType(field),
-      defaultValue: field.default === undefined ? undefined : value(field.default),
+      defaultValue: field.defaultValue === undefined ? undefined : value(field.defaultValue),
       directives: directives(field.directives),
     })
   );
@@ -105,7 +105,7 @@ export const fields = (fields: Field[]): FieldDefinitionNode[] =>
         kind: 'InputValueDefinition',
         name: name(arg.name),
         type: fieldType(arg),
-        defaultValue: arg.default === undefined ? undefined : value(arg.default),
+        defaultValue: arg.defaultValue === undefined ? undefined : value(arg.defaultValue),
       })),
       directives: directives(field.directives),
     })

package/tests/unit/__snapshots__/generate.spec.ts.snap

@@ -19,7 +19,7 @@ input AnotherObjectOrderBy {
 
 input AnotherObjectWhere {
   id: [ID!]
-  deleted: [Boolean!] = false
+  deleted: [Boolean!]
 }
 
 input AnotherObjectWhereUnique {
@@ -88,7 +88,7 @@ input SomeObjectOrderBy {
 
 input SomeObjectWhere {
   id: [ID!]
-  deleted: [Boolean!] = false
+  deleted: [Boolean!]
   another: AnotherObjectWhere
 }
 

package/tests/unit/resolve.spec.ts

@@ -23,6 +23,7 @@ const test = async (operationName: string, query: string, variables: object, res
 
   const user = await knexInstance('User').where({ id: 1 }).first();
   const result = await execute({
+    req: null as any,
     knex: knexInstance,
     locale: 'en',
     locales: ['en'],

package/tests/utils/models.ts

@@ -5,23 +5,23 @@ import { generatePermissions, PermissionsConfig } from '../../src/permissions/ge
 export const rawModels: RawModels = [
   {
     name: 'SomeEnum',
-    type: 'enum',
+    kind: 'enum',
     values: ['A', 'B', 'C'],
   },
   {
     name: 'Role',
-    type: 'enum',
+    kind: 'enum',
     values: ['ADMIN', 'USER'],
   },
 
   {
     name: 'SomeRawObject',
-    type: 'raw',
+    kind: 'raw',
     fields: [{ name: 'field', type: 'String' }],
   },
 
   {
-    type: 'object',
+    kind: 'object',
     name: 'User',
     fields: [
       {
@@ -30,13 +30,13 @@ export const rawModels: RawModels = [
       },
       {
         name: 'role',
-        type: 'enum',
-        typeName: 'Role',
+        kind: 'enum',
+        type: 'Role',
       },
     ],
   },
   {
-    type: 'object',
+    kind: 'object',
     name: 'AnotherObject',
     listQueriable: true,
     deletable: true,
@@ -48,8 +48,8 @@ export const rawModels: RawModels = [
         orderable: true,
       },
       {
-        type: 'relation',
-        typeName: 'AnotherObject',
+        kind: 'relation',
+        type: 'AnotherObject',
         name: 'myself',
         toOne: true,
         reverse: 'self',
@@ -57,7 +57,7 @@ export const rawModels: RawModels = [
     ],
   },
   {
-    type: 'object',
+    kind: 'object',
     name: 'SomeObject',
     plural: 'ManyObjects',
     description: 'An object',
@@ -74,8 +74,8 @@ export const rawModels: RawModels = [
       },
       {
         name: 'another',
-        type: 'relation',
-        typeName: 'AnotherObject',
+        kind: 'relation',
+        type: 'AnotherObject',
         filterable: true,
         updatable: true,
         nonNull: true,

package/tests/utils/server.ts

@@ -58,6 +58,7 @@ export const withServer = async (
           });
       });
       const result = await execute({
+        req,
         knex,
         locale: 'en',
         locales: ['en'],