@commitspark/graphql-api 0.7.0

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

@@ -0,0 +1,155 @@
+import { Entry } from '../persistence/persistence.service'
+import { ApolloContext } from '../app/api.service'
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { GraphQLObjectType } from 'graphql/type'
+import { QueryAllResolverGenerator } from './resolver-generators/query-all-resolver-generator'
+import { QueryByIdResolverGenerator } from './resolver-generators/query-by-id-resolver-generator'
+import { MutationCreateResolverGenerator } from './resolver-generators/mutation-create-resolver-generator'
+import { MutationUpdateResolverGenerator } from './resolver-generators/mutation-update.resolver-generator'
+import { MutationDeleteResolverGenerator } from './resolver-generators/mutation-delete-resolver-generator'
+import { QueryCountAllResolverGenerator } from './resolver-generators/query-count-all-resolver-generator'
+import { QueryTypeByIdResolverGenerator } from './resolver-generators/query-type-by-id-resolver-generator'
+
+export class QueriesMutationsGeneratorService {
+  constructor(
+    private readonly queryAllResolverGenerator: QueryAllResolverGenerator,
+    private readonly queryByIdResolverGenerator: QueryByIdResolverGenerator,
+    private readonly queryCountAllResolverGenerator: QueryCountAllResolverGenerator,
+    private readonly queryTypeByIdResolverGenerator: QueryTypeByIdResolverGenerator,
+    private readonly mutationCreateResolverGenerator: MutationCreateResolverGenerator,
+    private readonly mutationUpdateResolverGenerator: MutationUpdateResolverGenerator,
+    private readonly mutationDeleteResolverGenerator: MutationDeleteResolverGenerator,
+  ) {}
+
+  public generateFromAnalyzedSchema(
+    entryDirectiveTypes: GraphQLObjectType[],
+  ): IGeneratedSchema[] {
+    return entryDirectiveTypes.map((objectType): IGeneratedSchema => {
+      const typeName = objectType.name
+
+      const queryAllName = `all${typeName}s`
+      const queryAllString = `${queryAllName}: [${objectType.name}]`
+      const queryAllResolver: GraphQLFieldResolver<
+        any,
+        ApolloContext,
+        any,
+        Promise<Entry[]>
+      > = this.queryAllResolverGenerator.createResolver(typeName)
+
+      const queryAllMetaName = `_${queryAllName}Meta`
+      const queryAllMetaString = `${queryAllMetaName}: ListMetadata`
+      const queryAllMetaResolver: GraphQLFieldResolver<
+        any,
+        ApolloContext,
+        any,
+        Promise<TypeCount>
+      > = this.queryCountAllResolverGenerator.createResolver(typeName)
+
+      const queryByIdName = typeName
+      const queryByIdString = `${queryByIdName}(id: ID!): ${objectType.name}`
+      const queryByIdResolver: GraphQLFieldResolver<
+        any,
+        ApolloContext,
+        any,
+        Promise<Entry>
+      > = this.queryByIdResolverGenerator.createResolver(typeName)
+
+      const inputTypeName = `${typeName}Input`
+      const createMutationName = `create${typeName}`
+      const createMutationString = `${createMutationName}(data:${inputTypeName}, message:String): ${typeName}`
+      const createMutationResolver: GraphQLFieldResolver<
+        any,
+        ApolloContext,
+        any,
+        Promise<Entry>
+      > = this.mutationCreateResolverGenerator.createResolver(typeName)
+
+      const updateMutationName = `update${typeName}`
+      const updateMutationString = `${updateMutationName}(id: ID!, data:${inputTypeName}, message:String): ${typeName}`
+      const updateMutationResolver: GraphQLFieldResolver<
+        any,
+        ApolloContext,
+        any,
+        Promise<Entry>
+      > = this.mutationUpdateResolverGenerator.createResolver(typeName)
+
+      const deleteMutationName = `delete${typeName}`
+      const deleteMutationString = `${deleteMutationName}(id: ID!, message:String): DeletionResult`
+      const deleteMutationResolver: GraphQLFieldResolver<
+        any,
+        ApolloContext,
+        any,
+        Promise<Entry>
+      > = this.mutationDeleteResolverGenerator.createResolver(typeName)
+
+      return {
+        queryAll: {
+          name: queryAllName,
+          schemaString: queryAllString,
+          resolver: queryAllResolver,
+        },
+        queryAllMeta: {
+          name: queryAllMetaName,
+          schemaString: queryAllMetaString,
+          resolver: queryAllMetaResolver,
+        },
+        queryById: {
+          name: queryByIdName,
+          schemaString: queryByIdString,
+          resolver: queryByIdResolver,
+        },
+        createMutation: {
+          name: createMutationName,
+          schemaString: createMutationString,
+          resolver: createMutationResolver,
+        },
+        updateMutation: {
+          name: updateMutationName,
+          schemaString: updateMutationString,
+          resolver: updateMutationResolver,
+        },
+        deleteMutation: {
+          name: deleteMutationName,
+          schemaString: deleteMutationString,
+          resolver: deleteMutationResolver,
+        },
+      }
+    })
+  }
+
+  public generateTypeNameQuery(): IGeneratedQuery<Promise<string>> {
+    const contentTypeQueryName = '_typeName'
+    const contentTypeQueryString = `${contentTypeQueryName}(id: ID!): String`
+    const contentTypeQueryResolver: GraphQLFieldResolver<
+      any,
+      ApolloContext,
+      any,
+      Promise<string>
+    > = this.queryTypeByIdResolverGenerator.createResolver()
+
+    return {
+      name: contentTypeQueryName,
+      schemaString: contentTypeQueryString,
+      resolver: contentTypeQueryResolver,
+    }
+  }
+}
+
+export interface IGeneratedSchema {
+  queryAll: IGeneratedQuery<Promise<Entry[]>>
+  queryAllMeta: IGeneratedQuery<Promise<TypeCount>>
+  queryById: IGeneratedQuery<Promise<Entry>>
+  createMutation: IGeneratedQuery<Promise<Entry>>
+  updateMutation: IGeneratedQuery<Promise<Entry>>
+  deleteMutation: IGeneratedQuery<Promise<Entry>>
+}
+
+export interface IGeneratedQuery<T> {
+  name: string
+  schemaString: string
+  resolver: GraphQLFieldResolver<any, ApolloContext, any, T>
+}
+
+export type TypeCount = {
+  count: number
+}

