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

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

package/src/graphql/resolvers/types.ts

@@ -1,13 +1,36 @@
 import { ApolloContext } from '../../client.ts'
-import { GraphQLFieldResolver, GraphQLNamedType } from 'graphql'
+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

@@ -16,11 +16,17 @@ import { generateSchemaRootTypeStrings } from './schema-root-type-generator.ts'
 import { printSchemaWithDirectives } from '@graphql-tools/utils'
 import { unionTypeResolver } from './resolvers/query-mutation-resolvers/union-type-resolver.ts'
 import { ApolloContext } from '../client.ts'
-import { GraphQLFieldResolver, GraphQLTypeResolver } from 'graphql'
+import { GraphQLTypeResolver } from 'graphql'
 import { getValidationResult } from './schema-validator.ts'
-import { EntryData } from '@commitspark/git-adapter'
 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'
 
 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.ts'
+import {
+  GeneratedQuery,
+  GeneratedSchema,
+} from './queries-mutations-generator.ts'
 
 export function generateSchemaRootTypeStrings(
   generatedSchemas: GeneratedSchema[],
-  typeQuery: GeneratedQuery<Promise<string>>,
+  typeQuery: GeneratedQuery,
 ): string {
   return (
     `type Query {\n` +

package/src/graphql/schema-utils/entry-reference-util.ts

@@ -1,9 +1,11 @@
 import {
   GraphQLNullableType,
   GraphQLObjectType,
+  GraphQLUnionType,
   isListType,
   isNonNullType,
   isObjectType,
+  isScalarType,
   isUnionType,
 } from 'graphql'
 import { ApolloContext } from '../../client.ts'
@@ -14,6 +16,8 @@ import {
 } from './union-type-util.ts'
 import { hasEntryDirective, isUnionOfEntryTypes } from './entry-type-util.ts'
 import { createError, ErrorCode } from '../errors.ts'
+import { EntryData } from '@commitspark/git-adapter'
+import { isEntryData } from '../util.ts'
 
 function isPermittedReferenceType(
   referencedTypeName: string,
@@ -38,16 +42,18 @@ async function validateReference(
   context: ApolloContext,
   fieldName: string,
   fieldType: GraphQLNullableType,
-  fieldValue: any,
+  fieldValue: EntryData,
 ): Promise<void> {
   if (isNonNullType(fieldType)) {
     await validateReference(context, fieldName, fieldType.ofType, fieldValue)
     return
-  } else if (isListType(fieldType)) {
+  }
+
+  if (isListType(fieldType)) {
     if (!Array.isArray(fieldValue)) {
       throw createError(
         `Expected array while validation references for field "${fieldName}".`,
-        ErrorCode.SCHEMA_DATA_MISMATCH,
+        ErrorCode.BAD_REPOSITORY_DATA,
         {
           fieldName: fieldName,
           fieldValue: fieldValue,
@@ -63,17 +69,24 @@ async function validateReference(
       )
     }
     return
-  } else if (isUnionType(fieldType) || isObjectType(fieldType)) {
-    if (!('id' in fieldValue)) {
+  }
+
+  if (isUnionType(fieldType) || isObjectType(fieldType)) {
+    if (
+      fieldValue === null ||
+      !('id' in fieldValue) ||
+      typeof fieldValue.id !== 'string'
+    ) {
       throw createError(
-        `Expected key "id" in data while validating reference for field "${fieldName}".`,
-        ErrorCode.SCHEMA_DATA_MISMATCH,
+        `Expected key "id" with value of type string in data while validating reference for field "${fieldName}".`,
+        ErrorCode.BAD_REPOSITORY_DATA,
         {
           fieldName: fieldName,
           fieldValue: fieldValue,
         },
       )
     }
+
     const referencedId = fieldValue.id
     let referencedTypeName
     try {
@@ -106,8 +119,12 @@ export async function getReferencedEntryIds(
   context: ApolloContext,
   fieldName: string | null,
   type: GraphQLNullableType,
-  data: any,
+  data: unknown,
 ): Promise<string[]> {
+  if (data === null || data === undefined || isScalarType(type)) {
+    return []
+  }
+
   if (isNonNullType(type)) {
     return getReferencedEntryIds(
       rootType,
@@ -116,7 +133,20 @@ export async function getReferencedEntryIds(
       type.ofType,
       data,
     )
-  } else if (isListType(type)) {
+  }
+
+  if (isListType(type)) {
+    if (!Array.isArray(data)) {
+      throw createError(
+        `Expected array as data for field "${fieldName}". `,
+        ErrorCode.BAD_REPOSITORY_DATA,
+        {
+          fieldName: fieldName ? fieldName : undefined,
+          fieldValue: data,
+        },
+      )
+    }
+
     let referencedEntryIds: string[] = []
     for (const element of data) {
       referencedEntryIds = [
@@ -133,10 +163,29 @@ export async function getReferencedEntryIds(
     // deduplicate
     referencedEntryIds = [...new Set(referencedEntryIds)]
     return referencedEntryIds
-  } else if (isUnionType(type)) {
+  }
+
+  if (isUnionType(type)) {
+    if (!isEntryData(data)) {
+      throw createError(
+        `Expected object as data for type "${type.name}".`,
+        ErrorCode.BAD_REPOSITORY_DATA,
+        {
+          typeName: type.name,
+          fieldName: fieldName ? fieldName : undefined,
+          fieldValue: data,
+        },
+      )
+    }
+
     if (isUnionOfEntryTypes(type)) {
-      await validateReference(context, '', type, data)
-      return [data.id]
+      const referenceId = await getValidatedReferenceId(
+        context,
+        fieldName,
+        type,
+        data,
+      )
+      return [referenceId]
     }
 
     const requestedUnionTypeName = getUnionTypeNameFromFieldValue(data)
@@ -166,24 +215,41 @@ export async function getReferencedEntryIds(
       concreteFieldUnionType,
       unionValue,
     )
-  } else if (isObjectType(type)) {
+  }
+
+  if (isObjectType(type)) {
     if (type.name !== rootType.name && hasEntryDirective(type)) {
-      await validateReference(context, fieldName ?? '', type, data)
-      return [data.id]
+      const referenceId = await getValidatedReferenceId(
+        context,
+        fieldName,
+        type,
+        data,
+      )
+      return [referenceId]
     } else {
       let referencedEntryIds: string[] = []
       for (const [fieldsKey, field] of Object.entries(type.getFields())) {
-        const fieldValue = data[fieldsKey] ?? undefined
-        if (fieldValue !== undefined) {
-          const nestedResult = await getReferencedEntryIds(
-            rootType,
-            context,
-            fieldsKey,
-            field.type,
-            fieldValue,
+        // expect our object type to hold EntryData (i.e. an object)
+        if (Array.isArray(data) || !isEntryData(data)) {
+          throw createError(
+            `Expected object as data for type "${type.name}".`,
+            ErrorCode.BAD_REPOSITORY_DATA,
+            {
+              typeName: type.name,
+              fieldName: field.name ? field.name : undefined,
+            },
           )
-          referencedEntryIds = [...referencedEntryIds, ...nestedResult]
         }
+
+        // recursively get referenced IDs in nested data
+        const nestedResult = await getReferencedEntryIds(
+          rootType,
+          context,
+          fieldsKey,
+          field.type,
+          data[fieldsKey],
+        )
+        referencedEntryIds = [...referencedEntryIds, ...nestedResult]
       }
       // deduplicate
       referencedEntryIds = [...new Set(referencedEntryIds)]
@@ -193,3 +259,44 @@ export async function getReferencedEntryIds(
 
   return []
 }
+
+async function getValidatedReferenceId(
+  context: ApolloContext,
+  fieldName: string | null,
+  type: GraphQLUnionType | GraphQLObjectType,
+  data: unknown,
+): Promise<string> {
+  if (
+    data === null ||
+    data === undefined ||
+    !isEntryData(data) ||
+    Array.isArray(data)
+  ) {
+    throw createError(
+      `Expected object as data for field "${fieldName}" of type "${type.name}".`,
+      ErrorCode.BAD_REPOSITORY_DATA,
+      {
+        typeName: type.name,
+        fieldName: fieldName ? fieldName : undefined,
+        fieldValue: data,
+      },
+    )
+  }
+  await validateReference(context, fieldName ? fieldName : '', type, data)
+
+  let referencedId = null
+  if (typeof (referencedId = data.id) !== 'string') {
+    throw createError(
+      `Expected a key "id" with value of type string in data of field "${fieldName}" of type "${type.name}"` +
+        ` after this reference was just verified to be valid.`,
+      ErrorCode.INTERNAL_ERROR,
+      {
+        typeName: type.name,
+        fieldName: fieldName ? fieldName : undefined,
+        fieldValue: data,
+      },
+    )
+  }
+
+  return referencedId
+}

package/src/graphql/util.ts

@@ -0,0 +1,13 @@
+import { EntryData } from '@commitspark/git-adapter'
+
+export function isEntryData(obj: unknown): obj is EntryData {
+  if (typeof obj !== 'object') {
+    return false
+  }
+
+  if (Array.isArray(obj)) {
+    return false
+  }
+
+  return Object.getOwnPropertySymbols(obj).length === 0
+}