@smartive/graphql-magic 16.3.6 → 16.3.8

package/src/resolvers/mutations.ts

@@ -137,15 +137,17 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
     throw new ForbiddenError('Entity is already deleted.');
   }
 
-  const toDelete: { [type: string]: { [id: string]: string } } = {};
-  const toUnlink: {
-    [type: string]: {
-      [id: string]: {
+  const toDelete: Record<string, Record<string, string>> = {};
+  const toUnlink: Record<
+    string,
+    Record<
+      string,
+      {
         display: string;
         fields: string[];
-      };
-    };
-  } = {};
+      }
+    >
+  > = {};
 
   const beforeHooks: Callbacks = [];
   const mutations: Callbacks = [];
@@ -167,18 +169,19 @@ const del = async (model: EntityModel, { where, dryRun }: { where: any; dryRun:
     if (!dryRun) {
       const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user?.id };
       const data = { prev: entity, input: {}, normalizedInput, next: { ...entity, ...normalizedInput } };
-      if (ctx.mutationHook) {
+      const mutationHook = ctx.mutationHook;
+      if (mutationHook) {
         beforeHooks.push(async () => {
-          await ctx.mutationHook(currentModel, 'delete', 'before', data, ctx);
+          await mutationHook(currentModel, 'delete', 'before', data, ctx);
         });
       }
       mutations.push(async () => {
         await ctx.knex(currentModel.name).where({ id: entity.id }).update(normalizedInput);
         await createRevision(currentModel, { ...entity, deleted: true }, ctx);
       });
-      if (ctx.mutationHook) {
+      if (mutationHook) {
         afterHooks.push(async () => {
-          await ctx.mutationHook(currentModel, 'delete', 'after', data, ctx);
+          await mutationHook(currentModel, 'delete', 'after', data, ctx);
         });
       }
     }
@@ -270,7 +273,7 @@ const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullC
     if (
       !relatedEntity.deleted ||
       !relatedEntity.deletedAt ||
-      !anyDateToLuxon(relatedEntity.deletedAt, ctx.timeZone).equals(anyDateToLuxon(entity.deletedAt, ctx.timeZone))
+      !anyDateToLuxon(relatedEntity.deletedAt, ctx.timeZone)!.equals(anyDateToLuxon(entity.deletedAt, ctx.timeZone)!)
     ) {
       return;
     }
@@ -279,7 +282,7 @@ const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullC
     const data = { prev: relatedEntity, input: {}, normalizedInput, next: { ...relatedEntity, ...normalizedInput } };
     if (ctx.mutationHook) {
       beforeHooks.push(async () => {
-        await ctx.mutationHook(currentModel, 'restore', 'before', data, ctx);
+        await ctx.mutationHook!(currentModel, 'restore', 'before', data, ctx);
       });
     }
     mutations.push(async () => {
@@ -288,7 +291,7 @@ const restore = async (model: EntityModel, { where }: { where: any }, ctx: FullC
     });
     if (ctx.mutationHook) {
       afterHooks.push(async () => {
-        await ctx.mutationHook(currentModel, 'restore', 'after', data, ctx);
+        await ctx.mutationHook!(currentModel, 'restore', 'after', data, ctx);
       });
     }
 
@@ -369,7 +372,7 @@ const sanitize = (ctx: FullContext, model: EntityModel, data: Entity) => {
     }
 
     if (isEndOfDay(field) && data[key]) {
-      data[key] = anyDateToLuxon(data[key], ctx.timeZone).endOf('day');
+      data[key] = anyDateToLuxon(data[key], ctx.timeZone)!.endOf('day');
       continue;
     }
 
@@ -380,5 +383,5 @@ const sanitize = (ctx: FullContext, model: EntityModel, data: Entity) => {
   }
 };
 
-const isEndOfDay = (field?: EntityField) =>
+const isEndOfDay = (field: EntityField) =>
   isPrimitive(field) && field.type === 'DateTime' && field?.endOfDay === true && field?.dateTimeType === 'date';

package/src/resolvers/node.ts

@@ -149,7 +149,7 @@ export const getInlineFragments = (node: ResolverNode) =>
 
       baseTypeDefinition: node.baseTypeDefinition,
       typeName: getFragmentTypeName(subNode),
-    })
+    }),
   );
 
 export const getFragmentSpreads = (node: ResolverNode) =>
@@ -166,7 +166,7 @@ export const getFragmentSpreads = (node: ResolverNode) =>
 
       baseTypeDefinition: node.baseTypeDefinition,
       typeName: node.model.name,
-    })
+    }),
   );
 
 export const getJoins = (node: ResolverNode, toMany: boolean) => {
@@ -217,5 +217,6 @@ export const getJoins = (node: ResolverNode, toMany: boolean) => {
       isList: isListType(fieldDefinition.type),
     });
   }
+
   return nodes;
 };

package/src/resolvers/resolver.ts

