@smartive/graphql-magic 9.1.2 → 10.0.0

package/src/resolvers/resolvers.ts

@@ -1,5 +1,5 @@
 import { Models } from '../models/models';
-import { getModelPluralField, merge, typeToField } from '../models/utils';
+import { isRootModel, merge, not, typeToField } from '../models/utils';
 import { mutationResolver } from './mutations';
 import { queryResolver } from './resolver';
 
@@ -8,33 +8,44 @@ export const getResolvers = (models: Models) => ({
     {
       me: queryResolver,
     },
-    ...models
+    ...models.entities
       .filter(({ queriable }) => queriable)
       .map((model) => ({
         [typeToField(model.name)]: queryResolver,
       })),
-    ...models
+    ...models.entities
       .filter(({ listQueriable }) => listQueriable)
       .map((model) => ({
-        [getModelPluralField(model)]: queryResolver,
+        [model.pluralField]: queryResolver,
       })),
   ]),
   Mutation: merge<unknown>([
-    ...models
+    ...models.entities
+      .filter(not(isRootModel))
       .filter(({ creatable }) => creatable)
       .map((model) => ({
         [`create${model.name}`]: mutationResolver,
       })),
-    ...models
+    ...models.entities
+      .filter(not(isRootModel))
       .filter(({ updatable }) => updatable)
       .map((model) => ({
         [`update${model.name}`]: mutationResolver,
       })),
-    ...models
+    ...models.entities
+      .filter(not(isRootModel))
       .filter(({ deletable }) => deletable)
       .map((model) => ({
         [`delete${model.name}`]: mutationResolver,
         [`restore${model.name}`]: mutationResolver,
       })),
   ]),
+  ...Object.assign(
+    {},
+    ...models.entities.filter(isRootModel).map((model) => ({
+      [model.name]: {
+        __resolveType: ({ TYPE }) => TYPE,
+      },
+    }))
+  ),
 });

package/src/resolvers/selects.ts

@@ -0,0 +1,77 @@
+import { Knex } from 'knex';
+import {
+  ID_ALIAS,
+  Joins,
+  ResolverNode,
+  TYPE_ALIAS,
+  addJoin,
+  getFragmentSpreads,
+  getInlineFragments,
+  getJoins,
+  getNameOrAlias,
+  getSimpleFields,
+} from '.';
+import { PermissionError, UserInputError } from '..';
+
+export const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins: Joins) => {
+  // Simple field selects
+  void query.select(
+    ...[
+      { tableAlias: node.rootTableAlias, resultAlias: node.resultAlias, field: 'id', fieldAlias: ID_ALIAS },
+      ...(node.model.root
+        ? [{ tableAlias: node.rootTableAlias, resultAlias: node.resultAlias, field: 'type', fieldAlias: TYPE_ALIAS }]
+        : []),
+      ...getSimpleFields(node)
+        .filter((fieldNode) => {
+          const field = node.model.fieldsByName[fieldNode.name.value];
+          if (!field || field.kind === 'relation' || field.kind === 'custom') {
+            return false;
+          }
+
+          if (typeof field.queriable === 'object' && !field.queriable.roles?.includes(node.ctx.user.role)) {
+            throw new PermissionError(
+              'READ',
+              `${node.model.name}'s field "${field.name}"`,
+              'field permission not available'
+            );
+          }
+
+          return true;
+        })
+        .map((fieldNode) => {
+          const field = node.model.getField(fieldNode.name.value);
+          if (node.model.parent && !field.inherited) {
+            addJoin(joins, node.rootTableAlias, node.model.name, node.tableAlias, 'id', 'id');
+          }
+          const fieldAlias = getNameOrAlias(fieldNode);
+          if ([ID_ALIAS, TYPE_ALIAS].includes(fieldAlias)) {
+            throw new UserInputError(`Keyword ${fieldAlias} is reserved by graphql-magic.`);
+          }
+          return {
+            fieldNode,
+            field: fieldNode.name.value,
+            tableAlias: field.inherited ? node.rootTableAlias : node.tableAlias,
+            resultAlias: node.resultAlias,
+            fieldAlias,
+          };
+        }),
+    ].map(
+      ({ tableAlias, resultAlias, field, fieldAlias }) =>
+        `${node.ctx.aliases.getShort(tableAlias)}.${field} as ${node.ctx.aliases.getShort(resultAlias)}__${fieldAlias}`
+    )
+  );
+
+  for (const subNode of getInlineFragments(node)) {
+    applySelects(subNode, query, joins);
+  }
+
+  for (const subNode of getFragmentSpreads(node)) {
+    applySelects(subNode, query, joins);
+  }
+
+  for (const subNode of getJoins(node, false)) {
+    addJoin(joins, node.tableAlias, subNode.rootModel.name, subNode.rootTableAlias, subNode.foreignKey, 'id');
+
+    applySelects(subNode, query, joins);
+  }
+};

