@smartive/graphql-magic 3.1.0 → 5.0.0

package/src/models/utils.ts

@@ -0,0 +1,288 @@
+import assert from 'assert';
+import { pluralize } from 'inflection';
+import camelCase from 'lodash/camelCase';
+import lodashGet from 'lodash/get';
+import kebabCase from 'lodash/kebabCase';
+import startCase from 'lodash/startCase';
+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;
+
+export const merge = <T>(objects: ({ [name: string]: T } | undefined | false)[] | undefined): { [name: string]: T } =>
+  (objects || []).filter(isNotFalsy).reduce((i, acc) => ({ ...acc, ...i }), {});
+
+// Target -> target
+export const typeToField = (type: string) => type.substr(0, 1).toLowerCase() + type.substr(1);
+
+export const getModelPlural = (model: ObjectModel | Model) => model.plural || pluralize(model.name);
+
+export const getModelPluralField = (model: Model) => typeToField(getModelPlural(model));
+
+export const getModelSlug = (model: Model) => kebabCase(getModelPlural(model));
+
+export const getModelLabelPlural = (model: Model) => getLabel(getModelPlural(model));
+
+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 = {
+      ...model,
+      fieldsByName: {},
+      relations: [],
+      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: 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.type === 'relation' && {
+          foreignKey: field.foreignKey || `${field.name}Id`,
+        }),
+      })),
+    };
+
+    for (const field of objectModel.fields) {
+      objectModel.fieldsByName[field.name] = field;
+    }
+
+    return objectModel;
+  });
+
+  for (const model of models) {
+    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'),
+        typeName: model.name,
+        toOne: !!field.toOne,
+        fieldModel,
+        field,
+        model,
+      };
+
+      const relation: Relation = {
+        field,
+        model: fieldModel,
+        reverseRelation,
+      };
+      model.relations.push(relation);
+      model.relationsByName[relation.field.name] = relation;
+
+      fieldModel.reverseRelations.push(reverseRelation);
+
+      fieldModel.reverseRelationsByName[reverseRelation.name] = reverseRelation;
+    }
+  }
+
+  return models;
+};
+
+export const summonByName = <T extends { name: string }>(array: T[], value: string) => summonByKey(array, 'name', value);
+
+export const summonByKey = <T>(array: readonly T[] | undefined, key: string, value: unknown) =>
+  summon(array, (element: T) => lodashGet(element, key) === value, `No element found with ${key} ${value}`);
+
+export const summon = <T>(array: readonly T[] | undefined, cb: Parameters<T[]['find']>[1], errorMessage?: string) => {
+  if (array === undefined) {
+    console.trace();
+    throw new Error('Base array is not defined.');
+  }
+  const result = array.find(cb);
+  if (result === undefined) {
+    console.trace();
+    throw new Error(errorMessage || 'Element not found.');
+  }
+  return result;
+};
+
+type ForSure<T> = T extends undefined | null ? never : T;
+
+export const it = <T>(object: T | null | undefined): ForSure<T> => {
+  if (object === undefined || object === null) {
+    console.trace();
+    throw new Error('Base object is not defined.');
+  }
+
+  return object as ForSure<T>;
+};
+
+export const get = <T, U extends keyof ForSure<T>>(object: T | null | undefined, key: U): ForSure<ForSure<T>[U]> => {
+  const value = it(object)[key];
+  if (value === undefined || value === null) {
+    console.trace();
+    throw new Error(`Object doesn't have ${String(key)}`);
+  }
+  return value as ForSure<ForSure<T>[U]>;
+};
+
+export const getString = (v: unknown) => {
+  assert(typeof v === 'string');
+  return v;
+};
+
+export const retry = async <T>(cb: () => Promise<T>, condition: (e: any) => boolean) => {
+  try {
+    return await cb();
+  } catch (e) {
+    if (condition(e)) {
+      return await cb();
+    } else {
+      throw e;
+    }
+  }
+};

package/src/permissions/check.ts

@@ -1,9 +1,9 @@
 import { Knex } from 'knex';
 import { FullContext } from '../context';
 import { NotFoundError, PermissionError } from '../errors';
-import { Model } from '../models';
+import { Model } from '../models/models';
+import { get, getModelPlural, isRelation, summonByName } from '../models/utils';
 import { AliasGenerator, hash, ors } from '../resolvers/utils';
