@smartive/graphql-magic 3.1.0 → 4.0.0

package/src/resolvers/mutations.ts

@@ -1,10 +1,11 @@
 import { GraphQLResolveInfo } from 'graphql';
+import { DateTime } from 'luxon';
 import { v4 as uuid } from 'uuid';
 import { Context, FullContext } from '../context';
 import { ForbiddenError, GraphQLError } from '../errors';
-import { Entity, Model, ModelField, isEnumList } from '../models';
+import { Entity, Model, ModelField } from '../models';
 import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
-import { get, it, summonByName, typeToField } from '../utils';
+import { get, isEnumList, it, summonByName, typeToField } from '../utils';
 import { resolve } from './resolver';
 import { AliasGenerator } from './utils';
 
@@ -113,10 +114,10 @@ const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolea
     if (!(currentModel.name in toDelete)) {
       toDelete[currentModel.name] = {};
     }
-    if (entity.id in toDelete[currentModel.name]) {
+    if ((entity.id as string) in toDelete[currentModel.name]) {
       return;
     }
-    toDelete[currentModel.name][entity.id] = entity[currentModel.displayField || 'id'] || entity.id;
+    toDelete[currentModel.name][entity.id as string] = (entity[currentModel.displayField || 'id'] || entity.id) as string;
 
     if (!dryRun) {
       const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user.id };
@@ -275,8 +276,8 @@ const createRevision = async (model: Model, data: Entity, ctx: Context) => {
       revisionData.deleted = data.deleted || false;
     }
 
-    for (const { name, relation, nonNull, ...field } of model.fields.filter(({ updatable }) => updatable)) {
-      const col = relation ? `${name}Id` : name;
+    for (const { 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');
       } else {
@@ -301,16 +302,16 @@ const sanitize = (ctx: FullContext, model: Model, data: Entity) => {
     }
 
     if (isEndOfDay(field) && data[key]) {
-      data[key] = data[key].endOf('day');
+      data[key] = (data[key] as DateTime).endOf('day');
       continue;
     }
 
     if (isEnumList(ctx.rawModels, field) && Array.isArray(data[key])) {
-      data[key] = `{${data[key].join(',')}}`;
+      data[key] = `{${(data[key] as string[]).join(',')}}`;
       continue;
     }
   }
 };
 
 const isEndOfDay = (field?: ModelField) =>
-  field?.endOfDay === true && field?.dateTimeType === 'date' && field?.type === 'DateTime';
+  field.type === 'DateTime' && field?.endOfDay === true && field?.dateTimeType === 'date' && field?.type === 'DateTime';

package/src/resolvers/node.ts

@@ -8,8 +8,8 @@ import type {
 } from 'graphql';
 
 import { FullContext } from '../context';
-import { isJsonObjectModel, Model } from '../models';
-import { get, summonByKey, summonByName } from '../utils';
+import { Model } from '../models';
+import { get, isRawObjectModel, summonByKey, summonByName } from '../utils';
 import {
   getFragmentTypeName,
   getNameOrAlias,
@@ -113,7 +113,7 @@ export const getSimpleFields = (node: ResolverNode) => {
       return true;
     }
 
-    return node.model.fields.some(({ json, name }) => json && name === selection.name.value);
+    return node.model.fields.some(({ type, name }) => type === 'json' && name === selection.name.value);
   });
 };
 
