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

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 { isRecord } from '../util.ts'
 
 function isPermittedReferenceType(
   referencedTypeName: string,
@@ -38,7 +42,7 @@ 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)
@@ -47,7 +51,7 @@ async function validateReference(
     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,
@@ -64,16 +68,21 @@ async function validateReference(
     }
     return
   } else if (isUnionType(fieldType) || isObjectType(fieldType)) {
-    if (!('id' in fieldValue)) {
+    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 +115,12 @@ export async function getReferencedEntryIds(
   context: ApolloContext,
   fieldName: string | null,
   type: GraphQLNullableType,
-  data: any,
+  data: EntryData | EntryData[],
 ): Promise<string[]> {
+  if (data === null || isScalarType(type)) {
+    return []
+  }
+
   if (isNonNullType(type)) {
     return getReferencedEntryIds(
       rootType,
@@ -117,6 +130,17 @@ export async function getReferencedEntryIds(
       data,
     )
   } else 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 = [
@@ -135,8 +159,13 @@ export async function getReferencedEntryIds(
     return referencedEntryIds
   } else if (isUnionType(type)) {
     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)
@@ -168,22 +197,56 @@ export async function getReferencedEntryIds(
     )
   } else 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,
+        if (Array.isArray(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]
         }
+
+        const fieldValue = data[fieldsKey]
+        if (
+          fieldValue === undefined ||
+          fieldValue === null ||
+          isScalarType(field.type)
+        ) {
+          continue
+        }
+
+        if (!(Array.isArray(fieldValue) || isRecord(fieldValue))) {
+          throw createError(
+            `Expected object or array as data for field "${field.name}" of type "${type.name}".`,
+            ErrorCode.BAD_REPOSITORY_DATA,
+            {
+              typeName: type.name,
+              fieldName: field.name ? field.name : undefined,
+              fieldValue: fieldValue,
+            },
+          )
+        }
+        // recursively get referenced IDs in nested data
+        const nestedResult = await getReferencedEntryIds(
+          rootType,
+          context,
+          fieldsKey,
+          field.type,
+          fieldValue,
+        )
+        referencedEntryIds = [...referencedEntryIds, ...nestedResult]
       }
       // deduplicate
       referencedEntryIds = [...new Set(referencedEntryIds)]
@@ -193,3 +256,39 @@ export async function getReferencedEntryIds(
 
   return []
 }
+
+async function getValidatedReferenceId(
+  context: ApolloContext,
+  fieldName: string | null,
+  type: GraphQLUnionType | GraphQLObjectType,
+  data: EntryData | EntryData[],
+): Promise<string> {
+  if (data === null || typeof data !== 'object' || 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,11 @@
+export function isRecord(obj: unknown): obj is Record<string, unknown> {
+  if (typeof obj !== 'object') {
+    return false
+  }
+
+  if (Array.isArray(obj)) {
+    return false
+  }
+
+  return Object.getOwnPropertySymbols(obj).length === 0
+}