@smartive/graphql-magic 16.3.7 → 16.3.8

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,
-                      }
-                )
-            )
+                      },
+                ),
+            ),
           );
         }
       }

package/src/schema/utils.ts

@@ -1,9 +1,11 @@
 import { Dayjs } from 'dayjs';
 import {
-  ArgumentNode,
+  ConstArgumentNode,
+  ConstDirectiveNode,
+  ConstObjectFieldNode,
+  ConstValueNode,
   DefinitionNode,
   DirectiveDefinitionNode,
-  DirectiveNode,
   DocumentNode,
   EnumTypeDefinitionNode,
   EnumValueDefinitionNode,
@@ -11,16 +13,15 @@ import {
   InputObjectTypeDefinitionNode,
   InputValueDefinitionNode,
   InterfaceTypeDefinitionNode,
+  Kind,
   ListTypeNode,
   NamedTypeNode,
   NameNode,
   NonNullTypeNode,
-  ObjectFieldNode,
   ObjectTypeDefinitionNode,
   ScalarTypeDefinitionNode,
   StringValueNode,
   TypeNode,
-  ValueNode,
 } from 'graphql';
 import { DateTime } from 'luxon';
 import { Directive, Value, Values } from '../values';
@@ -46,71 +47,71 @@ export type DirectiveLocation =
   | 'INPUT_OBJECT';
 
 export const document = (definitions: DefinitionNode[]): DocumentNode => ({
-  kind: 'Document',
+  kind: Kind.DOCUMENT,
   definitions,
 });
 
 export const directive = (nme: string, locations: DirectiveLocation[], fields?: Field[]): DirectiveDefinitionNode => ({
   name: name(nme),
   repeatable: false,
-  kind: 'DirectiveDefinition',
+  kind: Kind.DIRECTIVE_DEFINITION,
   arguments: fields && inputValues(fields),
   locations: locations.map(name),
 });
 
 export const scalar = (nme: string): ScalarTypeDefinitionNode => ({
   name: name(nme),
-  kind: 'ScalarTypeDefinition',
+  kind: Kind.SCALAR_TYPE_DEFINITION,
 });
 
 export const input = (nme: string, fields: Field[], dvs?: Directive[]): InputObjectTypeDefinitionNode => ({
   name: name(nme),
   fields: inputValues(fields),
-  kind: 'InputObjectTypeDefinition',
+  kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
   directives: directives(dvs),
 });
 
 export const object = (nme: string, fds: Field[], interfaces?: string[], dvs?: Directive[]): ObjectTypeDefinitionNode => ({
   name: name(nme),
   fields: fields(fds),
-  kind: 'ObjectTypeDefinition',
-  interfaces: interfaces && interfaces.map((i) => namedType(i)),
+  kind: Kind.OBJECT_TYPE_DEFINITION,
+  interfaces: interfaces?.map((i) => namedType(i)),
   directives: directives(dvs),
 });
 
 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)),