package/src/resolvers/utils.ts

@@ -11,12 +11,15 @@ import type {
 } from 'graphql';
 import { Kind } from 'graphql';
 import { Knex } from 'knex';
+import { isEqual } from 'lodash';
+import { EntityField } from '..';
 import { UserInputError } from '../errors';
 import { get, it } from '../models/utils';
 import { Value } from '../values';
-import { FieldResolverNode } from './node';
+import { FieldResolverNode, ResolverNode } from './node';
 
 export const ID_ALIAS = 'ID';
+export const TYPE_ALIAS = 'TYPE';
 
 export type VariableValues = {
   [variableName: string]: Value;
@@ -66,17 +69,15 @@ export function hydrate<T extends Entry>(
   node: FieldResolverNode,
   raw: { [key: string]: undefined | null | string | Date | number }[]
 ): T[] {
-  const tableAlias = node.tableAlias;
+  const resultAlias = node.resultAlias;
   const res = raw.map((entry) => {
     const res: any = {};
     outer: for (const [column, value] of Object.entries(entry)) {
       let current = res;
-      const shortParts = column.split('__');
-      const fieldName = shortParts.pop();
-      const columnWithoutField = shortParts.join('__');
+      const [, columnWithoutField, fieldName] = column.match(/^(.*\w)__(\w+)$/);
       const longColumn = node.ctx.aliases.getLong(columnWithoutField);
-      const longColumnWithoutRoot = longColumn.replace(new RegExp(`^${tableAlias}(__)?`), '');
-      const allParts = [tableAlias, ...(longColumnWithoutRoot ? longColumnWithoutRoot.split('__') : []), fieldName];
+      const longColumnWithoutRoot = longColumn.replace(new RegExp(`^${resultAlias}(__)?`), '');
+      const allParts = [resultAlias, ...(longColumnWithoutRoot ? longColumnWithoutRoot.split('__') : []), fieldName];
       for (let i = 0; i < allParts.length - 1; i++) {
         const part = allParts[i];
 
@@ -91,7 +92,7 @@ export function hydrate<T extends Entry>(
       }
       current[it(fieldName)] = value;
     }
-    return res[tableAlias];
+    return res[resultAlias];
   });
 
   return res;
@@ -102,16 +103,12 @@ export const ors = (query: Knex.QueryBuilder, [first, ...rest]: ((query: Knex.Qu
     return query;
   }
   return query.where((subQuery) => {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-    subQuery.where((subSubQuery) => {
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-      first(subSubQuery);
+    void subQuery.where((subSubQuery) => {
+      void first(subSubQuery);
     });
     for (const cb of rest) {
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-      subQuery.orWhere((subSubQuery) => {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-        cb(subSubQuery);
+      void subQuery.orWhere((subSubQuery) => {
+        void cb(subSubQuery);
       });
     }
   });
@@ -131,15 +128,18 @@ export type Ops<T> = ((target: T) => T)[];
 
 export const apply = <T>(target: T, ops: ((target: T) => T)[]) => ops.reduce((target, op) => op(target), target);
 
-export type Joins = Record<`${string}:${string}`, { table1Alias: string; column1: string; column2: string }>;
+type Join = { table1Alias: string; column1: string; table2Name: string; table2Alias: string; column2: string };
+export type Joins = Join[];
 
 export const applyJoins = (aliases: AliasGenerator, query: Knex.QueryBuilder, joins: Joins) => {
-  for (const [tableName, { table1Alias, column1, column2 }] of Object.entries(joins)) {
-    const [table, alias] = tableName.split(':');
+  for (const { table1Alias, table2Name, table2Alias, column1, column2 } of joins) {
     const table1ShortAlias = aliases.getShort(table1Alias);
-    const table2ShortAlias = aliases.getShort(alias);
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-    query.leftJoin(`${table} as ${table2ShortAlias}`, `${table1ShortAlias}.${column1}`, `${table2ShortAlias}.${column2}`);
+    const table2ShortAlias = aliases.getShort(table2Alias);
+    void query.leftJoin(
+      `${table2Name} as ${table2ShortAlias}`,
+      `${table1ShortAlias}.${column1}`,
+      `${table2ShortAlias}.${column2}`
+    );
   }
 };
 
@@ -149,12 +149,20 @@ export const applyJoins = (aliases: AliasGenerator, query: Knex.QueryBuilder, jo
 export const addJoin = (
   joins: Joins,
   table1Alias: string,
-  table2: string,
-  alias2: string,
+  table2Name: string,
+  table2Alias: string,
   column1: string,
   column2: string
 ) => {
-  joins[`${table2}:${alias2}`] ||= { table1Alias, column1, column2 };
+  const join = { table1Alias, table2Name, table2Alias, column1, column2 };
+  const existingJoin = joins.find((j) => j.table2Alias === join.table2Alias);
+  if (existingJoin) {
+    if (!isEqual(existingJoin, join)) {
+      throw new Error(`Join collision: ${existingJoin}, ${join}`);
+    }
+  } else {
+    joins.push(join);
+  }
 };
 
 export class AliasGenerator {
@@ -186,3 +194,11 @@ export class AliasGenerator {
 }
 
 export const hash = (s: any) => createHash('md5').update(JSON.stringify(s)).digest('hex');
+
+export const getColumnName = (field: EntityField) =>
+  field.kind === 'relation' ? field.foreignKey || `${field.name}Id` : field.name;
+
+export const getColumn = (node: Pick<ResolverNode, 'model' | 'ctx' | 'rootTableAlias' | 'tableAlias'>, key: string) => {
+  const field = node.model.fields.find((field) => getColumnName(field) === key);
+  return `${node.ctx.aliases.getShort(field.inherited ? node.rootTableAlias : node.tableAlias)}.${key}`;
+};

package/src/schema/generate.ts

@@ -1,120 +1,105 @@
 import { DefinitionNode, DocumentNode, GraphQLSchema, buildASTSchema, print } from 'graphql';
-import flatMap from 'lodash/flatMap';
-import { RawModels } from '../models/models';
-import {
-  getModelPluralField,
-  getModels,
-  isEnumModel,
-  isInputModel,
-  isObjectModel,
-  isQueriableField,
-  isRawEnumModel,
-  isRelation,
-  isScalarModel,
-  typeToField,
-} from '../models/utils';
-import { Field, document, enm, input, object, scalar } from './utils';
-
-export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
-  const models = getModels(rawModels);
+import { Models } from '../models/models';
+import { isQueriableField, isRelation, isRootModel, typeToField } from '../models/utils';
+import { Field, document, enm, iface, input, object, scalar } from './utils';
 
+export const generateDefinitions = ({
+  scalars,
+  rawEnums,
+  enums,
+  inputs,
+  interfaces,
+  entities,
+  objects,
+}: Models): DefinitionNode[] => {
   return [
     // Predefined types
-    enm('Order', ['ASC', 'DESC']),
-    scalar('DateTime'),
-    scalar('Upload'),
-
-    ...rawModels.filter(isEnumModel).map((model) => enm(model.name, model.values)),
-    ...rawModels.filter(isRawEnumModel).map((model) => enm(model.name, model.values)),
-    ...rawModels.filter(isScalarModel).map((model) => scalar(model.name)),
-    ...rawModels
-      .filter(isObjectModel)
-      .filter(({ name }) => !['Query', 'Mutation'].includes(name))
-      .map((model) => object(model.name, model.fields)),
-    ...rawModels.filter(isInputModel).map((model) => input(model.name, model.fields)),
-    ...rawModels
-      .filter(isObjectModel)
+    ...rawEnums.map((model) => enm(model.name, model.values)),
+    ...enums.map((model) => enm(model.name, model.values)),
+    ...scalars.map((model) => scalar(model.name)),
+    ...objects.filter(({ name }) => !['Query', 'Mutation'].includes(name)).map((model) => object(model.name, model.fields)),
+    ...interfaces.map(({ name, fields }) => iface(name, fields)),
+    ...inputs.map((model) => input(model.name, model.fields)),
+    ...objects
       .filter((model) =>
-        models.some((m) => m.creatable && m.fields.some((f) => f.creatable && f.kind === 'json' && f.type === model.name))
+        entities.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(isObjectModel)
+    ...objects
       .filter((model) =>
-        models.some((m) => m.creatable && m.fields.some((f) => f.creatable && f.kind === 'json' && f.type === model.name))
+        entities.some((m) => m.updatable && m.fields.some((f) => f.updatable && f.kind === 'json' && f.type === model.name))
       )
       .map((model) => input(`Update${model.name}`, model.fields)),
 
-    ...flatMap(
-      models.map((model) => {
-        const types = [
-          object(
-            model.name,
-            [
-              ...model.fields.filter(isQueriableField).map((field) => ({
-                ...field,
-                type: field.type,
-                args: [...(field.args || [])],
-                directives: field.directives,
-              })),
-              ...model.reverseRelations.map(({ name, field, model }) => ({
-                name,
-                type: model.name,
-                list: !field.toOne,
-                nonNull: !field.toOne,
-                args: [
-                  { name: 'where', type: `${model.name}Where` },
-                  ...(model.fields.some(({ searchable }) => searchable) ? [{ name: 'search', type: 'String' }] : []),
-                  ...(model.fields.some(({ orderable }) => orderable)
-                    ? [{ name: 'orderBy', type: `${model.name}OrderBy`, list: true }]
-                    : []),
-                  { name: 'limit', type: 'Int' },
-                  { name: 'offset', type: 'Int' },
-                ],
-              })),
-            ],
-            model.interfaces
-          ),
-          input(`${model.name}Where`, [
-            ...model.fields
-              .filter(({ kind, unique, filterable }) => (unique || filterable) && kind !== 'relation')
-              .map((field) => ({
-                name: field.name,
-                type: field.type,
-                list: true,
-                default: typeof field.filterable === 'object' ? field.filterable.default : undefined,
-              })),
-            ...flatMap(
-              model.fields.filter(({ comparable }) => comparable),
-              (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, type }) => ({
-                name,
-                type: `${type}Where`,
-              })),
-          ]),
-          input(
-            `${model.name}WhereUnique`,
-            model.fields.filter(({ unique }) => unique).map((field) => ({ name: field.name, type: field.type }))
-          ),
-          ...(model.fields.some(({ orderable }) => orderable)
-            ? [
-                input(
-                  `${model.name}OrderBy`,
-                  model.fields.filter(({ orderable }) => orderable).map(({ name }) => ({ name, type: 'Order' }))
-                ),
-              ]
-            : []),
-        ];
+    ...entities.flatMap((model) => {
+      const types: DefinitionNode[] = [
+        (isRootModel(model) ? iface : object)(
+          model.name,
+          [
+            ...model.fields.filter(isQueriableField).map((field) => ({
+              ...field,
+              type: field.type,
+              args: [...(field.args || [])],
+              directives: field.directives,
+            })),
+            ...model.reverseRelations.map(({ name, field, targetModel }) => ({
+              name,
+              type: targetModel.name,
+              list: !field.toOne,
+              nonNull: !field.toOne,
+              args: [
+                { name: 'where', type: `${targetModel.name}Where` },
+                ...(targetModel.fields.some(({ searchable }) => searchable) ? [{ name: 'search', type: 'String' }] : []),
+                ...(targetModel.fields.some(({ orderable }) => orderable)
+                  ? [{ name: 'orderBy', type: `${targetModel.name}OrderBy`, list: true }]
+                  : []),
+                { name: 'limit', type: 'Int' },
+                { name: 'offset', type: 'Int' },
+              ],
+            })),
+          ],
+          [...(model.parent ? [model.parent] : []), ...(model.interfaces || [])]
+        ),
+        input(`${model.name}Where`, [
+          ...model.fields
+            .filter(({ kind, unique, filterable }) => (unique || filterable) && kind !== 'relation')
+            .map((field) => ({
+              name: field.name,
+              type: field.type,
+              list: true,
+              default: typeof field.filterable === 'object' ? field.filterable.default : undefined,
+            })),
+          ...model.fields
+            .filter(({ comparable }) => comparable)
+            .flatMap((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, type }) => ({
+              name,
+              type: `${type}Where`,
+            })),
+        ]),
+        input(
+          `${model.name}WhereUnique`,
+          model.fields.filter(({ unique }) => unique).map((field) => ({ name: field.name, type: field.type }))
+        ),
+        ...(model.fields.some(({ orderable }) => orderable)
+          ? [
+              input(
+                `${model.name}OrderBy`,
+                model.fields.filter(({ orderable }) => orderable).map(({ name }) => ({ name, type: 'Order' }))
+              ),
+            ]
+          : []),
+      ];
 
+      if (!isRootModel(model)) {
         if (model.creatable) {
           types.push(
             input(
@@ -153,16 +138,16 @@ export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
             )
           );
         }
-        return types;
-      })
-    ),
+      }
 
+      return types;
+    }),
     object('Query', [
       {
         name: 'me',
         type: 'User',
       },
-      ...models
+      ...entities
         .filter(({ queriable }) => queriable)
         .map(({ name }) => ({
           name: typeToField(name),
@@ -176,10 +161,10 @@ export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
             },
           ],
         })),
-      ...models
+      ...entities
         .filter(({ listQueriable }) => listQueriable)
         .map((model) => ({
-          name: getModelPluralField(model),
+          name: model.pluralField,
           type: model.name,
           list: true,
           nonNull: true,
@@ -193,17 +178,14 @@ export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
             { name: 'offset', type: 'Int' },
           ],
         })),
-      ...rawModels
-        .filter(isObjectModel)
-        .filter((model) => model.name === 'Query')
-        .flatMap((model) => model.fields),
+      ...objects.filter((model) => model.name === 'Query').flatMap((model) => model.fields),
     ]),
 
     object('Mutation', [
-      ...flatMap(
-        models.map((model): Field[] => {
-          const mutations: Field[] = [];
+      ...entities.flatMap((model): Field[] => {
+        const mutations: Field[] = [];
 
+        if (!isRootModel(model)) {
           if (model.creatable) {
             mutations.push({
               name: `create${model.name}`,
@@ -269,19 +251,16 @@ export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
               ],
             });
           }
+        }
 
-          return mutations;
-        })
-      ),
-      ...rawModels
-        .filter(isObjectModel)
-        .filter((model) => model.name === 'Mutation')
-        .flatMap((model) => model.fields),
+        return mutations;
+      }),
+      ...objects.filter((model) => model.name === 'Mutation').flatMap((model) => model.fields),
     ]),
   ];
 };
 
-export const generate = (rawModels: RawModels) => document(generateDefinitions(rawModels));
+export const generate = (models: Models) => document(generateDefinitions(models));
 
 export const printSchema = (schema: GraphQLSchema): string =>
   [
@@ -297,4 +276,4 @@ export const printSchema = (schema: GraphQLSchema): string =>
 
 export const printSchemaFromDocument = (document: DocumentNode) => printSchema(buildASTSchema(document));
 
-export const printSchemaFromModels = (models: RawModels) => printSchema(buildASTSchema(generate(models)));
+export const printSchemaFromModels = (models: Models) => printSchema(buildASTSchema(generate(models)));

package/src/schema/utils.ts

@@ -77,10 +77,11 @@ export const object = (nme: string, fds: Field[], interfaces?: string[], dvs?: D
   directives: directives(dvs),
 });
 
-export const iface = (nme: string, fds: Field[], dvs?: Directive[]): InterfaceTypeDefinitionNode => ({
+export const iface = (nme: string, fds: Field[], interfaces?: string[], dvs?: Directive[]): InterfaceTypeDefinitionNode => ({
   name: name(nme),
   fields: fields(fds),
   kind: 'InterfaceTypeDefinition',
+  interfaces: interfaces && interfaces.map((i) => namedType(i)),
   directives: directives(dvs),
 });
 

package/tests/api/__snapshots__/inheritance.spec.ts.snap

@@ -0,0 +1,83 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`inheritance mutations create 1`] = `
+{
+  "createReview": {
+    "content": "A review",
+    "rating": 5,
+  },
+}
+`;
+
+exports[`inheritance mutations delete and restore 1`] = `
+{
+  "deleteReview": "817c55de-2f77-4159-bd44-9837d868f889",
+}
+`;
+
+exports[`inheritance mutations delete and restore 2`] = `
+{
+  "restoreReview": "817c55de-2f77-4159-bd44-9837d868f889",
+}
+`;
+
+exports[`inheritance mutations update 1`] = `
+{
+  "updateReview": {
+    "content": "A review",
+    "rating": 5,
+  },
+}
+`;
+
+exports[`inheritance queries root type listQuery 1`] = `
+{
+  "reactions": [
+    {
+      "content": "This is a review with a rating",
+      "rating": 5,
+      "type": "Review",
+    },
+    {
+      "content": "I do not know but here is the answer.",
+      "type": "Answer",
+    },
+    {
+      "content": "What is the question?",
+      "type": "Question",
+    },
+  ],
+}
+`;
+
+exports[`inheritance queries root type query 1`] = `
+{
+  "reaction": {
+    "content": "This is a review with a rating",
+    "rating": 5,
+    "type": "Review",
+  },
+}
+`;
+
+exports[`inheritance queries sub type listQuery 1`] = `
+{
+  "reviews": [
+    {
+      "content": "This is a review with a rating",
+      "rating": 5,
+      "type": "Review",
+    },
+  ],
+}
+`;
+
+exports[`inheritance queries sub type query 1`] = `
+{
+  "review": {
+    "content": "This is a review with a rating",
+    "rating": 5,
+    "type": "Review",
+  },
+}
+`;