@commitspark/graphql-api 1.0.0-beta.6 → 1.0.0-beta.8

package/src/graphql/resolvers/object-type-field-default-value-resolver-generator.ts

@@ -1,6 +1,5 @@
 import {
   GraphQLField,
-  GraphQLFieldResolver,
   GraphQLObjectType,
   GraphQLOutputType,
   GraphQLSchema,
@@ -9,10 +8,10 @@ import {
   isObjectType,
   isUnionType,
 } from 'graphql'
-import { EntryData } from '@commitspark/git-adapter'
-import { ResolvedEntryData } from './field-resolvers/types'
-import { resolveFieldDefaultValue } from './field-resolvers/field-default-value-resolver'
-import { ApolloContext } from '../../client'
+import { resolveFieldDefaultValue } from './field-resolvers/field-default-value-resolver.ts'
+import { createError, ErrorCode } from '../errors.ts'
+import { isRecord } from '../util.ts'
+import { ContextInjectionResolver } from './types.ts'
 
 function requiresCustomDefaultValueResolver(type: GraphQLOutputType): boolean {
   if (isNonNullType(type)) {
@@ -29,10 +28,11 @@ function requiresCustomDefaultValueResolver(type: GraphQLOutputType): boolean {
 
 function getFieldsForCustomDefaultValueResolver(
   objectType: GraphQLObjectType,
-): GraphQLField<any, any>[] {
+): GraphQLField<unknown, unknown>[] {
   const fields = []
   for (const fieldsKey in objectType.getFields()) {
-    const field: GraphQLField<any, any> = objectType.getFields()[fieldsKey]
+    const field: GraphQLField<unknown, unknown> =
+      objectType.getFields()[fieldsKey]
     if (requiresCustomDefaultValueResolver(field.type)) {
       fields.push(field)
     }
@@ -40,38 +40,54 @@ function getFieldsForCustomDefaultValueResolver(
   return fields
 }
 
-type FieldResolversRecord = Record<
+type RecordOfContextInjectionResolvers = Record<
   string,
-  GraphQLFieldResolver<
-    any,
-    ApolloContext,
-    any,
-    Promise<ResolvedEntryData<EntryData | EntryData[] | null>>
-  >
+  ContextInjectionResolver
 >
 
 export function createObjectTypeFieldResolvers(
   schema: GraphQLSchema,
-): Record<string, FieldResolversRecord> {
-  const fieldResolversByType: Record<string, FieldResolversRecord> = {}
+): Record<string, RecordOfContextInjectionResolvers> {
+  const adapterResolversByType: Record<
+    string,
+    RecordOfContextInjectionResolvers
+  > = {}
+
   for (const typeName of Object.keys(schema.getTypeMap())) {
     const type = schema.getType(typeName)
     if (!isObjectType(type) || type.name.startsWith('__')) {
       continue
     }
+
+    // only some fields need a custom resolver that generates a default result value on missing source data
     const fieldsForCustomDefaultValueResolver =
       getFieldsForCustomDefaultValueResolver(type)
 
-    const fieldResolversByFieldName: FieldResolversRecord = {}
+    const fieldResolversByFieldName: Record<string, ContextInjectionResolver> =
+      {}
     for (const field of fieldsForCustomDefaultValueResolver) {
-      fieldResolversByFieldName[field.name] = (
-        obj,
-        args,
-        context,
-        info,
-      ): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> =>
-        resolveFieldDefaultValue(
-          field.name in obj ? obj[field.name] : undefined,
+      // the resolvers created here serve as adapters to inject additional context information needed by actual field resolvers
+      fieldResolversByFieldName[field.name] = (obj, args, context, info) => {
+        let fieldSourceData = null
+        if (obj) {
+          fieldSourceData = obj[field.name] ?? null
+          if (
+            fieldSourceData !== null &&
+            !(isRecord(fieldSourceData) || Array.isArray(fieldSourceData))
+          ) {
+            throw createError(
+              `Expected an object or array as data for passing to resolver of field "${field.name}" in type "${typeName}".`,
+              ErrorCode.BAD_REPOSITORY_DATA,
+              {
+                fieldName: field.name,
+                typeName: typeName,
+              },
+            )
+          }
+        }
+
+        return resolveFieldDefaultValue(
+          fieldSourceData,
           args,
           {
             ...context,
@@ -79,12 +95,13 @@ export function createObjectTypeFieldResolvers(
           },
           info,
         )
+      }
     }
 
     if (Object.keys(fieldResolversByFieldName).length > 0) {
-      fieldResolversByType[typeName] = fieldResolversByFieldName
+      adapterResolversByType[typeName] = fieldResolversByFieldName
     }
   }
 
-  return fieldResolversByType
+  return adapterResolversByType
 }

package/src/graphql/resolvers/query-mutation-resolvers/mutation-create-resolver.ts

@@ -1,20 +1,20 @@
-import { findById, findByTypeId } from '../../../persistence/persistence'
-import { GraphQLFieldResolver, isObjectType } from 'graphql'
-import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
+import { findById, findByTypeId } from '../../../persistence/persistence.ts'
+import { isObjectType } from 'graphql'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
 import {
   ENTRY_ID_INVALID_CHARACTERS,
   EntryData,
   EntryDraft,
 } from '@commitspark/git-adapter'
-import { QueryMutationResolverContext } from '../types'
-import { createError, ErrorCode } from '../../errors'
+import { QueryMutationResolver } from '../types.ts'
+import { createError, ErrorCode } from '../../errors.ts'
 
-export const mutationCreateResolver: GraphQLFieldResolver<
-  any,
-  QueryMutationResolverContext,
-  any,
-  Promise<EntryData>
-> = async (source, args, context, info) => {
+export const mutationCreateResolver: QueryMutationResolver<EntryData> = async (
+  source,
+  args,
+  context,
+  info,
+) => {
   if (!isObjectType(context.type)) {
     throw createError(
       `Entry of type "${context.type.name}" cannot be created as is not an ObjectType.`,
@@ -57,7 +57,7 @@ export const mutationCreateResolver: GraphQLFieldResolver<
     context,
     null,
     info.returnType,
-    args.data,
+    args.data ?? null,
   )
 
   const referencedEntryUpdates: EntryDraft[] = []
@@ -84,7 +84,7 @@ export const mutationCreateResolver: GraphQLFieldResolver<
       type: context.type.name,
       referencedBy: [],
     },
-    data: args.data,
+    data: args.data ?? null,
     deletion: false,
   }
 
@@ -94,7 +94,7 @@ export const mutationCreateResolver: GraphQLFieldResolver<
     entries: [newEntryDraft, ...referencedEntryUpdates],
     message: args.commitMessage,
   })
-  context.setCurrentHash(commit.ref)
+  context.setCurrentHash(commit.commitHash)
 
   const newEntry = await findByTypeId(context, context.type.name, args.id)
   return { ...newEntry.data, id: newEntry.id }

package/src/graphql/resolvers/query-mutation-resolvers/mutation-delete-resolver.ts

@@ -1,16 +1,16 @@
-import { findById, findByTypeId } from '../../../persistence/persistence'
-import { Entry, EntryData, EntryDraft } from '@commitspark/git-adapter'
-import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
-import { GraphQLFieldResolver, isObjectType } from 'graphql'
-import { QueryMutationResolverContext } from '../types'
-import { createError, ErrorCode } from '../../errors'
+import { findById, findByTypeId } from '../../../persistence/persistence.ts'
+import { Entry, EntryDraft } from '@commitspark/git-adapter'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
+import { isObjectType } from 'graphql'
+import { QueryMutationResolver } from '../types.ts'
+import { createError, ErrorCode } from '../../errors.ts'
 
-export const mutationDeleteResolver: GraphQLFieldResolver<
-  any,
-  QueryMutationResolverContext,
-  any,
-  Promise<EntryData>
-> = async (source, args, context, info) => {
+export const mutationDeleteResolver: QueryMutationResolver<string> = async (
+  source,
+  args,
+  context,
+  info,
+) => {
   const entry: Entry = await findByTypeId(context, context.type.name, args.id)
 
   if (entry.metadata.referencedBy && entry.metadata.referencedBy.length > 0) {
@@ -41,7 +41,7 @@ export const mutationDeleteResolver: GraphQLFieldResolver<
     context,
     null,
     entryType,
-    entry.data,
+    entry.data ?? null,
   )
   const referencedEntryUpdates: EntryDraft[] = []
   for (const referencedEntryId of referencedEntryIds) {
@@ -70,7 +70,7 @@ export const mutationDeleteResolver: GraphQLFieldResolver<
     ],
     message: args.commitMessage,
   })
-  context.setCurrentHash(commit.ref)
+  context.setCurrentHash(commit.commitHash)
 
   return args.id
 }

package/src/graphql/resolvers/query-mutation-resolvers/mutation-update-resolver.ts

@@ -1,9 +1,9 @@
-import { findById, findByTypeId } from '../../../persistence/persistence'
-import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
-import { GraphQLFieldResolver, isObjectType } from 'graphql'
+import { findById, findByTypeId } from '../../../persistence/persistence.ts'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
+import { isObjectType } from 'graphql'
 import { EntryData, EntryDraft } from '@commitspark/git-adapter'
-import { QueryMutationResolverContext } from '../types'
-import { createError, ErrorCode } from '../../errors'
+import { QueryMutationResolver } from '../types.ts'
+import { createError, ErrorCode } from '../../errors.ts'
 
 function mergeData(
   existingEntryData: EntryData,
@@ -15,12 +15,12 @@ function mergeData(
   }
 }
 
-export const mutationUpdateResolver: GraphQLFieldResolver<
-  any,
-  QueryMutationResolverContext,
-  any,
-  Promise<EntryData>
-> = async (source, args, context, info) => {
+export const mutationUpdateResolver: QueryMutationResolver<EntryData> = async (
+  source,
+  args,
+  context,
+  info,
+) => {
   if (!isObjectType(context.type)) {
     throw createError(
       `Type "${context.type.name}" cannot be mutated as is not an ObjectType.`,
@@ -36,10 +36,10 @@ export const mutationUpdateResolver: GraphQLFieldResolver<
     context,
     null,
     info.returnType,
-    existingEntry.data,
+    existingEntry.data ?? null,
   )
 
-  const mergedData = mergeData(existingEntry.data ?? null, args.data)
+  const mergedData = mergeData(existingEntry.data ?? null, args.data ?? null)
   const updatedReferencedEntryIds = await getReferencedEntryIds(
     context.type,
     context,
@@ -74,10 +74,10 @@ export const mutationUpdateResolver: GraphQLFieldResolver<
   }
   for (const newlyReferencedEntryId of newlyReferencedIds) {
     const newlyReferencedEntry = await findById(context, newlyReferencedEntryId)
-    const updatedReferenceList: string[] =
-      newlyReferencedEntry.metadata.referencedBy ?? []
-    updatedReferenceList.push(args.id)
-    updatedReferenceList.sort()
+    const updatedReferenceList: string[] = [
+      ...(newlyReferencedEntry.metadata.referencedBy ?? []),
+      args.id,
+    ].sort()
     referencedEntryUpdates.push({
       ...newlyReferencedEntry,
       metadata: {
@@ -97,7 +97,7 @@ export const mutationUpdateResolver: GraphQLFieldResolver<
     ],
     message: args.commitMessage,
   })
-  context.setCurrentHash(commit.ref)
+  context.setCurrentHash(commit.commitHash)
 
   const updatedEntry = await findByTypeId(context, context.type.name, args.id)
   return { ...updatedEntry.data, id: updatedEntry.id }

package/src/graphql/resolvers/query-mutation-resolvers/query-by-id-resolver.ts

@@ -1,14 +1,13 @@
 import { EntryData } from '@commitspark/git-adapter'
-import { findByTypeId } from '../../../persistence/persistence'
-import { GraphQLFieldResolver } from 'graphql'
-import { QueryMutationResolverContext } from '../types'
+import { findByTypeId } from '../../../persistence/persistence.ts'
+import { QueryMutationResolver } from '../types.ts'
 
-export const queryByIdResolver: GraphQLFieldResolver<
-  any,
-  QueryMutationResolverContext,
-  any,
-  Promise<EntryData>
-> = async (_obj, args, context, info) => {
+export const queryByIdResolver: QueryMutationResolver<EntryData> = async (
+  _source,
+  args,
+  context,
+  info,
+) => {
   void info
   const entry = await findByTypeId(context, context.type.name, args.id)
 

package/src/graphql/resolvers/query-mutation-resolvers/query-every-resolver.ts

@@ -1,14 +1,13 @@
 import { EntryData } from '@commitspark/git-adapter'
-import { findByType } from '../../../persistence/persistence'
-import { GraphQLFieldResolver } from 'graphql'
-import { QueryMutationResolverContext } from '../types'
+import { findByType } from '../../../persistence/persistence.ts'
+import { QueryMutationResolver } from '../types.ts'
 
-export const queryEveryResolver: GraphQLFieldResolver<
-  any,
-  QueryMutationResolverContext,
-  any,
-  Promise<EntryData[]>
-> = async (_obj, _args, context, info) => {
+export const queryEveryResolver: QueryMutationResolver<EntryData[]> = async (
+  _source,
+  _args,
+  context,
+  info,
+) => {
   void info
   const entries = await findByType(context, context.type.name)
 

package/src/graphql/resolvers/query-mutation-resolvers/query-type-by-id-resolver.ts

@@ -1,13 +1,12 @@
-import { getTypeById } from '../../../persistence/persistence'
-import { GraphQLFieldResolver } from 'graphql'
-import { ApolloContext } from '../../../client'
+import { getTypeById } from '../../../persistence/persistence.ts'
+import { QueryMutationResolver } from '../types.ts'
 
-export const queryTypeByIdResolver: GraphQLFieldResolver<
-  any,
-  ApolloContext,
-  any,
-  Promise<string>
-> = async (_source, args, context, info) => {
+export const queryTypeByIdResolver: QueryMutationResolver<string> = async (
+  _source,
+  args,
+  context,
+  info,
+) => {
   void info
   return getTypeById(context, args.id)
 }

package/src/graphql/resolvers/query-mutation-resolvers/union-type-resolver.ts

@@ -1,18 +1,30 @@
-import { ApolloContext } from '../../../client'
-import { getTypeById } from '../../../persistence/persistence'
-import { GraphQLTypeResolver } from 'graphql'
-import { buildsOnTypeWithEntryDirective } from '../../schema-utils/entry-type-util'
+import { getTypeById } from '../../../persistence/persistence.ts'
+import { buildsOnTypeWithEntryDirective } from '../../schema-utils/entry-type-util.ts'
+import { UnionTypeResolver } from '../types.ts'
+import { createError, ErrorCode } from '../../errors.ts'
 
-export const unionTypeResolver: GraphQLTypeResolver<
-  any,
-  ApolloContext
-> = async (obj, context, info, abstractType) => {
+export const unionTypeResolver: UnionTypeResolver = async (
+  source,
+  context,
+  info,
+  abstractType,
+) => {
   if (buildsOnTypeWithEntryDirective(abstractType)) {
-    return getTypeById(context, obj.id)
+    if (!('id' in source) || typeof source.id !== 'string') {
+      throw createError(
+        `Expected key "id" of type string in data while resolving reference-based union type for field "${info.fieldName}".`,
+        ErrorCode.BAD_REPOSITORY_DATA,
+        {
+          typeName: abstractType.name,
+          fieldName: info.fieldName,
+        },
+      )
+    }
+    return getTypeById(context, source.id)
   } else {
     // We have injected an internal `__typename` field into the data of fields pointing to a non-entry union
     // in UnionValueResolver. This artificial field holds the type information we need here.
-    return obj.__typename
+    return source.__typename
   }
 
   // TODO same for interface type: https://www.apollographql.com/docs/apollo-server/data/resolvers/#resolving-unions-and-interfaces

package/src/graphql/resolvers/types.ts

@@ -1,14 +1,36 @@
-import { ApolloContext } from '../../client'
-import { GraphQLNamedType } from 'graphql/type'
-import { GraphQLFieldResolver } from 'graphql'
+import { ApolloContext } from '../../client.ts'
+import {
+  GraphQLFieldResolver,
+  GraphQLNamedType,
+  GraphQLTypeResolver,
+} from 'graphql'
+import { EntryData } from '@commitspark/git-adapter'
+import { RecursiveArray } from './field-resolvers/types.ts'
 
 export interface QueryMutationResolverContext extends ApolloContext {
   type: GraphQLNamedType
 }
 
 export type QueryMutationResolver<ResultType> = GraphQLFieldResolver<
-  any,
-  ApolloContext,
-  any,
+  unknown,
+  QueryMutationResolverContext,
+  { id: string; data?: EntryData; commitMessage: string },
   Promise<ResultType>
 >
+
+export type UnionTypeResolver = GraphQLTypeResolver<
+  UnionTypeResolverSourceData,
+  ApolloContext
+>
+
+type UnionTypeResolverSourceData = EntryData & {
+  id?: string
+  __typename: string
+}
+
+export type ContextInjectionResolver = GraphQLFieldResolver<
+  EntryData,
+  ApolloContext,
+  Record<string, unknown>,
+  Promise<RecursiveArray<EntryData>>
+>

package/src/graphql/schema-generator.ts

@@ -1,26 +1,32 @@
 import {
   generateQueriesAndMutations,
   generateTypeNameQuery,
-} from './queries-mutations-generator'
+} from './queries-mutations-generator.ts'
 import {
   IExecutableSchemaDefinition,
   makeExecutableSchema,
 } from '@graphql-tools/schema'
-import { analyzeSchema } from './schema-analyzer'
+import { analyzeSchema } from './schema-analyzer.ts'
 import {
   generateIdInputTypeStrings,
   generateObjectInputTypeStrings,
   generateUnionInputTypeStrings,
-} from './input-type-generator'
-import { generateSchemaRootTypeStrings } from './schema-root-type-generator'
+} from './input-type-generator.ts'
+import { generateSchemaRootTypeStrings } from './schema-root-type-generator.ts'
 import { printSchemaWithDirectives } from '@graphql-tools/utils'
-import { unionTypeResolver } from './resolvers/query-mutation-resolvers/union-type-resolver'
-import { ApolloContext } from '../client'
-import { GraphQLFieldResolver, GraphQLTypeResolver } from 'graphql'
-import { getValidationResult } from './schema-validator'
+import { unionTypeResolver } from './resolvers/query-mutation-resolvers/union-type-resolver.ts'
+import { ApolloContext } from '../client.ts'
+import { GraphQLTypeResolver } from 'graphql'
+import { getValidationResult } from './schema-validator.ts'
+import { createObjectTypeFieldResolvers } from './resolvers/object-type-field-default-value-resolver-generator.ts'
+import { createError, ErrorCode } from './errors.ts'
+import { FieldResolver } from './resolvers/field-resolvers/types.ts'
+import {
+  ContextInjectionResolver,
+  QueryMutationResolver,
+  UnionTypeResolver,
+} from './resolvers/types.ts'
 import { EntryData } from '@commitspark/git-adapter'
-import { createObjectTypeFieldResolvers } from './resolvers/object-type-field-default-value-resolver-generator'
-import { createError, ErrorCode } from './errors'
 
 export async function generateSchema(
   context: ApolloContext,
@@ -52,19 +58,6 @@ export async function generateSchema(
   )
   const generatedTypeNameQuery = generateTypeNameQuery()
 
-  const generatedEntryReferenceResolvers: Record<
-    string,
-    Record<
-      string,
-      GraphQLFieldResolver<
-        Record<string, any>,
-        ApolloContext,
-        any,
-        Promise<EntryData | EntryData[] | null>
-      >
-    >
-  > = {}
-
   const generatedObjectInputTypeStrings = generateObjectInputTypeStrings(
     schemaAnalyzerResult.objectTypes,
   )
@@ -85,7 +78,10 @@ export async function generateSchema(
 
 ${generatedSchemaRootTypeStrings}`
 
-  const generatedUnionTypeResolvers: Record<string, UnionTypeResolver> = {}
+  const generatedUnionTypeResolvers: Record<
+    string,
+    { __resolveType: UnionTypeResolver }
+  > = {}
   for (const unionType of schemaAnalyzerResult.unionTypes) {
     generatedUnionTypeResolvers[unionType.name] = {
       __resolveType: unionTypeResolver,
@@ -96,11 +92,11 @@ ${generatedSchemaRootTypeStrings}`
 
   const generatedQueryResolvers: Record<
     string,
-    GraphQLFieldResolver<any, ApolloContext>
+    QueryMutationResolver<EntryData | EntryData[] | string>
   > = {}
   const generatedMutationResolvers: Record<
     string,
-    GraphQLFieldResolver<any, ApolloContext>
+    QueryMutationResolver<EntryData | EntryData[] | string>
   > = {}
 
   for (const element of generatedQueriesMutations) {
@@ -119,11 +115,14 @@ ${generatedSchemaRootTypeStrings}`
 
   const allGeneratedResolvers: Record<
     string,
-    Record<
-      string,
-      | GraphQLFieldResolver<any, ApolloContext>
-      | GraphQLTypeResolver<any, ApolloContext>
-    >
+    | Record<
+        string,
+        | QueryMutationResolver<EntryData | EntryData[] | string>
+        | GraphQLTypeResolver<unknown, ApolloContext>
+        | ContextInjectionResolver
+        | FieldResolver
+      >
+    | UnionTypeResolverRecord
   > = {
     Query: generatedQueryResolvers,
     Mutation: generatedMutationResolvers,
@@ -141,12 +140,6 @@ ${generatedSchemaRootTypeStrings}`
       ...generatedObjectTypeFieldResolvers[typeName],
     }
   }
-  for (const typeName of Object.keys(generatedEntryReferenceResolvers)) {
-    allGeneratedResolvers[typeName] = {
-      ...(allGeneratedResolvers[typeName] ?? {}),
-      ...generatedEntryReferenceResolvers[typeName],
-    }
-  }
 
   const typeDefs = [
     filteredOriginalSchemaString,
@@ -162,6 +155,6 @@ ${generatedSchemaRootTypeStrings}`
   }
 }
 
-interface UnionTypeResolver {
-  __resolveType: GraphQLTypeResolver<any, ApolloContext>
+interface UnionTypeResolverRecord {
+  __resolveType: UnionTypeResolver
 }

package/src/graphql/schema-root-type-generator.ts

@@ -1,8 +1,11 @@
-import { GeneratedQuery, GeneratedSchema } from './queries-mutations-generator'
+import {
+  GeneratedQuery,
+  GeneratedSchema,
+} from './queries-mutations-generator.ts'
 
 export function generateSchemaRootTypeStrings(
   generatedSchemas: GeneratedSchema[],
-  typeQuery: GeneratedQuery<Promise<string>>,
+  typeQuery: GeneratedQuery,
 ): string {
   return (
     `type Query {\n` +