+  kind: Kind.INTERFACE_TYPE_DEFINITION,
+  interfaces: interfaces?.map((i) => namedType(i)),
   directives: directives(dvs),
 });
 
 export const inputValues = (fields: Field[]): InputValueDefinitionNode[] =>
   fields.map(
     (field): InputValueDefinitionNode => ({
-      kind: 'InputValueDefinition',
+      kind: Kind.INPUT_VALUE_DEFINITION,
       name: name(field.name),
       type: fieldType(field),
       defaultValue: field.defaultValue === undefined ? undefined : value(field.defaultValue),
       directives: directives(field.directives),
-    })
+    }),
   );
 
 export const fields = (fields: Field[]): FieldDefinitionNode[] =>
   fields.map(
     (field): FieldDefinitionNode => ({
-      kind: 'FieldDefinition',
+      kind: Kind.FIELD_DEFINITION,
       name: name(field.name),
       type: fieldType(field),
       arguments: field.args?.map((arg) => ({
-        kind: 'InputValueDefinition',
+        kind: Kind.INPUT_VALUE_DEFINITION,
         name: name(arg.name),
         type: fieldType(arg),
         defaultValue: arg.defaultValue === undefined ? undefined : value(arg.defaultValue),
       })),
       directives: directives(field.directives),
-    })
+    }),
   );
 
 export const inputValue = (
@@ -118,62 +119,62 @@ export const inputValue = (
   type: TypeNode,
   dvs?: Directive[],
   description?: string,
-  defaultValue?: Value
+  defaultValue?: Value,
 ): InputValueDefinitionNode => ({
   name: name(nme),
   type,
-  kind: 'InputValueDefinition',
+  kind: Kind.INPUT_VALUE_DEFINITION,
   directives: directives(dvs),
   defaultValue: defaultValue ? value(defaultValue) : undefined,
   description: description ? (value(description) as StringValueNode) : undefined,
 });
 
-export const directives = (directives?: Directive[]): DirectiveNode[] | undefined =>
+export const directives = (directives?: Directive[]): ConstDirectiveNode[] | undefined =>
   directives?.map(
-    (directive): DirectiveNode => ({
-      kind: 'Directive',
+    (directive): ConstDirectiveNode => ({
+      kind: Kind.DIRECTIVE,
       name: name(directive.name),
       arguments: args(directive.values),
-    })
+    }),
   );
 
-export const args = (ags: Values | undefined): ReadonlyArray<ArgumentNode> | undefined =>
+export const args = (ags: Values | undefined): readonly ConstArgumentNode[] | undefined =>
   ags?.map(
-    (argument): ArgumentNode => ({
-      kind: 'Argument',
+    (argument): ConstArgumentNode => ({
+      kind: Kind.ARGUMENT,
       name: name(argument.name),
       value: value(argument.values),
-    })
+    }),
   );
 
 export const enm = (nme: string, values: string[]): EnumTypeDefinitionNode => ({
   name: name(nme),
-  kind: 'EnumTypeDefinition',
+  kind: Kind.ENUM_TYPE_DEFINITION,
   values: values.map(
     (v): EnumValueDefinitionNode => ({
-      kind: 'EnumValueDefinition',
+      kind: Kind.ENUM_VALUE_DEFINITION,
       name: name(v),
-    })
+    }),
   ),
 });
 
 export const nonNull = (type: NamedTypeNode | ListTypeNode): NonNullTypeNode => ({
   type,
-  kind: 'NonNullType',
+  kind: Kind.NON_NULL_TYPE,
 });
 
 export const namedType = (nme: string): NamedTypeNode => ({
-  kind: 'NamedType',
+  kind: Kind.NAMED_TYPE,
   name: name(nme),
 });
 
 export const list = (type: TypeNode): ListTypeNode => ({
   type,
-  kind: 'ListType',
+  kind: Kind.LIST_TYPE,
 });
 
 export const name = (name: string): NameNode => ({
-  kind: 'Name',
+  kind: Kind.NAME,
   value: name,
 });
 
@@ -185,61 +186,62 @@ export const fieldType = (field: Field) => {
   if (field.nonNull) {
     type = nonNull(type);
   }
+
   return type;
 };
 
-export const value = (val: Value = null): ValueNode =>
+export const value = (val: Value = null): ConstValueNode =>
   val === null
     ? {
-        kind: 'NullValue',
+        kind: Kind.NULL,
       }
     : typeof val === 'boolean'