package/src/graphql/resolver-generators/entry-reference-resolver.generator.ts

@@ -0,0 +1,71 @@
+import { GraphQLField, GraphQLObjectType } from 'graphql'
+import {
+  Entry,
+  PersistenceService,
+} from '../../persistence/persistence.service'
+import { ApolloContext } from '../../app/api.service'
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+
+export class EntryReferenceResolverGenerator {
+  constructor(private readonly persistence: PersistenceService) {}
+
+  public createResolver(
+    context: ApolloContext,
+    obj: {
+      type: GraphQLObjectType
+      fields: GraphQLField<any, any>[]
+    },
+  ): Record<
+    string,
+    GraphQLFieldResolver<
+      Record<string, any>,
+      ApolloContext,
+      any,
+      Promise<Entry | Entry[] | undefined>
+    >
+  > {
+    const persistence = this.persistence
+
+    const fieldResolvers: Record<
+      string,
+      GraphQLFieldResolver<
+        Record<string, any>,
+        ApolloContext,
+        any,
+        Promise<Entry | Entry[] | undefined>
+      >
+    > = {}
+
+    for (const field of obj.fields) {
+      const fieldName = field.name
+      fieldResolvers[fieldName] = async (
+        source,
+        args,
+        context,
+        info,
+      ): Promise<Entry | Entry[] | undefined> => {
+        if (source[fieldName] === undefined) {
+          return undefined
+        }
+        // TODO decide this based on type definition, not data
+        if (Array.isArray(source[fieldName])) {
+          return source[fieldName].map((el: any) =>
+            persistence.findById(
+              context.gitAdapter,
+              context.getCurrentRef(),
+              el.id,
+            ),
+          )
+        } else {
+          return persistence.findById(
+            context.gitAdapter,
+            context.getCurrentRef(),
+            source[fieldName].id,
+          )
+        }
+      }
+    }
+
+    return fieldResolvers
+  }
+}

