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

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

@@ -1,127 +0,0 @@
-import { PersistenceService } from '../../persistence/persistence.service'
-import { ApolloContext } from '../../app/api.service'
-import { EntryReferenceUtil } from '../schema-utils/entry-reference-util'
-import { GraphQLFieldResolver, isObjectType } from 'graphql'
-import { EntryData, EntryDraft } from '@commitspark/git-adapter'
-
-export class MutationUpdateResolverGenerator {
-  constructor(
-    private readonly persistence: PersistenceService,
-    private readonly entryReferenceUtil: EntryReferenceUtil,
-  ) {}
-
-  public createResolver(
-    typeName: string,
-  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<EntryData>> {
-    return async (
-      source,
-      args,
-      context: ApolloContext,
-      info,
-    ): Promise<EntryData> => {
-      if (!isObjectType(info.returnType)) {
-        throw new Error('Expected to update an ObjectType')
-      }
-
-      const existingEntry = await this.persistence.findByTypeId(
-        context.gitAdapter,
-        context.getCurrentRef(),
-        typeName,
-        args.id,
-      )
-
-      const existingReferencedEntryIds =
-        await this.entryReferenceUtil.getReferencedEntryIds(
-          info.returnType,
-          context,
-          null,
-          info.returnType,
-          existingEntry.data,
-        )
-
-      const mergedData = this.mergeData(existingEntry.data ?? null, args.data)
-      const updatedReferencedEntryIds =
-        await this.entryReferenceUtil.getReferencedEntryIds(
-          info.returnType,
-          context,
-          null,
-          info.returnType,
-          mergedData,
-        )
-
-      const noLongerReferencedIds = existingReferencedEntryIds.filter(
-        (entryId) => !updatedReferencedEntryIds.includes(entryId),
-      )
-      const newlyReferencedIds = updatedReferencedEntryIds.filter(
-        (entryId) => !existingReferencedEntryIds.includes(entryId),
-      )
-
-      const referencedEntryUpdates: EntryDraft[] = []
-      for (const noLongerReferencedEntryId of noLongerReferencedIds) {
-        const noLongerReferencedEntry = await this.persistence.findById(
-          context.gitAdapter,
-          context.getCurrentRef(),
-          noLongerReferencedEntryId,
-        )
-        referencedEntryUpdates.push({
-          ...noLongerReferencedEntry,
-          metadata: {
-            ...noLongerReferencedEntry.metadata,
-            referencedBy: noLongerReferencedEntry.metadata.referencedBy?.filter(
-              (entryId) => entryId !== args.id,
-            ),
-          },
-          deletion: false,
-        })
-      }
-      for (const newlyReferencedEntryId of newlyReferencedIds) {
-        const newlyReferencedEntry = await this.persistence.findById(
-          context.gitAdapter,
-          context.getCurrentRef(),
-          newlyReferencedEntryId,
-        )
-        const updatedReferenceList: string[] =
-          newlyReferencedEntry.metadata.referencedBy ?? []
-        updatedReferenceList.push(args.id)
-        updatedReferenceList.sort()
-        referencedEntryUpdates.push({
-          ...newlyReferencedEntry,
-          metadata: {
-            ...newlyReferencedEntry.metadata,
-            referencedBy: updatedReferenceList,
-          },
-          deletion: false,
-        })
-      }
-
-      const commit = await context.gitAdapter.createCommit({
-        ref: context.branch,
-        parentSha: context.getCurrentRef(),
-        entries: [
-          { ...existingEntry, data: mergedData, deletion: false },
-          ...referencedEntryUpdates,
-        ],
-        message: args.commitMessage,
-      })
-      context.setCurrentRef(commit.ref)
-
-      const updatedEntry = await this.persistence.findByTypeId(
-        context.gitAdapter,
-        context.getCurrentRef(),
-        typeName,
-        args.id,
-      )
-      return { ...updatedEntry.data, id: updatedEntry.id }
-    }
-  }
-
-  private mergeData(
-    existingEntryData: EntryData,
-    updateData: EntryData,
-  ): EntryData {
-    return {
-      ...existingEntryData,
-      ...updateData,
-    }
-  }
-}

package/src/graphql/resolver-generators/object-type-field-default-value-resolver-generator.ts

@@ -1,117 +0,0 @@
-import {
-  GraphQLField,
-  GraphQLFieldResolver,
-  GraphQLObjectType,
-  GraphQLOutputType,
-  GraphQLSchema,
-  isListType,
-  isNonNullType,
-  isObjectType,
-  isUnionType,
-} from 'graphql'
-import { ApolloContext } from '../../app/api.service'
-import { EntryData } from '@commitspark/git-adapter'
-import { ResolvedEntryData } from '../field-resolver/fieldResolver'
-import { FieldDefaultValueResolver } from '../field-resolver/field-default-value-resolver'
-
-export class ObjectTypeFieldDefaultValueResolverGenerator {
-  constructor(
-    private readonly fieldDefaultValueResolver: FieldDefaultValueResolver,
-  ) {}
-
-  public createResolver(
-    schema: GraphQLSchema,
-  ): Record<
-    string,
-    Record<
-      string,
-      GraphQLFieldResolver<
-        any,
-        ApolloContext,
-        any,
-        Promise<ResolvedEntryData<EntryData | EntryData[] | null>>
-      >
-    >
-  > {
-    const resolvers: Record<
-      string,
-      Record<
-        string,
-        GraphQLFieldResolver<
-          any,
-          ApolloContext,
-          any,
-          Promise<ResolvedEntryData<EntryData | EntryData[] | null>>
-        >
-      >
-    > = {}
-    for (const typeName of Object.keys(schema.getTypeMap())) {
-      const type = schema.getType(typeName)
-      if (!isObjectType(type) || type.name.startsWith('__')) {
-        continue
-      }
-      const objectType = type as GraphQLObjectType
-      const fieldsForCustomDefaultValueResolver =
-        this.getFieldsForCustomDefaultValueResolver(objectType)
-
-      const fieldResolvers: Record<
-        string,
-        GraphQLFieldResolver<
-          any,
-          ApolloContext,
-          any,
-          Promise<ResolvedEntryData<EntryData | EntryData[] | null>>
-        >
-      > = {}
-      for (const field of fieldsForCustomDefaultValueResolver) {
-        fieldResolvers[field.name] = (
-          obj,
-          args,
-          context,
-          info,
-        ): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> =>
-          this.fieldDefaultValueResolver.resolve(
-            field.name in obj ? obj[field.name] : undefined,
-            args,
-            {
-              gitAdapter: context.gitAdapter,
-              getCurrentRef: context.getCurrentRef,
-            },
-            info,
-          )
-      }
-
-      if (Object.keys(fieldResolvers).length > 0) {
-        resolvers[typeName] = fieldResolvers
-      }
-    }
-
-    return resolvers
-  }
-
-  private getFieldsForCustomDefaultValueResolver(
-    objectType: GraphQLObjectType,
-  ): GraphQLField<any, any>[] {
-    const fields = []
-    for (const fieldsKey in objectType.getFields()) {
-      const field: GraphQLField<any, any> = objectType.getFields()[fieldsKey]
-      if (this.requiresCustomDefaultValueResolver(field.type)) {
-        fields.push(field)
-      }
-    }
-    return fields
-  }
-
-  private requiresCustomDefaultValueResolver(type: GraphQLOutputType): boolean {
-    if (isNonNullType(type)) {
-      return this.requiresCustomDefaultValueResolver(type.ofType)
-    } else if (isListType(type)) {
-      return true
-    } else if (isUnionType(type)) {
-      return true
-    } else if (isObjectType(type)) {
-      return true
-    }
-    return false
-  }
-}

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

@@ -1,29 +0,0 @@
-import { ApolloContext } from '../../app/api.service'
-import { EntryData } from '@commitspark/git-adapter'
-import { PersistenceService } from '../../persistence/persistence.service'
-import { GraphQLFieldResolver } from 'graphql'
-
-export class QueryAllResolverGenerator {
-  constructor(private readonly persistence: PersistenceService) {}
-
-  public createResolver(
-    typeName: string,
-  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<EntryData[]>> {
-    return async (
-      obj,
-      args,
-      context: ApolloContext,
-      info,
-    ): Promise<EntryData[]> => {
-      const entries = await this.persistence.findByType(
-        context.gitAdapter,
-        context.getCurrentRef(),
-        typeName,
-      )
-
-      return entries.map((entry) => {
-        return { ...entry.data, id: entry.id }
-      })
-    }
-  }
-}

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

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

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

@@ -1,29 +0,0 @@
-import { PersistenceService } from '../../persistence/persistence.service'
-import { GraphQLFieldResolver } from 'graphql'
-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

@@ -1,27 +0,0 @@
-import { PersistenceService } from '../../persistence/persistence.service'
-import { GraphQLFieldResolver } from 'graphql'
-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

@@ -1,38 +0,0 @@
-import { ApolloContext } from '../../app/api.service'
-import { PersistenceService } from '../../persistence/persistence.service'
-import {
-  GraphQLAbstractType,
-  GraphQLResolveInfo,
-  GraphQLTypeResolver,
-} from 'graphql'
-import { EntryTypeUtil } from '../schema-utils/entry-type-util'
-
-export class UnionTypeResolverGenerator {
-  constructor(
-    private readonly persistence: PersistenceService,
-    private readonly entryTypeUtil: EntryTypeUtil,
-  ) {}
-
-  public createResolver(): GraphQLTypeResolver<any, ApolloContext> {
-    return async (
-      obj: any,
-      context: ApolloContext,
-      info: GraphQLResolveInfo,
-      abstractType: GraphQLAbstractType,
-    ): Promise<string> => {
-      if (this.entryTypeUtil.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 UnionValueResolver. 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/schema-analyzer.service.ts

@@ -1,57 +0,0 @@
-import {
-  GraphQLInterfaceType,
-  GraphQLObjectType,
-  GraphQLSchema,
-  GraphQLUnionType,
-  isInterfaceType,
-  isObjectType,
-  isUnionType,
-} from 'graphql'
-import { getDirective } from '@graphql-tools/utils'
-
-export class SchemaAnalyzerService {
-  public analyzeSchema(schema: GraphQLSchema): ISchemaAnalyzerResult {
-    const result: ISchemaAnalyzerResult = {
-      entryDirectiveTypes: [],
-      objectTypes: [],
-      interfaceTypes: [],
-      unionTypes: [],
-    }
-
-    const typeMap = schema.getTypeMap()
-
-    for (const [key, type] of Object.entries(typeMap)) {
-      if (key.startsWith('__')) {
-        continue
-      }
-
-      if (isObjectType(type)) {
-        const objectType = type as GraphQLObjectType
-        result.objectTypes.push(objectType)
-        const entityDirective = getDirective(schema, objectType, 'Entry')?.[0]
-        if (entityDirective) {
-          result.entryDirectiveTypes.push(objectType)
-        }
-      }
-
-      if (isInterfaceType(type)) {
-        const interfaceType = type as GraphQLInterfaceType
-        result.interfaceTypes.push(interfaceType)
-      }
-
-      if (isUnionType(type)) {
-        const unionType = type as GraphQLUnionType
-        result.unionTypes.push(unionType)
-      }
-    }
-
-    return result
-  }
-}
-
-export interface ISchemaAnalyzerResult {
-  entryDirectiveTypes: GraphQLObjectType[]
-  objectTypes: GraphQLObjectType[]
-  interfaceTypes: GraphQLInterfaceType[]
-  unionTypes: GraphQLUnionType[]
-}

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

@@ -1,178 +0,0 @@
-import { QueriesMutationsGeneratorService } from './queries-mutations-generator.service'
-import {
-  IExecutableSchemaDefinition,
-  makeExecutableSchema,
-} from '@graphql-tools/schema'
-import { SchemaAnalyzerService } from './schema-analyzer.service'
-import { InputTypeGeneratorService } from './input-type-generator.service'
-import { SchemaRootTypeGeneratorService } from './schema-root-type-generator.service'
-import { printSchemaWithDirectives } from '@graphql-tools/utils'
-import { UnionTypeResolverGenerator } from './resolver-generators/union-type-resolver-generator'
-import { ApolloContext } from '../app/api.service'
-import { GraphQLFieldResolver, GraphQLTypeResolver } from 'graphql'
-import { SchemaValidator } from './schema-validator'
-import { EntryData } from '@commitspark/git-adapter'
-import { ObjectTypeFieldDefaultValueResolverGenerator } from './resolver-generators/object-type-field-default-value-resolver-generator'
-
-export class SchemaGeneratorService {
-  constructor(
-    private readonly queriesMutationsGenerator: QueriesMutationsGeneratorService,
-    private readonly schemaAnalyzer: SchemaAnalyzerService,
-    private readonly inputTypeGenerator: InputTypeGeneratorService,
-    private readonly schemaRootTypeGenerator: SchemaRootTypeGeneratorService,
-    private readonly unionTypeResolverGenerator: UnionTypeResolverGenerator,
-    private readonly objectTypeFieldDefaultValueResolverGenerator: ObjectTypeFieldDefaultValueResolverGenerator,
-    private readonly schemaValidator: SchemaValidator,
-  ) {}
-
-  public async generateSchema(
-    context: ApolloContext,
-  ): Promise<IExecutableSchemaDefinition> {
-    const originalSchemaString = await context.gitAdapter.getSchema(
-      context.getCurrentRef(),
-    )
-    const schema = makeExecutableSchema({
-      typeDefs: originalSchemaString,
-    })
-
-    const validationResult = this.schemaValidator.getValidationResult(schema)
-    if (validationResult.length > 0) {
-      throw new Error(validationResult.join('\n'))
-    }
-    const schemaAnalyzerResult = this.schemaAnalyzer.analyzeSchema(schema)
-
-    const filteredOriginalSchemaString =
-      printSchemaWithDirectives(schema) + '\n'
-
-    const generatedIdInputTypeStrings =
-      this.inputTypeGenerator.generateIdInputTypeStrings(schemaAnalyzerResult)
-
-    const generatedQueriesMutations =
-      this.queriesMutationsGenerator.generateFromAnalyzedSchema(
-        schemaAnalyzerResult.entryDirectiveTypes,
-      )
-    const generatedTypeNameQuery =
-      this.queriesMutationsGenerator.generateTypeNameQuery()
-
-    const generatedEntryReferenceResolvers: Record<
-      string,
-      Record<
-        string,
-        GraphQLFieldResolver<
-          Record<string, any>,
-          ApolloContext,
-          any,
-          Promise<EntryData | EntryData[] | null>
-        >
-      >
-    > = {}
-
-    const generatedObjectInputTypeStrings =
-      this.inputTypeGenerator.generateObjectInputTypeStrings(
-        schemaAnalyzerResult.objectTypes,
-      )
-
-    const generatedUnionInputTypeStrings =
-      this.inputTypeGenerator.generateUnionInputTypeStrings(
-        schemaAnalyzerResult.unionTypes,
-      )
-
-    const generatedSchemaRootTypeStrings =
-      this.schemaRootTypeGenerator.generateSchemaRootTypeStrings(
-        generatedQueriesMutations,
-        generatedTypeNameQuery,
-      )
-
-    const generatedSchemaString =
-      'schema {\n  query: Query\n  mutation: Mutation\n}\n\n' +
-      generatedSchemaRootTypeStrings +
-      '\n' +
-      'type ListMetadata {\n' +
-      '  count: Int!\n' +
-      '}\n'
-
-    const generatedUnionTypeResolvers: Record<string, UnionTypeResolver> = {}
-    for (const unionType of schemaAnalyzerResult.unionTypes) {
-      generatedUnionTypeResolvers[unionType.name] = {
-        __resolveType: this.unionTypeResolverGenerator.createResolver(),
-      }
-    }
-    const generatedObjectTypeFieldDefaultValueResolvers =
-      this.objectTypeFieldDefaultValueResolverGenerator.createResolver(schema)
-
-    const generatedQueryResolvers: Record<
-      string,
-      GraphQLFieldResolver<any, ApolloContext>
-    > = {}
-    const generatedMutationResolvers: Record<
-      string,
-      GraphQLFieldResolver<any, ApolloContext>
-    > = {}
-
-    for (const element of generatedQueriesMutations) {
-      generatedQueryResolvers[element.queryAll.name] = element.queryAll.resolver
-      generatedQueryResolvers[element.queryAllMeta.name] =
-        element.queryAllMeta.resolver
-      generatedQueryResolvers[element.queryById.name] =
-        element.queryById.resolver
-      generatedMutationResolvers[element.createMutation.name] =
-        element.createMutation.resolver
-      generatedMutationResolvers[element.updateMutation.name] =
-        element.updateMutation.resolver
-      generatedMutationResolvers[element.deleteMutation.name] =
-        element.deleteMutation.resolver
-    }
-    generatedQueryResolvers[generatedTypeNameQuery.name] =
-      generatedTypeNameQuery.resolver
-
-    const allGeneratedResolvers: Record<
-      string,
-      Record<
-        string,
-        | GraphQLFieldResolver<any, ApolloContext>
-        | GraphQLTypeResolver<any, ApolloContext>
-      >
-    > = {
-      Query: generatedQueryResolvers,
-      Mutation: generatedMutationResolvers,
-    }
-
-    for (const typeName of Object.keys(generatedUnionTypeResolvers)) {
-      allGeneratedResolvers[typeName] = {
-        ...(allGeneratedResolvers[typeName] ?? {}),
-        ...generatedUnionTypeResolvers[typeName],
-      }
-    }
-    for (const typeName of Object.keys(
-      generatedObjectTypeFieldDefaultValueResolvers,
-    )) {
-      allGeneratedResolvers[typeName] = {
-        ...(allGeneratedResolvers[typeName] ?? {}),
-        ...generatedObjectTypeFieldDefaultValueResolvers[typeName],
-      }
-    }
-    for (const typeName of Object.keys(generatedEntryReferenceResolvers)) {
-      allGeneratedResolvers[typeName] = {
-        ...(allGeneratedResolvers[typeName] ?? {}),
-        ...generatedEntryReferenceResolvers[typeName],
-      }
-    }
-
-    const typeDefs = [
-      filteredOriginalSchemaString,
-      generatedSchemaString,
-      generatedIdInputTypeStrings.join('\n'),
-      generatedObjectInputTypeStrings.join('\n'),
-      generatedUnionInputTypeStrings.join('\n'),
-    ].filter((typeDef) => typeDef.length > 0)
-
-    return {
-      typeDefs: typeDefs,
-      resolvers: allGeneratedResolvers,
-    }
-  }
-}
-
-interface UnionTypeResolver {
-  __resolveType: GraphQLTypeResolver<any, ApolloContext>
-}

package/src/graphql/schema-root-type-generator.service.ts

@@ -1,44 +0,0 @@
-import {
-  IGeneratedQuery,
-  IGeneratedSchema,
-} from './queries-mutations-generator.service'
-
-export class SchemaRootTypeGeneratorService {
-  public generateSchemaRootTypeStrings(
-    generatedSchemas: IGeneratedSchema[],
-    typeQuery: IGeneratedQuery<Promise<string>>,
-  ): string {
-    return (
-      `type Query {\n` +
-      generatedSchemas
-        .map((generated) => '  ' + generated.queryAll.schemaString)
-        .join('\n') +
-      '\n' +
-      generatedSchemas
-        .map((generated) => '  ' + generated.queryAllMeta.schemaString)
-        .join('\n') +
-      '\n' +
-      generatedSchemas
-        .map((generated) => '  ' + generated.queryById.schemaString)
-        .join('\n') +
-      '\n' +
-      `  ${typeQuery.schemaString}` +
-      '\n' +
-      '}\n\n' +
-      'type Mutation {\n' +
-      generatedSchemas
-        .map((generated) => '  ' + generated.createMutation.schemaString)
-        .join('\n') +
-      '\n' +
-      generatedSchemas
-        .map((generated) => '  ' + generated.updateMutation.schemaString)
-        .join('\n') +
-      '\n' +
-      generatedSchemas
-        .map((generated) => '  ' + generated.deleteMutation.schemaString)
-        .join('\n') +
-      '\n' +
-      '}\n'
-    )
-  }
-}