-    ? {
-        kind: 'BooleanValue',
-        value: val,
-      }
-    : typeof val === 'number'
-    ? {
-        kind: 'IntValue',
-        value: `${val}`,
-      }
-    : typeof val === 'string'
-    ? {
-        kind: 'StringValue',
-        value: val,
-      }
-    : val instanceof Symbol
-    ? {
-        kind: 'EnumValue',
-        value: val.description,
-      }
-    : Array.isArray(val)
-    ? {
-        kind: 'ListValue',
-        values: val.map(value),
-      }
-    : val instanceof DateTime
-    ? {
-        kind: 'StringValue',
-        value: val.toString(),
-      }
-    : val instanceof Dayjs
-    ? {
-        kind: 'StringValue',
-        value: val.toISOString(),
-      }
-    : typeof val === 'object'
-    ? {
-        kind: 'ObjectValue',
-        fields: Object.keys(val).map(
-          (nme): ObjectFieldNode => ({
-            kind: 'ObjectField',
-            name: name(nme),
-            value: value(val[nme]),
-          })
-        ),
-      }
-    : doThrow(`Unsupported value ${val}`);
+      ? {
+          kind: Kind.BOOLEAN,
+          value: val,
+        }
+      : typeof val === 'number'
+        ? {
+            kind: Kind.INT,
+            value: `${val}`,
+          }
+        : typeof val === 'string'
+          ? {
+              kind: Kind.STRING,
+              value: val,
+            }
+          : val instanceof Symbol
+            ? {
+                kind: Kind.ENUM,
+                value: val.description!,
+              }
+            : Array.isArray(val)
+              ? {
+                  kind: Kind.LIST,
+                  values: val.map(value),
+                }
+              : val instanceof DateTime
+                ? {
+                    kind: Kind.STRING,
+                    value: val.toString(),
+                  }
+                : val instanceof Dayjs
+                  ? {
+                      kind: Kind.STRING,
+                      value: val.toISOString(),
+                    }
+                  : typeof val === 'object'
+                    ? {
+                        kind: Kind.OBJECT,
+                        fields: Object.keys(val).map(
+                          (nme): ConstObjectFieldNode => ({
+                            kind: Kind.OBJECT_FIELD,
+                            name: name(nme),
+                            value: value(val[nme]),
+                          }),
+                        ),
+                      }
+                    : doThrow(`Unsupported value ${val}`);
 
 const doThrow = (message: string) => {
   throw new Error(message);

package/src/utils/dates.ts

@@ -3,7 +3,7 @@ import { DateTime } from 'luxon';
 
 export type DateLibrary = 'luxon' | 'dayjs';
 
-export const DATE_CLASS: { [key in DateLibrary]: string } = {
+export const DATE_CLASS: Record<DateLibrary, string> = {
   luxon: 'DateTime',
   dayjs: 'Dayjs',
 };
@@ -19,9 +19,9 @@ export const anyDateToLuxon = (date: unknown, zone: string | undefined, fallback
   if (!date) {
     if (fallbackToNow) {
       return DateTime.local({ zone });
-    } else {
-      return undefined;
     }
+
+    return undefined;
   }
 
   if (DateTime.isDateTime(date)) {

package/tests/generated/api/index.ts

@@ -678,7 +678,7 @@ export type User = {
   deletedReactions: Array<Reaction>;
   deletedReviews: Array<Review>;
   id: Scalars['ID']['output'];
-  role?: Maybe<Role>;
+  role: Role;
   updatedAnswers: Array<Answer>;
   updatedManyObjects: Array<SomeObject>;
   updatedQuestions: Array<Question>;
@@ -1172,7 +1172,7 @@ export type UserResolvers<ContextType = any, ParentType extends ResolversParentT
   deletedReactions?: Resolver<Array<ResolversTypes['Reaction']>, ParentType, ContextType, Partial<UserDeletedReactionsArgs>>;
   deletedReviews?: Resolver<Array<ResolversTypes['Review']>, ParentType, ContextType, Partial<UserDeletedReviewsArgs>>;
   id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
-  role?: Resolver<Maybe<ResolversTypes['Role']>, ParentType, ContextType>;
+  role?: Resolver<ResolversTypes['Role'], ParentType, ContextType>;
   updatedAnswers?: Resolver<Array<ResolversTypes['Answer']>, ParentType, ContextType, Partial<UserUpdatedAnswersArgs>>;
   updatedManyObjects?: Resolver<Array<ResolversTypes['SomeObject']>, ParentType, ContextType, Partial<UserUpdatedManyObjectsArgs>>;
   updatedQuestions?: Resolver<Array<ResolversTypes['Question']>, ParentType, ContextType, Partial<UserUpdatedQuestionsArgs>>;