package/src/graphql/resolver-generators/mutation-create-resolver-generator.ts

@@ -0,0 +1,38 @@
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { ApolloContext } from '../../app/api.service'
+import {
+  Entry,
+  PersistenceService,
+} from '../../persistence/persistence.service'
+
+export class MutationCreateResolverGenerator {
+  constructor(private readonly persistence: PersistenceService) {}
+
+  public createResolver(
+    typeName: string,
+  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<Entry>> {
+    return async (
+      source,
+      args,
+      context: ApolloContext,
+      info,
+    ): Promise<Entry> => {
+      // TODO validate ID references in payload to assert referenced ID exists and points to correct entry type
+      const createResult = await this.persistence.createType(
+        context.gitAdapter,
+        context.branch,
+        context.getCurrentRef(),
+        typeName,
+        args.data,
+        args.message,
+      )
+      context.setCurrentRef(createResult.ref)
+      return this.persistence.findByTypeId(
+        context.gitAdapter,
+        context.getCurrentRef(),
+        typeName,
+        createResult.id,
+      )
+    }
+  }
+}

package/src/graphql/resolver-generators/mutation-delete-resolver-generator.ts

@@ -0,0 +1,35 @@
+import {
+  Entry,
+  PersistenceService,
+} from '../../persistence/persistence.service'
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { ApolloContext } from '../../app/api.service'
+
+export class MutationDeleteResolverGenerator {
+  constructor(private readonly persistence: PersistenceService) {}
+
+  public createResolver(
+    typeName: string,
+  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<Entry>> {
+    return async (
+      source,
+      args,
+      context: ApolloContext,
+      info,
+    ): Promise<Entry> => {
+      // TODO validate ID to delete is not referenced anywhere
+      const deleteResult = await this.persistence.deleteByTypeId(
+        context.gitAdapter,
+        context.branch,
+        context.getCurrentRef(),
+        typeName,
+        args.id,
+        args.message,
+      )
+      context.setCurrentRef(deleteResult.ref)
+      return {
+        id: args.id,
+      }
+    }
+  }
+}

package/src/graphql/resolver-generators/mutation-update.resolver-generator.ts

@@ -0,0 +1,39 @@
+import {
+  Entry,
+  PersistenceService,
+} from '../../persistence/persistence.service'
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { ApolloContext } from '../../app/api.service'
+
+export class MutationUpdateResolverGenerator {
+  constructor(private readonly persistence: PersistenceService) {}
+
+  public createResolver(
+    typeName: string,
+  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<Entry>> {
+    return async (
+      source,
+      args,
+      context: ApolloContext,
+      info,
+    ): Promise<Entry> => {
+      // TODO validate ID references in payload to assert referenced ID exists and points to correct entry type
+      const updateResult = await this.persistence.updateByTypeId(
+        context.gitAdapter,
+        context.branch,
+        context.getCurrentRef(),
+        typeName,
+        args.id,
+        args.data,
+        args.message,
+      )
+      context.setCurrentRef(updateResult.ref)
+      return this.persistence.findByTypeId(
+        context.gitAdapter,
+        context.getCurrentRef(),
+        typeName,
+        args.id,
+      )
+    }
+  }
+}

package/src/graphql/resolver-generators/query-all-resolver-generator.ts

@@ -0,0 +1,27 @@
+import { ApolloContext } from '../../app/api.service'
+import {
+  Entry,
+  PersistenceService,
+} from '../../persistence/persistence.service'
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+
+export class QueryAllResolverGenerator {
+  constructor(private readonly persistence: PersistenceService) {}
+
+  public createResolver(
+    typeName: string,
+  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<Entry[]>> {
+    return async (
+      obj,
+      args,
+      context: ApolloContext,
+      info,
+    ): Promise<Entry[]> => {
+      return this.persistence.findByType(
+        context.gitAdapter,
+        context.getCurrentRef(),
+        typeName,
+      )
+    }
+  }
+}

package/src/graphql/resolver-generators/query-by-id-resolver-generator.ts

@@ -0,0 +1,23 @@
+import {
+  Entry,
+  PersistenceService,
+} from '../../persistence/persistence.service'
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { ApolloContext } from '../../app/api.service'
+
+export class QueryByIdResolverGenerator {
+  constructor(private readonly persistence: PersistenceService) {}
+
+  public createResolver(
+    typeName: string,
+  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<Entry>> {
+    return async (obj, args, context, info): Promise<Entry> => {
+      return this.persistence.findByTypeId(
+        context.gitAdapter,
+        context.getCurrentRef(),
+        typeName,
+        args.id,
+      )
+    }
+  }
+}

package/src/graphql/resolver-generators/query-count-all-resolver-generator.ts

@@ -0,0 +1,29 @@
+import { PersistenceService } from '../../persistence/persistence.service'
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { ApolloContext } from '../../app/api.service'
+import { TypeCount } from '../queries-mutations-generator.service'
+
+export class QueryCountAllResolverGenerator {
+  constructor(private readonly persistence: PersistenceService) {}
+
+  public createResolver(
+    typeName: string,
+  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<TypeCount>> {
+    return async (
+      obj,
+      args,
+      context: ApolloContext,
+      info,
+    ): Promise<TypeCount> => {
+      return {
+        count: (
+          await this.persistence.findByType(
+            context.gitAdapter,
+            context.getCurrentRef(),
+            typeName,
+          )
+        ).length,
+      }
+    }
+  }
+}

package/src/graphql/resolver-generators/query-type-by-id-resolver-generator.ts

@@ -0,0 +1,27 @@
+import { PersistenceService } from '../../persistence/persistence.service'
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { ApolloContext } from '../../app/api.service'
+
+export class QueryTypeByIdResolverGenerator {
+  constructor(private readonly persistence: PersistenceService) {}
+
+  public createResolver(): GraphQLFieldResolver<
+    any,
+    ApolloContext,
+    any,
+    Promise<string>
+  > {
+    return async (
+      source,
+      args,
+      context: ApolloContext,
+      info,
+    ): Promise<string> => {
+      return this.persistence.getTypeById(
+        context.gitAdapter,
+        context.getCurrentRef(),
+        args.id,
+      )
+    }
+  }
+}

package/src/graphql/resolver-generators/union-type-resolver-generator.ts

@@ -0,0 +1,40 @@
+import { ApolloContext } from '../../app/api.service'
+import { PersistenceService } from '../../persistence/persistence.service'
+import {
+  GraphQLAbstractType,
+  GraphQLResolveInfo,
+  GraphQLTypeResolver,
+} from 'graphql/type/definition'
+import { EntryReferenceUtil } from '../schema-utils/entry-reference-util'
+
+export class UnionTypeResolverGenerator {
+  constructor(
+    private readonly persistence: PersistenceService,
+    private readonly entryReferenceUtil: EntryReferenceUtil,
+  ) {}
+
+  public createResolver(): GraphQLTypeResolver<any, ApolloContext> {
+    return async (
+      obj: any,
+      context: ApolloContext,
+      info: GraphQLResolveInfo,
+      abstractType: GraphQLAbstractType,
+    ): Promise<string> => {
+      if (
+        this.entryReferenceUtil.buildsOnTypeWithEntryDirective(abstractType)
+      ) {
+        return this.persistence.getTypeById(
+          context.gitAdapter,
+          context.getCurrentRef(),
+          obj.id,
+        )
+      } else {
+        // We have injected an internal `__typename` field into the data of fields pointing to a non-entry union
+        // in UnionValueResolverGenerator. This artificial field holds the type information we need here.
+        return obj.__typename
+      }
+
+      // TODO same for interface type: https://www.apollographql.com/docs/apollo-server/data/resolvers/#resolving-unions-and-interfaces
+    }
+  }
+}

package/src/graphql/resolver-generators/union-value-resolver-generator.ts

@@ -0,0 +1,116 @@
+import {
+  GraphQLFieldResolver,
+  GraphQLNullableType,
+  GraphQLUnionType,
+} from 'graphql/type/definition'
+import { ApolloContext } from '../../app/api.service'
+import { Entry } from '../../persistence/persistence.service'
+import { GraphQLSchema, Kind } from 'graphql'
+import {
+  GraphQLField,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+} from 'graphql/type'
+import { EntryReferenceUtil } from '../schema-utils/entry-reference-util'
+
+export class UnionValueResolverGenerator {
+  constructor(private readonly entryReferenceUtil: EntryReferenceUtil) {}
+
+  public createResolver(
+    schema: GraphQLSchema,
+  ): Record<
+    string,
+    Record<string, GraphQLFieldResolver<any, ApolloContext, any, Entry>>
+  > {
+    const resolvers: Record<
+      string,
+      Record<string, GraphQLFieldResolver<any, ApolloContext, any, Entry>>
+    > = {}
+    for (const typeName of Object.keys(schema.getTypeMap())) {
+      const type = schema.getType(typeName)
+      if (!type || type.astNode?.kind !== Kind.OBJECT_TYPE_DEFINITION) {
+        continue
+      }
+      const objectType = type as GraphQLObjectType
+      const unionFieldsNotUsingEntry =
+        this.getFieldsWithUnionTypeNotUsingEntryTypes(objectType)
+
+      const fieldResolvers: Record<
+        string,
+        GraphQLFieldResolver<any, ApolloContext, any, Entry>
+      > = {}
+      for (const field of unionFieldsNotUsingEntry) {
+        fieldResolvers[field.name] = (obj, args, context, info): Entry => {
+          const fieldValue = obj[info.fieldName]
+          return this.collapseTypeField(field.type, fieldValue)
+        }
+      }
+
+      if (Object.keys(fieldResolvers).length > 0) {
+        resolvers[typeName] = fieldResolvers
+      }
+    }
+
+    return resolvers
+  }
+
+  private getFieldsWithUnionTypeNotUsingEntryTypes(
+    objectType: GraphQLObjectType,
+  ): GraphQLField<any, any>[] {
+    const fields = []
+    for (const fieldsKey in objectType.getFields()) {
+      const field: GraphQLField<any, any> = objectType.getFields()[fieldsKey]
+      if (
+        this.buildsOnUnionType(field.type) &&
+        !this.entryReferenceUtil.buildsOnTypeWithEntryDirective(field.type)
+      ) {
+        fields.push(field)
+      }
+    }
+    return fields
+  }
+
+  private buildsOnUnionType(type: GraphQLNullableType): boolean {
+    if (type instanceof GraphQLNonNull) {
+      return this.buildsOnUnionType(type.ofType)
+    } else if (type instanceof GraphQLList) {
+      return this.buildsOnUnionType(type.ofType)
+    } else if (type instanceof GraphQLUnionType) {
+      return true
+    } else if (type instanceof GraphQLObjectType) {
+      return false
+    }
+    return false
+  }
+
+  private collapseTypeField(
+    type: GraphQLNullableType,
+    fieldValue: Record<string, any> | Record<string, any>[],
+  ): Record<string, any> {
+    if (type instanceof GraphQLNonNull) {
+      return this.collapseTypeField(type.ofType, fieldValue)
+    } else if (type instanceof GraphQLList) {
+      if (!Array.isArray(fieldValue)) {
+        throw new Error('Expected array value')
+      }
+      return fieldValue.map((item) => this.collapseTypeField(type.ofType, item))
+    } else {
+      // Based on our @oneOf directive, we expect only one field whose name
+      // corresponds to the concrete type's name.
+      const firstKey = Object.keys(fieldValue)[0]
+      if (Array.isArray(fieldValue)) {
+        throw new Error('Did not expect array value')
+      }
+
+      // We replace the above name field that nests our concrete data directly
+      // with the data and a `__typename` field, so that our output data
+      // corresponds to the output schema provided by the user (i.e. there is
+      // no additional nesting level there).
+      return {
+        ...fieldValue[firstKey],
+        __typename: firstKey.slice(0, 1).toUpperCase() + firstKey.slice(1),
+      }
+    }
+  }
+}

package/src/graphql/schema-analyzer.service.ts

@@ -0,0 +1,70 @@
+import { GraphQLField, GraphQLObjectType, GraphQLSchema } from 'graphql'
+import { getDirective } from '@graphql-tools/utils'
+import { GraphQLInterfaceType, GraphQLUnionType } from 'graphql/type/definition'
+import { Kind } from 'graphql/language/kinds'
+import { ApolloContext } from '../app/api.service'
+import { EntryReferenceUtil } from './schema-utils/entry-reference-util'
+
+export class SchemaAnalyzerService {
+  constructor(private readonly entryReferenceUtil: EntryReferenceUtil) {}
+
+  public analyzeSchema(schema: GraphQLSchema): ISchemaAnalyzerResult {
+    const result: ISchemaAnalyzerResult = {
+      entryDirectiveTypes: [],
+      objectTypes: [],
+      interfaceTypes: [],
+      unionTypes: [],
+      typesWithEntryReferences: [],
+    }
+
+    const typeMap = schema.getTypeMap()
+
+    for (const [key, type] of Object.entries(typeMap)) {
+      if (key.startsWith('__')) {
+        continue
+      }
+
+      if (type.astNode?.kind === Kind.OBJECT_TYPE_DEFINITION) {
+        const objectType = type as GraphQLObjectType
+        result.objectTypes.push(objectType)
+        const entityDirective = getDirective(schema, objectType, 'Entry')?.[0]
+        if (entityDirective) {
+          result.entryDirectiveTypes.push(objectType)
+        }
+        const fieldsWithEntryReference =
+          this.entryReferenceUtil.getFieldsWithReferenceToTypeWithEntryDirective(
+            objectType,
+          )
+        if (fieldsWithEntryReference.length > 0) {
+          result.typesWithEntryReferences.push({
+            type: objectType,
+            fields: fieldsWithEntryReference,
+          })
+        }
+      }
+
+      if (type.astNode?.kind === Kind.INTERFACE_TYPE_DEFINITION) {
+        const interfaceType = type as GraphQLInterfaceType
+        result.interfaceTypes.push(interfaceType)
+      }
+
+      if (type.astNode?.kind === Kind.UNION_TYPE_DEFINITION) {
+        const unionType = type as GraphQLUnionType
+        result.unionTypes.push(unionType)
+      }
+    }
+
+    return result
+  }
+}
+
+export interface ISchemaAnalyzerResult {
+  entryDirectiveTypes: GraphQLObjectType[]
+  objectTypes: GraphQLObjectType[]
+  interfaceTypes: GraphQLInterfaceType[]
+  unionTypes: GraphQLUnionType[]
+  typesWithEntryReferences: {
+    type: GraphQLObjectType<any, ApolloContext>
+    fields: GraphQLField<any, ApolloContext>[]
+  }[]
+}