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

package/dist/types/graphql/schema-utils/entry-reference-util.d.ts

@@ -1,4 +1,5 @@
 import { GraphQLNullableType, GraphQLObjectType } from 'graphql';
 import { ApolloContext } from '../../client.ts';
-export declare function getReferencedEntryIds(rootType: GraphQLObjectType, context: ApolloContext, fieldName: string | null, type: GraphQLNullableType, data: any): Promise<string[]>;
+import { EntryData } from '@commitspark/git-adapter';
+export declare function getReferencedEntryIds(rootType: GraphQLObjectType, context: ApolloContext, fieldName: string | null, type: GraphQLNullableType, data: EntryData | EntryData[]): Promise<string[]>;
 //# sourceMappingURL=entry-reference-util.d.ts.map

package/dist/types/graphql/schema-utils/entry-reference-util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry-reference-util.d.ts","sourceRoot":"","sources":["../../../../src/graphql/schema-utils/entry-reference-util.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EAKlB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AA+F/C,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,GAAG,GACR,OAAO,CAAC,MAAM,EAAE,CAAC,CAqFnB"}
+{"version":3,"file":"entry-reference-util.d.ts","sourceRoot":"","sources":["../../../../src/graphql/schema-utils/entry-reference-util.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EAOlB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAQ/C,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AA8FpD,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,SAAS,GAAG,SAAS,EAAE,GAC5B,OAAO,CAAC,MAAM,EAAE,CAAC,CA2InB"}

package/dist/types/graphql/util.d.ts

@@ -0,0 +1,2 @@
+export declare function isRecord(obj: unknown): obj is Record<string, unknown>;
+//# sourceMappingURL=util.d.ts.map

package/dist/types/graphql/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/graphql/util.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUrE"}

package/package.json

@@ -9,7 +9,7 @@
     "gitops",
     "api"
   ],
-  "version": "1.0.0-beta.7",
+  "version": "1.0.0-beta.8",
   "license": "ISC",
   "private": false,
   "files": [
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@apollo/server": "^5.2.0",
-    "@commitspark/git-adapter": "^0.20.0",
+    "@commitspark/git-adapter": "^0.30.0",
     "@graphql-tools/schema": "^9.0.0",
     "@graphql-tools/utils": "^9.0.0"
   },

package/src/graphql/errors.ts

