@commitspark/graphql-api 0.90.0 → 1.0.0-beta.1

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

@@ -7,185 +7,171 @@ import {
   isObjectType,
   isUnionType,
 } from 'graphql'
-import { ApolloContext } from '../../app/api.service'
-import { PersistenceService } from '../../persistence/persistence.service'
-import { UnionTypeUtil } from './union-type-util'
-import { EntryTypeUtil } from './entry-type-util'
+import { ApolloContext } from '../../client'
+import { getTypeById } from '../../persistence/persistence'
+import {
+  getUnionTypeNameFromFieldValue,
+  getUnionValue,
+} from './union-type-util'
+import { hasEntryDirective, isUnionOfEntryTypes } from './entry-type-util'
 
-export class EntryReferenceUtil {
-  constructor(
-    private readonly persistence: PersistenceService,
-    private readonly entryTypeUtil: EntryTypeUtil,
-    private readonly unionTypeUtil: UnionTypeUtil,
-  ) {}
+function isPermittedReferenceType(
+  referencedTypeName: string,
+  fieldType: GraphQLNullableType,
+): boolean {
+  if (isNonNullType(fieldType)) {
+    return isPermittedReferenceType(referencedTypeName, fieldType.ofType)
+  } else if (isListType(fieldType)) {
+    return isPermittedReferenceType(referencedTypeName, fieldType.ofType)
+  } else if (isUnionType(fieldType)) {
+    return fieldType
+      .getTypes()
+      .map((concreteType) => concreteType.name)
+      .includes(referencedTypeName)
+  } else if (isObjectType(fieldType)) {
+    return fieldType.name === referencedTypeName
+  }
+  return false
+}
 
-  public async getReferencedEntryIds(
-    rootType: GraphQLObjectType,
-    context: ApolloContext,
-    fieldName: string | null,
-    type: GraphQLNullableType,
-    data: any,
-  ): Promise<string[]> {
-    if (isNonNullType(type)) {
-      return this.getReferencedEntryIds(
-        rootType,
+async function validateReference(
+  context: ApolloContext,
+  fieldName: string,
+  fieldType: GraphQLNullableType,
+  fieldValue: any,
+): Promise<void> {
+  if (isNonNullType(fieldType)) {
+    await validateReference(context, fieldName, fieldType.ofType, fieldValue)
+    return
+  } else if (isListType(fieldType)) {
+    if (!Array.isArray(fieldValue)) {
+      throw new Error(`Expected array value in field "${fieldName}"`)
+    }
+    for (const fieldListElement of fieldValue) {
+      await validateReference(
         context,
         fieldName,
-        type.ofType,
-        data,
+        fieldType.ofType,
+        fieldListElement,
       )
-    } else if (isListType(type)) {
-      let referencedEntryIds: string[] = []
-      for (const element of data) {
-        referencedEntryIds = [
-          ...referencedEntryIds,
-          ...(await this.getReferencedEntryIds(
-            rootType,
-            context,
-            fieldName,
-            type.ofType,
-            element,
-          )),
-        ]
-      }
-      // deduplicate
-      referencedEntryIds = [...new Set(referencedEntryIds)]
-      return referencedEntryIds
-    } else if (isUnionType(type)) {
-      if (this.entryTypeUtil.isUnionOfEntryTypes(type)) {
-        await this.validateReference(context, '', type, data)
-        return [data.id]
-      }
-
-      const unionTypeName =
-        this.unionTypeUtil.getUnionTypeNameFromFieldValue(data)
-      const unionType = type
-        .getTypes()
-        .find((type) => type.name === unionTypeName)
-      if (!unionType) {
-        throw new Error(
-          `Type "${unionTypeName}" found in field data is not a valid type for union type "${type.name}".`,
-        )
-      }
-      const unionValue = this.unionTypeUtil.getUnionValue(data)
-      return this.getReferencedEntryIds(
-        rootType,
-        context,
-        fieldName,
-        unionType,
-        unionValue,
+    }
+    return
+  } else if (isUnionType(fieldType) || isObjectType(fieldType)) {
+    if (!('id' in fieldValue)) {
+      throw new Error('Expected key "id"')
+    }
+    const referencedId = fieldValue.id
+    let referencedTypeName
+    try {
+      referencedTypeName = await getTypeById(
+        context.gitAdapter,
+        context.getCurrentRef(),
+        referencedId,
+      )
+    } catch (error) {
+      throw new GraphQLError(
+        `Reference with id "${referencedId}" points to non-existing entry`,
+        {
+          extensions: {
+            code: 'BAD_USER_INPUT',
+            fieldName: fieldName,
+          },
+        },
+      )
+    }
+    if (!isPermittedReferenceType(referencedTypeName, fieldType)) {
+      throw new GraphQLError(
+        `Reference with id "${referencedId}" points to entry of incompatible type`,
+        {
+          extensions: {
+            code: 'BAD_USER_INPUT',
+            fieldName: fieldName,
+          },
+        },
       )
-    } else if (isObjectType(type)) {
-      if (
-        type.name !== rootType.name &&
-        this.entryTypeUtil.hasEntryDirective(type)
-      ) {
-        await this.validateReference(context, fieldName ?? '', type, data)
-        return [data.id]
-      } else {
-        let referencedEntryIds: string[] = []
-        for (const [fieldsKey, field] of Object.entries(type.getFields())) {
-          const fieldValue = data[fieldsKey] ?? undefined
-          if (fieldValue !== undefined) {
-            const nestedResult = await this.getReferencedEntryIds(
-              rootType,
-              context,
-              fieldsKey,
-              field.type,
-              fieldValue,
-            )
-            referencedEntryIds = [...referencedEntryIds, ...nestedResult]
-          }
-        }
-        // deduplicate
-        referencedEntryIds = [...new Set(referencedEntryIds)]
-        return referencedEntryIds
-      }
     }
-
-    return []
   }
+}
 
-  private async validateReference(
-    context: ApolloContext,
-    fieldName: string,
-    fieldType: GraphQLNullableType,
-    fieldValue: any,
-  ): Promise<void> {
-    if (isNonNullType(fieldType)) {
-      await this.validateReference(
-        context,
-        fieldName,
-        fieldType.ofType,
-        fieldValue,
-      )
-      return
-    } else if (isListType(fieldType)) {
-      if (!Array.isArray(fieldValue)) {
-        throw new Error(`Expected array value in field "${fieldName}"`)
-      }
-      for (const fieldListElement of fieldValue) {
-        await this.validateReference(
+export async function getReferencedEntryIds(
+  rootType: GraphQLObjectType,
+  context: ApolloContext,
+  fieldName: string | null,
+  type: GraphQLNullableType,
+  data: any,
+): Promise<string[]> {
+  if (isNonNullType(type)) {
+    return getReferencedEntryIds(
+      rootType,
+      context,
+      fieldName,
+      type.ofType,
+      data,
+    )
+  } else if (isListType(type)) {
+    let referencedEntryIds: string[] = []
+    for (const element of data) {
+      referencedEntryIds = [
+        ...referencedEntryIds,
+        ...(await getReferencedEntryIds(
+          rootType,
           context,
           fieldName,
-          fieldType.ofType,
-          fieldListElement,
-        )
-      }
-      return
-    } else if (isUnionType(fieldType) || isObjectType(fieldType)) {
-      if (!('id' in fieldValue)) {
-        throw new Error('Expected key "id"')
-      }
-      const referencedId = fieldValue.id
-      let referencedTypeName
-      try {
-        referencedTypeName = await this.persistence.getTypeById(
-          context.gitAdapter,
-          context.getCurrentRef(),
-          referencedId,
-        )
-      } catch (error) {
-        throw new GraphQLError(
-          `Reference with id "${referencedId}" points to non-existing entry`,
-          {
-            extensions: {
-              code: 'BAD_USER_INPUT',
-              fieldName: fieldName,
-            },
-          },
-        )
-      }
-      if (!this.isPermittedReferenceType(referencedTypeName, fieldType)) {
-        throw new GraphQLError(
-          `Reference with id "${referencedId}" points to entry of incompatible type`,
-          {
-            extensions: {
-              code: 'BAD_USER_INPUT',
-              fieldName: fieldName,
-            },
-          },
-        )
-      }
+          type.ofType,
+          element,
+        )),
+      ]
+    }
+    // deduplicate
+    referencedEntryIds = [...new Set(referencedEntryIds)]
+    return referencedEntryIds
+  } else if (isUnionType(type)) {
+    if (isUnionOfEntryTypes(type)) {
+      await validateReference(context, '', type, data)
+      return [data.id]
     }
-  }
 
-  private isPermittedReferenceType(
-    referencedTypeName: string,
-    fieldType: GraphQLNullableType,
-  ): boolean {
-    if (isNonNullType(fieldType)) {
-      return this.isPermittedReferenceType(referencedTypeName, fieldType.ofType)
-    } else if (isListType(fieldType)) {
-      return this.isPermittedReferenceType(referencedTypeName, fieldType.ofType)
-    } else if (isUnionType(fieldType)) {
-      return fieldType
-        .getTypes()
-        .map((concreteType) => concreteType.name)
-        .includes(referencedTypeName)
-    } else if (isObjectType(fieldType)) {
-      return fieldType.name === referencedTypeName
+    const unionTypeName = getUnionTypeNameFromFieldValue(data)
+    const unionType = type
+      .getTypes()
+      .find((type) => type.name === unionTypeName)
+    if (!unionType) {
+      throw new Error(
+        `Type "${unionTypeName}" found in field data is not a valid type for union type "${type.name}".`,
+      )
+    }
+    const unionValue = getUnionValue(data)
+    return getReferencedEntryIds(
+      rootType,
+      context,
+      fieldName,
+      unionType,
+      unionValue,
+    )
+  } else if (isObjectType(type)) {
+    if (type.name !== rootType.name && hasEntryDirective(type)) {
+      await validateReference(context, fieldName ?? '', type, data)
+      return [data.id]
+    } 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,
+          )
+          referencedEntryIds = [...referencedEntryIds, ...nestedResult]
+        }
+      }
+      // deduplicate
+      referencedEntryIds = [...new Set(referencedEntryIds)]
+      return referencedEntryIds
     }
-    return false
   }
+
+  return []
 }

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

@@ -8,35 +8,32 @@ import {
   isUnionType,
 } from 'graphql'
 
-export class EntryTypeUtil {
-  public buildsOnTypeWithEntryDirective(type: GraphQLNullableType): boolean {
-    if (isNonNullType(type)) {
-      return this.buildsOnTypeWithEntryDirective(type.ofType)
-    } else if (isListType(type)) {
-      return this.buildsOnTypeWithEntryDirective(type.ofType)
-    } else if (isUnionType(type)) {
-      return this.isUnionOfEntryTypes(type)
-    } else if (isObjectType(type)) {
-      return this.hasEntryDirective(type)
-    }
-    return false
-  }
+export function hasEntryDirective(type: GraphQLObjectType): boolean {
+  return (
+    !!type.astNode &&
+    type.astNode.directives?.find(
+      (directive) => directive.name.value === 'Entry',
+    ) !== undefined
+  )
+}
 
-  public hasEntryDirective(type: GraphQLObjectType): boolean {
-    return (
-      !!type.astNode &&
-      type.astNode.directives?.find(
-        (directive) => directive.name.value === 'Entry',
-      ) !== undefined
-    )
-  }
+export function isUnionOfEntryTypes(type: GraphQLUnionType): boolean {
+  return type
+    .getTypes()
+    .every((unionType) => buildsOnTypeWithEntryDirective(unionType))
+}
 
-  public isUnionOfEntryTypes(type: GraphQLUnionType): boolean {
-    return (
-      type
-        .getTypes()
-        .filter((unionType) => this.buildsOnTypeWithEntryDirective(unionType))
-        .length > 0
-    )
+export function buildsOnTypeWithEntryDirective(
+  type: GraphQLNullableType,
+): boolean {
+  if (isNonNullType(type)) {
+    return buildsOnTypeWithEntryDirective(type.ofType)
+  } else if (isListType(type)) {
+    return buildsOnTypeWithEntryDirective(type.ofType)
+  } else if (isUnionType(type)) {
+    return isUnionOfEntryTypes(type)
+  } else if (isObjectType(type)) {
+    return hasEntryDirective(type)
   }
+  return false
 }

package/src/graphql/schema-utils/union-type-util.ts

@@ -1,22 +1,20 @@
 import { EntryData } from '@commitspark/git-adapter'
 
-export class UnionTypeUtil {
-  public getUnionTypeNameFromFieldValue(fieldValue: any): string {
-    if (typeof fieldValue !== 'object') {
-      throw new Error('Expected object as union value')
-    }
-
-    // Based on our @oneOf directive, we expect only one field whose name
-    // corresponds to the concrete type's name.
-    return Object.keys(fieldValue)[0]
+export function getUnionTypeNameFromFieldValue(fieldValue: any): string {
+  if (typeof fieldValue !== 'object') {
+    throw new Error('Expected object as union value')
   }
 
-  public getUnionValue(fieldValue: any): EntryData {
-    if (typeof fieldValue !== 'object') {
-      throw new Error('Expected object as union value')
-    }
+  // Based on our @oneOf directive, we expect only one field whose name
+  // corresponds to the concrete type's name.
+  return Object.keys(fieldValue)[0]
+}
 
-    const firstKey = Object.keys(fieldValue)[0]
-    return fieldValue[firstKey]
+export function getUnionValue(fieldValue: any): EntryData {
+  if (typeof fieldValue !== 'object') {
+    throw new Error('Expected object as union value')
   }
+
+  const firstKey = Object.keys(fieldValue)[0]
+  return fieldValue[firstKey]
 }

package/src/graphql/schema-validator.ts

@@ -1,39 +1,37 @@
 import { GraphQLSchema, GraphQLUnionType, Kind } from 'graphql'
 
-export class SchemaValidator {
-  public getValidationResult(schema: GraphQLSchema): string[] {
-    const results = []
-    results.push(this.checkUnionMembersConsistentUseOfEntryDirective(schema))
-    return results.filter((result) => result !== '')
-  }
-
-  private checkUnionMembersConsistentUseOfEntryDirective(
-    schema: GraphQLSchema,
-  ): string {
-    const typeMap = schema.getTypeMap()
+function checkUnionMembersConsistentUseOfEntryDirective(
+  schema: GraphQLSchema,
+): string {
+  const typeMap = schema.getTypeMap()
 
-    for (const [key, type] of Object.entries(typeMap)) {
-      if (type.astNode?.kind !== Kind.UNION_TYPE_DEFINITION) {
-        continue
-      }
-      const innerTypes = (type as GraphQLUnionType).getTypes()
+  for (const [key, type] of Object.entries(typeMap)) {
+    if (type.astNode?.kind !== Kind.UNION_TYPE_DEFINITION) {
+      continue
+    }
+    const innerTypes = (type as GraphQLUnionType).getTypes()
 
-      const numberUnionMembersWithEntryDirective = innerTypes.filter(
-        (innerType) =>
-          !!innerType.astNode &&
-          innerType.astNode.directives?.find(
-            (directive) => directive.name.value === 'Entry',
-          ) !== undefined,
-      ).length
+    const numberUnionMembersWithEntryDirective = innerTypes.filter(
+      (innerType) =>
+        !!innerType.astNode &&
+        innerType.astNode.directives?.find(
+          (directive) => directive.name.value === 'Entry',
+        ) !== undefined,
+    ).length
 
-      if (
-        numberUnionMembersWithEntryDirective !== 0 &&
-        numberUnionMembersWithEntryDirective !== innerTypes.length
-      ) {
-        return `Either all union members of "${type.name}" must have "@Entry" directive or none.`
-      }
+    if (
+      numberUnionMembersWithEntryDirective !== 0 &&
+      numberUnionMembersWithEntryDirective !== innerTypes.length
+    ) {
+      return `Either all union members of "${type.name}" must have "@Entry" directive or none.`
     }
-
-    return ''
   }
+
+  return ''
+}
+
+export function getValidationResult(schema: GraphQLSchema): string[] {
+  const results = []
+  results.push(checkUnionMembersConsistentUseOfEntryDirective(schema))
+  return results.filter((result) => result !== '')
 }

package/src/index.ts

@@ -1,8 +1,29 @@
-import { ApiService, GraphQLResponse, SchemaResponse } from './app/api.service'
-import { apiService } from './container'
+import {
+  ApolloExecuteOperationRequest,
+  getSchema,
+  GraphQLResponse,
+  postGraphQL,
+  SchemaResponse,
+  VariableValues,
+} from './client'
+import { GitAdapter } from '@commitspark/git-adapter'
 
-export { ApiService, GraphQLResponse, SchemaResponse }
+interface Client {
+  postGraphQL<
+    TData = Record<string, unknown>,
+    TVariables extends VariableValues = VariableValues,
+  >(
+    ref: string,
+    request: ApolloExecuteOperationRequest<TData, TVariables>,
+  ): Promise<GraphQLResponse<TData | null>>
+  getSchema(ref: string): Promise<SchemaResponse>
+}
+
+export { Client, GraphQLResponse, SchemaResponse }
 
-export async function getApiService(): Promise<ApiService> {
-  return apiService
+export async function createClient(gitAdapter: GitAdapter): Promise<Client> {
+  return {
+    postGraphQL: (ref, request) => postGraphQL(gitAdapter, ref, request),
+    getSchema: (ref) => getSchema(gitAdapter, ref),
+  }
 }

package/src/persistence/persistence.ts

@@ -0,0 +1,72 @@
+import { Entry, GitAdapter } from '@commitspark/git-adapter'
+import { GraphQLError } from 'graphql'
+
+export async function getTypeById(
+  gitAdapter: GitAdapter,
+  commitHash: string,
+  id: string,
+): Promise<string> {
+  const allEntries = await gitAdapter.getEntries(commitHash)
+  const requestedEntry = allEntries.find((entry: Entry) => entry.id === id)
+  if (requestedEntry === undefined) {
+    throw new GraphQLError(`Not found: ${id}`, {
+      extensions: {
+        code: 'NOT_FOUND',
+      },
+    })
+  }
+
+  return requestedEntry.metadata.type
+}
+
+export async function findById(
+  gitAdapter: GitAdapter,
+  commitHash: string,
+  id: string,
+): Promise<Entry> {
+  const allEntries = await gitAdapter.getEntries(commitHash)
+  const requestedEntry = allEntries.find((entry: Entry) => entry.id === id)
+  if (requestedEntry === undefined) {
+    throw new GraphQLError(`Not found: ${id}`, {
+      extensions: {
+        code: 'NOT_FOUND',
+      },
+    })
+  }
+
+  return requestedEntry
+}
+
+export async function findByType(
+  gitAdapter: GitAdapter,
+  commitHash: string,
+  type: string,
+): Promise<Entry[]> {
+  const allEntries = await gitAdapter.getEntries(commitHash)
+  return allEntries.filter((entry: Entry) => entry.metadata.type === type)
+}
+
+export async function findByTypeId(
+  gitAdapter: GitAdapter,
+  commitHash: string,
+  type: string,
+  id: string,
+): Promise<Entry> {
+  const allEntries = await gitAdapter.getEntries(commitHash)
+  const requestedEntry = allEntries.find(
+    (entry: Entry) => entry.id === id && entry.metadata.type === type,
+  )
+  if (requestedEntry === undefined) {
+    throw new GraphQLError(
+      `No entry of type "${type}" with id "${id}" exists`,
+      {
+        extensions: {
+          code: 'BAD_USER_INPUT',
+          argumentName: 'id',
+        },
+      },
+    )
+  }
+
+  return requestedEntry
+}