-import { get, getModelPlural, summonByName } from '../utils';
 import { BasicValue } from '../values';
 import { PermissionAction, PermissionLink, PermissionStack } from './generate';
 
@@ -139,7 +139,7 @@ export const checkCanWrite = async (
   let linked = false;
 
   for (const field of model.fields
-    .filter(({ relation }) => relation)
+    .filter(isRelation)
     .filter((field) => field.generated || (action === 'CREATE' ? field.creatable : field.updatable))) {
     const foreignKey = field.foreignKey || `${field.name}Id`;
     const foreignId = data[foreignKey] as string;

package/src/permissions/generate.ts

@@ -1,5 +1,5 @@
-import { Models } from '../models';
-import { summonByName } from '../utils';
+import { Models } from '../models/models';
+import { isRelation, summonByName } from '../models/utils';
 
 export type PermissionAction = 'READ' | 'CREATE' | 'UPDATE' | 'DELETE' | 'RESTORE' | 'LINK';
 
@@ -114,7 +114,7 @@ const addPermissions = (models: Models, permissions: RolePermissions, links: Per
 
   if (block.RELATIONS) {
     for (const [relation, subBlock] of Object.entries(block.RELATIONS)) {
-      const field = model.fields.find((field) => field.relation && field.name === relation);
+      const field = model.fields.filter(isRelation).find((field) => field.name === relation);
       let link: PermissionLink;
       if (field) {
         link = {

package/src/resolvers/arguments.ts

@@ -1,6 +1,6 @@
 import type { GraphQLObjectType, GraphQLSchema, TypeDefinitionNode, TypeNode, ValueNode } from 'graphql';
 import { Kind } from 'graphql';
-import { summonByKey } from '../utils';
+import { summonByKey } from '../models/utils';
 import { Value } from '../values';
 import { FieldResolverNode } from './node';
 import { Maybe, VariableValues } from './utils';

package/src/resolvers/filters.ts

@@ -1,6 +1,6 @@
 import { Knex } from 'knex';
 import { ForbiddenError, UserInputError } from '../errors';
-import { get, summonByName } from '../utils';
+import { get, summonByName } from '../models/utils';
 import { OrderBy, Where, normalizeArguments } from './arguments';
 import { FieldResolverNode, WhereNode } from './node';
 import { Joins, Ops, addJoin, apply, ors } from './utils';
@@ -85,7 +85,7 @@ const applyWhere = (node: WhereNode, where: Where, ops: Ops<Knex.QueryBuilder>,
     const field = summonByName(node.model.fields, key);
     const fullKey = `${node.shortTableAlias}.${key}`;
 
-    if (field.relation) {
+    if (field.type === 'relation') {
       const relation = get(node.model.relationsByName, field.name);
       const tableAlias = `${node.model.name}__W__${key}`;
       const subNode: WhereNode = {

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/models';
+import { get, isEnumList, it, summonByName, typeToField } from '../models/utils';
 import { applyPermissions, checkCanWrite, getEntityToMutate } from '../permissions/check';
-import { get, 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/models';
+import { get, isRawObjectModel, summonByKey, summonByName } from '../models/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

@@ -4,9 +4,9 @@ import cloneDeep from 'lodash/cloneDeep';
 import flatMap from 'lodash/flatMap';
 import { Context, FullContext } from '../context';
 import { NotFoundError, PermissionError } from '../errors';
+import { get, summonByKey } from '../models/utils';
 import { applyPermissions } from '../permissions/check';
 import { PermissionStack } from '../permissions/generate';
-import { get, summonByKey } from '../utils';
 import { applyFilters } from './filters';
 import {
   FieldResolverNode,
@@ -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/resolvers/resolvers.ts

@@ -1,5 +1,5 @@
-import { Models } from '../models';
-import { getModelPluralField, merge, typeToField } from '../utils';
+import { Models } from '../models/models';
+import { getModelPluralField, merge, typeToField } from '../models/utils';
 import { mutationResolver } from './mutations';
 import { queryResolver } from './resolver';
 

package/src/resolvers/utils.ts

@@ -12,7 +12,7 @@ import type {
 import { Kind } from 'graphql';
 import { Knex } from 'knex';
 import { UserInputError } from '../errors';
-import { get, it } from '../utils';
+import { get, it } from '../models/utils';
 import { Value } from '../values';
 import { FieldResolverNode } from './node';
 

package/tests/unit/resolve.spec.ts

@@ -1,14 +1,11 @@
-import { makeExecutableSchema } from '@graphql-tools/schema';
-import { execute, parse, Source } from 'graphql';
 import knex from 'knex';
 import { DateTime } from 'luxon';
+import { execute } from '../../src';
 import { gql } from '../../src/client/gql';
-import { Context } from '../../src/context';
-import { generate } from '../../src/generate';
 import { getResolvers } from '../../src/resolvers';
 import { models, permissions, rawModels } from '../utils/models';
 
-const test = async (operationName: string, query: string, variableValues: object, responses: unknown[]) => {
+const test = async (operationName: string, query: string, variables: object, responses: unknown[]) => {
   const knexInstance = knex({
     client: 'postgresql',
   });
@@ -25,11 +22,8 @@ const test = async (operationName: string, query: string, variableValues: object
   });
 
   const user = await knexInstance('User').where({ id: 1 }).first();
-  const typeDefs = generate(rawModels);
-  const contextValue: Context = {
-    req: null as any,
+  const result = await execute({
     knex: knexInstance,
-    document: typeDefs,
     locale: 'en',
     locales: ['en'],
     user,
@@ -37,16 +31,7 @@ const test = async (operationName: string, query: string, variableValues: object
     models,
     permissions,
     now: DateTime.fromISO('2020-01-01T00:00:00.000Z'),
-  };
-  const result = await execute({
-    schema: makeExecutableSchema({
-      typeDefs,
-      resolvers: getResolvers(models),
-    }),
-    document: parse(new Source(query, 'GraphQL request')),
-    contextValue,
-    variableValues,
-    operationName,
+    body: { operationName, query, variables }
   });
 
   expect(result).toMatchSnapshot();

package/tests/utils/models.ts

@@ -1,6 +1,6 @@
 import { RawModels } from '../../src/models';
+import { getModels } from '../../src/models/utils';
 import { generatePermissions, PermissionsConfig } from '../../src/permissions/generate';
-import { getModels } from '../../src/utils';
 
 export const rawModels: RawModels = [
   {
@@ -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,

package/tests/utils/server.ts

@@ -1,12 +1,9 @@
-import { makeExecutableSchema } from '@graphql-tools/schema';
-import { execute, parse, Source, TypedQueryDocumentNode } from 'graphql';
+import { TypedQueryDocumentNode } from 'graphql';
 import graphqlRequest, { RequestDocument, Variables } from 'graphql-request';
-import { createServer, RequestListener } from 'http';
+import { RequestListener, createServer } from 'http';
 import { Knex } from 'knex';
 import { DateTime } from 'luxon';
-import { Context } from '../../src/context';
-import { generate } from '../../src/generate';
-import { getResolvers } from '../../src/resolvers';
+import { execute } from '../../src';
 import { getKnex } from './database/knex';
 import { setupSchema } from './database/schema';
 import { ADMIN_ID, setupSeed } from './database/seed';
@@ -50,25 +47,7 @@ export const withServer = async (
 
     handler = async (req, res) => {
       const user = await knex('User').where({ id: ADMIN_ID }).first();
-
-      const typeDefs = generate(rawModels);
-      const contextValue: Context = {
-        req,
-        knex,
-        document: typeDefs,
-        locale: 'en',
-        locales: ['en'],
-        user,
-        rawModels,
-        models,
-        permissions,
-        now: DateTime.fromISO('2020-01-01T00:00:00.000Z'),
-      };
-      const {
-        query,
-        variables: variableValues,
-        operationName,
-      } = await new Promise<any>((res) => {
+      const body = await new Promise<any>((res) => {
         const chunks: any = [];
         req
           .on('data', (chunk) => {
@@ -79,14 +58,15 @@ export const withServer = async (
           });
       });
       const result = await execute({
-        schema: makeExecutableSchema({
-          typeDefs,
-          resolvers: getResolvers(models),
-        }),
-        document: parse(new Source(query, 'GraphQL request')),
-        contextValue,
-        variableValues,
-        operationName,
+        knex,
+        locale: 'en',
+        locales: ['en'],
+        user,
+        rawModels,
+        models,
+        permissions,
+        now: DateTime.fromISO('2020-01-01T00:00:00.000Z'),
+        body,
       });
 
       res.writeHead(200, { 'Content-Type': 'application/json' });