@@ -5,7 +5,6 @@ export const enum ErrorCode {
   BAD_USER_INPUT = 'BAD_USER_INPUT',
   NOT_FOUND = 'NOT_FOUND',
   BAD_REPOSITORY_DATA = 'BAD_REPOSITORY_DATA',
-  SCHEMA_DATA_MISMATCH = 'SCHEMA_DATA_MISMATCH',
   BAD_SCHEMA = 'BAD_SCHEMA',
   INTERNAL_ERROR = 'INTERNAL_ERROR',
   IN_USE = 'IN_USE',

package/src/graphql/queries-mutations-generator.ts

@@ -1,6 +1,5 @@
 import { EntryData } from '@commitspark/git-adapter'
-import { ApolloContext } from '../client.ts'
-import { GraphQLFieldResolver, GraphQLObjectType } from 'graphql'
+import { GraphQLObjectType } from 'graphql'
 import { queryEveryResolver } from './resolvers/query-mutation-resolvers/query-every-resolver.ts'
 import { queryByIdResolver } from './resolvers/query-mutation-resolvers/query-by-id-resolver.ts'
 import { mutationCreateResolver } from './resolvers/query-mutation-resolvers/mutation-create-resolver.ts'
@@ -19,12 +18,12 @@ export function generateQueriesAndMutations(
     // pluralization of user-provided typeName
     const queryEveryName = `every${typeName}`
     const queryEveryString = `${queryEveryName}: [${objectType.name}!]`
-    const queryEveryResolverFunc: GraphQLFieldResolver<
-      any,
-      ApolloContext,
-      any,
-      Promise<EntryData[]>
-    > = (source, args, context, info) =>
+    const queryEveryResolverFunc: QueryMutationResolver<EntryData[]> = (
+      source,
+      args,
+      context,
+      info,
+    ) =>
       queryEveryResolver(source, args, { ...context, type: objectType }, info)
 
     const queryByIdName = typeName
@@ -69,7 +68,7 @@ export function generateQueriesAndMutations(
 
     const deleteMutationName = `delete${typeName}`
     const deleteMutationString = `${deleteMutationName}(id: ID!, commitMessage: String): ID`
-    const deleteMutationResolver: QueryMutationResolver<EntryData> = (
+    const deleteMutationResolver: QueryMutationResolver<string> = (
       source,
       args,
       context,
@@ -112,7 +111,7 @@ export function generateQueriesAndMutations(
   })
 }
 
-export function generateTypeNameQuery(): GeneratedQuery<Promise<string>> {
+export function generateTypeNameQuery(): GeneratedQuery {
   const entryTypeQueryName = '_typeName'
   const entryTypeQueryString = `${entryTypeQueryName}(id: ID!): String!`
 
@@ -124,15 +123,15 @@ export function generateTypeNameQuery(): GeneratedQuery<Promise<string>> {
 }
 
 export interface GeneratedSchema {
-  queryEvery: GeneratedQuery<Promise<EntryData[]>>
-  queryById: GeneratedQuery<Promise<EntryData>>
-  createMutation: GeneratedQuery<Promise<EntryData>>
-  updateMutation: GeneratedQuery<Promise<EntryData>>
-  deleteMutation: GeneratedQuery<Promise<EntryData>>
+  queryEvery: GeneratedQuery
+  queryById: GeneratedQuery
+  createMutation: GeneratedQuery
+  updateMutation: GeneratedQuery
+  deleteMutation: GeneratedQuery
 }
 
-export interface GeneratedQuery<T> {
+export interface GeneratedQuery {
   name: string
   schemaString: string
-  resolver: GraphQLFieldResolver<any, ApolloContext, any, T>
+  resolver: QueryMutationResolver<EntryData | EntryData[] | string>
 }

package/src/graphql/resolvers/field-resolvers/entry-reference-resolver.ts

@@ -1,13 +1,13 @@
-import { FieldResolver, FieldResolverContext } from './types.ts'
-import { GraphQLResolveInfo, isNamedType } from 'graphql'
+import { FieldResolver } from './types.ts'
+import { isNamedType } from 'graphql'
 import { findById } from '../../../persistence/persistence.ts'
 import { createError, ErrorCode } from '../../errors.ts'
 
-export const resolveEntryReference: FieldResolver<any> = async (
-  fieldValue: any,
-  args: any,
-  context: FieldResolverContext,
-  info: GraphQLResolveInfo,
+export const resolveEntryReference: FieldResolver = async (
+  fieldValue,
+  args,
+  context,
+  info,
 ) => {
   void info
   if (!isNamedType(context.currentType)) {
@@ -20,6 +20,21 @@ export const resolveEntryReference: FieldResolver<any> = async (
     )
   }
 
+  if (
+    fieldValue === null ||
+    typeof fieldValue !== 'object' ||
+    !('id' in fieldValue) ||
+    typeof fieldValue.id !== 'string'
+  ) {
+    throw createError(
+      'Expected fieldValue.id to be a string.',
+      ErrorCode.INTERNAL_ERROR,
+      {
+        fieldValue: fieldValue,
+      },
+    )
+  }
+
   const entry = await findById(context, fieldValue.id)
 
   return { ...entry.data, id: entry.id }

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

@@ -1,8 +1,6 @@
-import { FieldResolver, FieldResolverContext, ResolvedEntryData } from './types.ts'
-import { EntryData } from '@commitspark/git-adapter'
+import { FieldResolver } from './types.ts'
 import {
   GraphQLNonNull,
-  GraphQLResolveInfo,
   GraphQLUnionType,
   isListType,
   isNonNullType,
@@ -17,12 +15,12 @@ import { resolveEntryReference } from './entry-reference-resolver.ts'
 import { resolveUnionValue } from './union-value-resolver.ts'
 import { createError, ErrorCode } from '../../errors.ts'
 
-export const resolveFieldDefaultValue: FieldResolver<any> = async (
-  fieldValue: any,
-  args: any,
-  context: FieldResolverContext,
-  info: GraphQLResolveInfo,
-): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> => {
+export const resolveFieldDefaultValue: FieldResolver = async (
+  fieldValue,
+  args,
+  context,
+  info,
+) => {
   if (isNonNullType(context.currentType)) {
     return resolveFieldDefaultValue(
       fieldValue,
@@ -46,7 +44,7 @@ export const resolveFieldDefaultValue: FieldResolver<any> = async (
     if (!Array.isArray(fieldValue)) {
       throw createError(
         `Expected array while resolving value for field "${info.fieldName}".`,
-        ErrorCode.SCHEMA_DATA_MISMATCH,
+        ErrorCode.BAD_REPOSITORY_DATA,
         {
           fieldName: info.fieldName,
           fieldValue: fieldValue,

package/src/graphql/resolvers/field-resolvers/types.ts

@@ -2,16 +2,18 @@ import { GraphQLFieldResolver, GraphQLOutputType } from 'graphql'
 import { EntryData } from '@commitspark/git-adapter'
 import { ApolloContext } from '../../../client.ts'
 
-export interface FieldResolverContext extends ApolloContext {
+interface FieldResolverContext extends ApolloContext {
   currentType: GraphQLOutputType
   hasNonNullParent?: boolean
 }
 
+type FieldResolverSource = EntryData | EntryData[]
+
 export type FieldResolver<
-  TSource,
+  TSource = FieldResolverSource,
   TContext = FieldResolverContext,
-  TArgs = any,
-  TResult = Promise<ResolvedEntryData<EntryData | EntryData[] | null>>,
+  TArgs = Record<string, unknown>,
+  TResult = Promise<RecursiveArray<EntryData>>,
 > = GraphQLFieldResolver<TSource, TContext, TArgs, TResult>
 
-export type ResolvedEntryData<T> = T | Array<ResolvedEntryData<T>>
+export type RecursiveArray<T> = T | Array<RecursiveArray<T>>

package/src/graphql/resolvers/field-resolvers/union-value-resolver.ts

@@ -1,13 +1,11 @@
 import { EntryData } from '@commitspark/git-adapter'
-import { FieldResolver, ResolvedEntryData } from './types.ts'
+import { FieldResolver } from './types.ts'
 import {
   getUnionTypeNameFromFieldValue,
   getUnionValue,
 } from '../../schema-utils/union-type-util.ts'
 
-export const resolveUnionValue: FieldResolver<any> = async (
-  fieldValue: any,
-): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> => {
+export const resolveUnionValue: FieldResolver = async (fieldValue) => {
   const typeName = getUnionTypeNameFromFieldValue(fieldValue)
   const unionValue = getUnionValue(fieldValue)
 

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.ts'
 import { resolveFieldDefaultValue } from './field-resolvers/field-default-value-resolver.ts'
-import { ApolloContext } from '../../client.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.ts'
-import { GraphQLFieldResolver, isObjectType } from 'graphql'
+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.ts'
+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.ts'
-import { Entry, EntryData, EntryDraft } from '@commitspark/git-adapter'
+import { Entry, EntryDraft } from '@commitspark/git-adapter'
 import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
-import { GraphQLFieldResolver, isObjectType } from 'graphql'
-import { QueryMutationResolverContext } from '../types.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,8 +1,8 @@
 import { findById, findByTypeId } from '../../../persistence/persistence.ts'
 import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
-import { GraphQLFieldResolver, isObjectType } from 'graphql'
+import { isObjectType } from 'graphql'
 import { EntryData, EntryDraft } from '@commitspark/git-adapter'
-import { QueryMutationResolverContext } from '../types.ts'
+import { QueryMutationResolver } from '../types.ts'
 import { createError, ErrorCode } from '../../errors.ts'
 
 function mergeData(
@@ -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.ts'
-import { GraphQLFieldResolver } from 'graphql'
-import { QueryMutationResolverContext } from '../types.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.ts'
-import { GraphQLFieldResolver } from 'graphql'
-import { QueryMutationResolverContext } from '../types.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.ts'
-import { GraphQLFieldResolver } from 'graphql'
-import { ApolloContext } from '../../../client.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.ts'
 import { getTypeById } from '../../../persistence/persistence.ts'
-import { GraphQLTypeResolver } from 'graphql'
 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