@@ -19,7 +19,7 @@ export const resolve = async (ctx: FullContext, id?: string) => {
   const fieldNode = summonByKey(ctx.info.fieldNodes, 'name.value', ctx.info.fieldName);
   const baseTypeDefinition = get(
     ctx.info.operation.operation === 'query' ? ctx.info.schema.getQueryType() : ctx.info.schema.getMutationType(),
-    'astNode'
+    'astNode',
   );
   const node = getRootFieldNode({
     ctx,
@@ -29,7 +29,7 @@ export const resolve = async (ctx: FullContext, id?: string) => {
   const { query, verifiedPermissionStacks } = await buildQuery(node);
 
   if (ctx.info.fieldName === 'me') {
-    if (!node.ctx.user.id) {
+    if (!node.ctx.user?.id) {
       return undefined;
     }
 
@@ -66,7 +66,7 @@ type VerifiedPermissionStacks = Record<string, PermissionStack>;
 
 const buildQuery = async (
   node: FieldResolverNode,
-  parentVerifiedPermissionStacks?: VerifiedPermissionStacks
+  parentVerifiedPermissionStacks?: VerifiedPermissionStacks,
 ): Promise<{ query: Knex.QueryBuilder; verifiedPermissionStacks: VerifiedPermissionStacks }> => {
   const query = node.ctx.knex.fromRaw(`"${node.rootModel.name}" as "${node.ctx.aliases.getShort(node.resultAlias)}"`);
 
@@ -88,7 +88,7 @@ const buildQuery = async (
       node.ctx.aliases.getShort(alias),
       query,
       'READ',
-      parentVerifiedPermissionStacks?.[alias.split('__').slice(0, -1).join('__')]
+      parentVerifiedPermissionStacks?.[alias.split('__').slice(0, -1).join('__')],
     );
 
     if (typeof verifiedPermissionStack !== 'boolean') {
@@ -102,13 +102,13 @@ const buildQuery = async (
 const applySubQueries = async (
   node: ResolverNode,
   entries: Entry[],
-  parentVerifiedPermissionStacks: VerifiedPermissionStacks
+  parentVerifiedPermissionStacks: VerifiedPermissionStacks,
 ): Promise<void> => {
   if (!entries.length) {
     return;
   }
 
-  const entriesById: { [id: string]: Entry[] } = {};
+  const entriesById: Record<string, Entry[]> = {};
   for (const entry of entries) {
     if (!entriesById[entry[ID_ALIAS]]) {
       entriesById[entry[ID_ALIAS]] = [];
@@ -130,7 +130,7 @@ const applySubQueries = async (
       query
         .clone()
         .select(`${shortTableAlias}.${foreignKey} as ${shortResultAlias}__${foreignKey}`)
-        .where({ [`${shortTableAlias}.${foreignKey}`]: id })
+        .where({ [`${shortTableAlias}.${foreignKey}`]: id }),
     );
 
     // TODO: make unionAll faster then promise.all...
@@ -153,10 +153,11 @@ const applySubQueries = async (
       flatMap(
         entries.map((entry) => {
           const children = entry[fieldName];
+
           return (isList ? children : children ? [children] : []) as Entry[];
-        })
+        }),
       ),
-      verifiedPermissionStacks
+      verifiedPermissionStacks,
     );
   }
 
@@ -172,7 +173,7 @@ const applySubQueries = async (
     await applySubQueries(
       subNode,
       entries.map((item) => item[getNameOrAlias(subNode.field)] as Entry).filter(Boolean),
-      parentVerifiedPermissionStacks
+      parentVerifiedPermissionStacks,
     );
   }
 };

package/src/resolvers/selects.ts

@@ -34,7 +34,7 @@ export const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins
               role,
               'READ',
               `${node.model.name}'s field "${field.name}"`,
-              'field permission not available'
+              'field permission not available',
             );
           }
 
@@ -49,6 +49,7 @@ export const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins
           if ([ID_ALIAS, TYPE_ALIAS].includes(fieldAlias)) {
             throw new UserInputError(`Keyword ${fieldAlias} is reserved by graphql-magic.`);
           }
+
           return {
             fieldNode,
             field: fieldNode.name.value,
@@ -59,8 +60,8 @@ export const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins
         }),
     ].map(
       ({ tableAlias, resultAlias, field, fieldAlias }) =>
-        `${node.ctx.aliases.getShort(tableAlias)}.${field} as ${node.ctx.aliases.getShort(resultAlias)}__${fieldAlias}`
-    )
+        `${node.ctx.aliases.getShort(tableAlias)}.${field} as ${node.ctx.aliases.getShort(resultAlias)}__${fieldAlias}`,
+    ),
   );
 
   for (const subNode of getInlineFragments(node)) {

package/src/resolvers/utils.ts

@@ -21,17 +21,17 @@ import { FieldResolverNode, ResolverNode } from './node';
 export const ID_ALIAS = 'ID';
 export const TYPE_ALIAS = 'TYPE';
 
-export type VariableValues = {
-  [variableName: string]: Value;
-};
+export type VariableValues = Record<string, Value>;
 
 export const getTypeName = (t: TypeNode): string => {
   switch (t.kind) {
     case 'ListType':
     case 'NonNullType':
       return getTypeName(t.type);
-    default:
+    case 'NamedType':
       return t.name.value;
+    default:
+      throw new Error(`Unknown type node kind: ${t.kind}`);
   }
 };
 
@@ -67,14 +67,14 @@ export type Entry = {
 
 export function hydrate<T extends Entry>(
   node: FieldResolverNode,
-  raw: { [key: string]: undefined | null | string | Date | number }[]
+  raw: Record<string, undefined | null | string | Date | number>[],
 ): T[] {
   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 [, columnWithoutField, fieldName] = column.match(/^(.*\w)__(\w+)$/);
+      const [, columnWithoutField, fieldName] = column.match(/^(.*\w)__(\w+)$/)!;
       const longColumn = node.ctx.aliases.getLong(columnWithoutField);
       const longColumnWithoutRoot = longColumn.replace(new RegExp(`^${resultAlias}(__)?`), '');
       const allParts = [resultAlias, ...(longColumnWithoutRoot ? longColumnWithoutRoot.split('__') : []), fieldName];
@@ -92,6 +92,7 @@ export function hydrate<T extends Entry>(
       }
       current[it(fieldName)] = value;
     }
+
     return res[resultAlias];
   });
 
@@ -102,6 +103,7 @@ export const ors = (query: Knex.QueryBuilder, [first, ...rest]: ((query: Knex.Qu
   if (!first) {
     return query;
   }
+
   return query.where((subQuery) => {
     void subQuery.where((subSubQuery) => {
       void first(subSubQuery);
@@ -117,7 +119,7 @@ export const ors = (query: Knex.QueryBuilder, [first, ...rest]: ((query: Knex.Qu
 export const getNameOrAlias = (node: FieldNode) => {
   const name = node.alias ? node.alias.value : node.name.value;
 
-  if ([ID_ALIAS].indexOf(name) >= 0) {
+  if ([ID_ALIAS].includes(name)) {
     throw new UserInputError(`"${name}" can not be used as alias since it's a reserved word`);
   }
 
@@ -140,7 +142,7 @@ export const applyJoins = (aliases: AliasGenerator, query: Knex.QueryBuilder, jo
     void query.leftJoin(
       `${table2Name} as ${table2ShortAlias}`,
       `${table1ShortAlias}.${column1}`,
-      `${table2ShortAlias}.${column2}`
+      `${table2ShortAlias}.${column2}`,
     );
   }
 };
@@ -154,7 +156,7 @@ export const addJoin = (
   table2Name: string,
   table2Alias: string,
   column1: string,
-  column2: string
+  column2: string,
 ) => {
   const join = { table1Alias, table2Name, table2Alias, column1, column2 };
   const existingJoin = joins.find((j) => j.table2Alias === join.table2Alias);
@@ -173,6 +175,7 @@ export class AliasGenerator {
   public getShort(long?: string) {
     if (!long) {
       const short = `a${Object.keys(this.reverse).length}`;
+
       return (this.reverse[short] = short);
     }
 
@@ -187,6 +190,7 @@ export class AliasGenerator {
     }
 
     this.reverse[short] = long;
+
     return short;
   }
 
@@ -201,6 +205,7 @@ 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);
+  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

@@ -22,12 +22,12 @@ export const generateDefinitions = ({
     ...inputs.map((model) => input(model.name, model.fields)),
     ...objects
       .filter((model) =>
-        entities.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)),
     ...objects
       .filter((model) =>
-        entities.some((m) => m.updatable && m.fields.some((f) => f.updatable && 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)),
 
@@ -58,7 +58,7 @@ export const generateDefinitions = ({
               ],
             })),
           ],
-          [...(model.parent ? [model.parent] : []), ...(model.interfaces || [])]
+          [...(model.parent ? [model.parent] : []), ...(model.interfaces || [])],
         ),
         input(`${model.name}Where`, [
           ...model.fields
@@ -112,13 +112,13 @@ export const generateDefinitions = ({
         ]),
         input(
           `${model.name}WhereUnique`,
-          model.fields.filter(({ unique }) => unique).map((field) => ({ name: field.name, type: field.type }))
+          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' }))
+                model.fields.filter(({ orderable }) => orderable).map(({ name }) => ({ name, type: 'Order' })),
               ),
             ]
           : []),
@@ -139,9 +139,9 @@ export const generateDefinitions = ({
                         type: field.kind === 'json' ? `Create${field.type}` : field.type,
                         list: field.list,
                         nonNull: field.nonNull && field.defaultValue === undefined,
-                      }
-                )
-            )
+                      },
+                ),
+            ),
           );
         }
 
@@ -158,9 +158,9 @@ export const generateDefinitions = ({
                         name: field.name,
                         type: field.kind === 'json' ? `Update${field.type}` : field.type,
                         list: field.list,
-                      }
-                )
-            )
+                      },
+                ),
+            ),
           );
         }
       }