@@ -150,13 +150,13 @@ export const getJoins = (node: ResolverNode, toMany: boolean) => {
 
     const typeName = getTypeName(fieldDefinition.type);
 
-    if (isJsonObjectModel(summonByName(ctx.rawModels, typeName))) {
+    if (isRawObjectModel(summonByName(ctx.rawModels, typeName))) {
       continue;
     }
 
     const baseModel = summonByName(ctx.models, baseTypeDefinition.name.value);
 
-    let foreignKey;
+    let foreignKey: string | undefined;
     if (toMany) {
       const reverseRelation = baseModel.reverseRelationsByName[fieldName];
       if (!reverseRelation) {
@@ -165,7 +165,7 @@ export const getJoins = (node: ResolverNode, toMany: boolean) => {
       foreignKey = reverseRelation.foreignKey;
     } else {
       const modelField = baseModel.fieldsByName[fieldName];
-      if (!modelField || modelField.raw) {
+      if (modelField?.type !== 'relation') {
         continue;
       }
       foreignKey = modelField.foreignKey;

package/src/resolvers/resolver.ts

@@ -115,11 +115,11 @@ 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.relation || field.raw) {
+          if (!field || field.type === 'relation' || field.type === 'raw') {
             return false;
           }
 
-          if (field.queriableBy && !field.queriableBy.includes(node.ctx.user.role)) {
+          if (typeof field.queriable === 'object' && !field.queriable.roles?.includes(node.ctx.user.role)) {
             throw new PermissionError(
               'READ',
               `${node.model.name}'s field "${field.name}"`,

package/src/utils.ts

@@ -4,7 +4,24 @@ import camelCase from 'lodash/camelCase';
 import lodashGet from 'lodash/get';
 import kebabCase from 'lodash/kebabCase';
 import startCase from 'lodash/startCase';
-import { Model, Models, ObjectModel, RawModels, Relation, ReverseRelation, isObjectModel } from './models';
+import {
+  BooleanField,
+  DateTimeField,
+  EnumModel,
+  Model,
+  ModelField,
+  Models,
+  ObjectModel,
+  RawEnumModel,
+  RawField,
+  RawModel,
+  RawModels,
+  RawObjectModel,
+  Relation,
+  RelationField,
+  ReverseRelation,
+  ScalarModel,
+} from './models';
 
 const isNotFalsy = <T>(v: T | null | undefined | false): v is T => typeof v !== 'undefined' && v !== null && v !== false;
 
@@ -26,6 +43,59 @@ export const getModelLabel = (model: Model) => getLabel(model.name);
 
 export const getLabel = (s: string) => startCase(camelCase(s));
 
+export const isObjectModel = (model: RawModel): model is ObjectModel => model.type === 'object';
+
+export const isEnumModel = (model: RawModel): model is EnumModel => model.type === 'enum';
+
+export const isRawEnumModel = (model: RawModel): model is RawEnumModel => model.type === 'raw-enum';
+
+export const isScalarModel = (model: RawModel): model is ScalarModel => model.type === 'scalar';
+
+export const isRawObjectModel = (model: RawModel): model is RawObjectModel => model.type === 'raw';
+
+export const isEnumList = (models: RawModels, field: ModelField) =>
+  field?.list === true && models.find(({ name }) => name === field.type)?.type === 'enum';
+
+export const and =
+  (...predicates: ((field: ModelField) => boolean)[]) =>
+  (field: ModelField) =>
+    predicates.every((predicate) => predicate(field));
+
+export const not = (predicate: (field: ModelField) => boolean) => (field: ModelField) => !predicate(field);
+
+export const isRelation = (field: ModelField): field is RelationField => field.type === 'relation';
+
+export const isToOneRelation = (field: ModelField): field is RelationField => isRelation(field) && !!field.toOne;
+
+export const isQueriableField = ({ queriable }: ModelField) => queriable !== false;
+
+export const isRaw = (field: ModelField): field is RawField => field.type === 'raw';
+
+export const isVisible = ({ hidden }: ModelField) => hidden !== true;
+
+export const isSimpleField = and(not(isRelation), not(isRaw));
+
+export const isUpdatable = ({ updatable }: ModelField) => !!updatable;
+
+export const isCreatable = ({ creatable }: ModelField) => !!creatable;
+
+export const isQueriableBy = (role: string) => (field: ModelField) =>
+  field.queriable !== false && (field.queriable == true || !field.queriable.roles || field.queriable.roles.includes(role));
+
+export const isUpdatableBy = (role: string) => (field: ModelField) =>
+  field.updatable && (field.updatable === true || !field.updatable.roles || field.updatable.roles.includes(role));
+
+export const isCreatableBy = (role: string) => (field: ModelField) =>
+  field.creatable && (field.creatable === true || !field.creatable.roles || field.creatable.roles.includes(role));
+
+export const actionableRelations = (model: Model, action: 'create' | 'update' | 'filter') =>
+  model.fields
+    .filter(isRelation)
+    .filter(
+      (field) =>
+        field[`${action === 'filter' ? action : action.slice(0, -1)}able` as 'filterable' | 'creatable' | 'updatable']
+    );
+
 export const getModels = (rawModels: RawModels): Models => {
   const models: Models = rawModels.filter(isObjectModel).map((model) => {
     const objectModel: Model = {
@@ -35,60 +105,86 @@ export const getModels = (rawModels: RawModels): Models => {
       relationsByName: {},
       reverseRelations: [],
       reverseRelationsByName: {},
-      fields: [
-        { name: 'id', type: 'ID', nonNull: true, unique: true, primary: true, generated: true },
-        ...model.fields,
-        ...(model.creatable
-          ? [
-              { name: 'createdAt', type: 'DateTime', nonNull: !model.nonStrict, orderable: true, generated: true },
-              {
-                name: 'createdBy',
-                type: 'User',
-                relation: true,
-                nonNull: !model.nonStrict,
-                reverse: `created${getModelPlural(model)}`,
-                generated: true,
-              },
-            ]
-          : []),
-        ...(model.updatable
-          ? [
-              { name: 'updatedAt', type: 'DateTime', nonNull: !model.nonStrict, orderable: true, generated: true },
-              {
-                name: 'updatedBy',
-                type: 'User',
-                relation: true,
-                nonNull: !model.nonStrict,
-                reverse: `updated${getModelPlural(model)}`,
-                generated: true,
-              },
-            ]
-          : []),
-        ...(model.deletable
-          ? [
-              {
-                name: 'deleted',
-                type: 'Boolean',
-                nonNull: true,
-                default: false,
-                filterable: true,
-                defaultFilter: false,
-                generated: true,
-              },
-              { name: 'deletedAt', type: 'DateTime', orderable: true, generated: true },
-              {
-                name: 'deletedBy',
-                type: 'User',
-                relation: true,
-                reverse: `deleted${getModelPlural(model)}`,
-                generated: true,
-              },
-            ]
-          : []),
-      ].map(({ foreignKey, ...field }) => ({
+      fields: (
+        [
+          { name: 'id', type: 'ID', nonNull: true, unique: true, primary: true, generated: true },
+          ...model.fields,
+          ...(model.creatable
+            ? [
+                {
+                  name: 'createdAt',
+                  type: 'DateTime',
+
+                  nonNull: true,
+                  orderable: true,
+                  generated: true,
+                  ...(typeof model.creatable === 'object' && model.creatable.createdAt),
+                } satisfies DateTimeField,
+                {
+                  name: 'createdBy',
+                  type: 'relation',
+                  typeName: 'User',
+                  nonNull: true,
+                  reverse: `created${getModelPlural(model)}`,
+                  generated: true,
+                  ...(typeof model.creatable === 'object' && model.creatable.createdBy),
+                } satisfies RelationField,
+              ]
+            : []),
+          ...(model.updatable
+            ? [
+                {
+                  name: 'updatedAt',
+                  type: 'DateTime',
+                  nonNull: true,
+                  orderable: true,
+                  generated: true,
+                  ...(typeof model.updatable === 'object' && model.updatable.updatedAt),
+                } satisfies DateTimeField,
+                {
+                  name: 'updatedBy',
+                  type: 'relation',
+                  typeName: 'User',
+                  nonNull: true,
+                  reverse: `updated${getModelPlural(model)}`,
+                  generated: true,
+                  ...(typeof model.updatable === 'object' && model.updatable.updatedBy),
+                } satisfies RelationField,
+              ]
+            : []),
+          ...(model.deletable
+            ? [
+                {
+                  name: 'deleted',
+                  type: 'Boolean',
+                  nonNull: true,
+                  default: false,
+                  filterable: { default: false },
+                  generated: true,
+                  ...(typeof model.deletable === 'object' && model.deletable.deleted),
+                } satisfies BooleanField,
+                {
+                  name: 'deletedAt',
+                  type: 'DateTime',
+                  orderable: true,
+                  generated: true,
+                  ...(typeof model.deletable === 'object' && model.deletable.deletedAt),
+                } satisfies DateTimeField,
+                {
+                  name: 'deletedBy',
+                  type: 'relation',
+                  typeName: 'User',
+                  reverse: `deleted${getModelPlural(model)}`,
+                  generated: true,
+                  ...(typeof model.deletable === 'object' && model.deletable.deletedBy),
+                } satisfies RelationField,
+              ]
+            : []),
+        ] satisfies ModelField[]
+      ).map((field: ModelField) => ({
         ...field,
-        ...(field.relation && {
-          foreignKey: foreignKey || `${field.name}Id`,
+        ...(field.type === 'relation' && {
+          foreignKey: field.foreignKey || `${field.name}Id`,
         }),
       })),
     };
@@ -101,13 +197,18 @@ export const getModels = (rawModels: RawModels): Models => {
   });
 
   for (const model of models) {
-    for (const field of model.fields.filter(({ relation }) => relation)) {
-      const fieldModel = summonByName(models, field.type);
+    for (const field of model.fields) {
+      if (field.type !== 'relation') {
+        continue;
+      }
+
+      const fieldModel = summonByName(models, field.typeName);
 
       const reverseRelation: ReverseRelation = {
+        type: 'relation',
         name: field.reverse || (field.toOne ? typeToField(model.name) : getModelPluralField(model)),
         foreignKey: get(field, 'foreignKey'),
-        type: model.name,
+        typeName: model.name,
         toOne: !!field.toOne,
         fieldModel,
         field,

package/tests/utils/models.ts

@@ -16,7 +16,7 @@ export const rawModels: RawModels = [
 
   {
     name: 'SomeRawObject',
-    type: 'raw-object',
+    type: 'raw',
     fields: [{ name: 'field', type: 'String' }],
   },
 
@@ -30,7 +30,8 @@ export const rawModels: RawModels = [
       },
       {
         name: 'role',
-        type: 'Role',
+        type: 'enum',
+        typeName: 'Role',
       },
     ],
   },
@@ -47,11 +48,11 @@ export const rawModels: RawModels = [
         orderable: true,
       },
       {
-        type: 'AnotherObject',
+        type: 'relation',
+        typeName: 'AnotherObject',
         name: 'myself',
         toOne: true,
         reverse: 'self',
-        relation: true
       }
     ],
   },
@@ -73,8 +74,8 @@ export const rawModels: RawModels = [
       },
       {
         name: 'another',
-        type: 'AnotherObject',
-        relation: true,
+        type: 'relation',
+        typeName: 'AnotherObject',
         filterable: true,
         updatable: true,
         nonNull: true,