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

package/src/graphql/field-resolver/field-default-value-resolver.ts

@@ -1,152 +0,0 @@
-import {
-  FieldResolver,
-  FieldResolverContext,
-  ResolvedEntryData,
-} from './fieldResolver'
-import { EntryData } from '@commitspark/git-adapter'
-import {
-  GraphQLFieldResolver,
-  GraphQLNonNull,
-  GraphQLOutputType,
-  GraphQLResolveInfo,
-  GraphQLUnionType,
-  isListType,
-  isNonNullType,
-  isObjectType,
-  isUnionType,
-} from 'graphql'
-import { EntryTypeUtil } from '../schema-utils/entry-type-util'
-import { UnionValueResolver } from './union-value-resolver'
-import { EntryReferenceResolver } from './entry-reference-resolver'
-
-export class FieldDefaultValueResolver implements FieldResolver<any> {
-  resolve: GraphQLFieldResolver<
-    any,
-    FieldResolverContext,
-    any,
-    Promise<ResolvedEntryData<EntryData | EntryData[] | null>>
-  >
-
-  constructor(
-    private readonly entryTypeUtil: EntryTypeUtil,
-    private readonly unionValueResolver: UnionValueResolver,
-    private readonly entryReferenceResolver: EntryReferenceResolver,
-  ) {
-    this.resolve = (
-      fieldValue,
-      args,
-      context,
-      info,
-    ): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> =>
-      this.resolveFieldValue(
-        fieldValue,
-        args,
-        context,
-        info,
-        info.returnType,
-        false,
-      )
-  }
-
-  private resolveFieldValue(
-    fieldValue: any,
-    args: any,
-    context: FieldResolverContext,
-    info: GraphQLResolveInfo,
-    currentType: GraphQLOutputType,
-    hasNonNullParent: boolean,
-  ): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> {
-    if (isNonNullType(currentType)) {
-      return this.resolveFieldValue(
-        fieldValue,
-        args,
-        {
-          gitAdapter: context.gitAdapter,
-          getCurrentRef: context.getCurrentRef,
-        },
-        info,
-        currentType.ofType,
-        true,
-      )
-    } else if (isListType(currentType)) {
-      if (fieldValue === undefined || fieldValue === null) {
-        if (hasNonNullParent) {
-          return new Promise((resolve) => resolve([]))
-        } else {
-          return new Promise((resolve) => resolve(null))
-        }
-      }
-
-      if (!Array.isArray(fieldValue)) {
-        throw new Error(
-          `Expected array while resolving value for field "${info.fieldName}".`,
-        )
-      }
-
-      const resultPromises = []
-      for (const item of fieldValue) {
-        const resultPromise = this.resolveFieldValue(
-          item,
-          args,
-          {
-            gitAdapter: context.gitAdapter,
-            getCurrentRef: context.getCurrentRef,
-          },
-          info,
-          currentType.ofType,
-          hasNonNullParent,
-        )
-        resultPromises.push(resultPromise)
-      }
-      return Promise.all(resultPromises)
-    } else if (isUnionType(currentType)) {
-      if (fieldValue === undefined || fieldValue === null) {
-        if (hasNonNullParent) {
-          throw new Error(
-            `Cannot generate a default value for NonNull field "${
-              info.parentType.name
-            }.${info.fieldName}" because it is a union field of type "${
-              (info.returnType as GraphQLNonNull<GraphQLUnionType>).ofType.name
-            }".`,
-          )
-        } else {
-          return new Promise((resolve) => resolve(null))
-        }
-      }
-
-      if (this.entryTypeUtil.buildsOnTypeWithEntryDirective(currentType)) {
-        return this.entryReferenceResolver.resolve(
-          fieldValue,
-          args,
-          context,
-          info,
-        )
-      }
-
-      return this.unionValueResolver.resolve(fieldValue, args, context, info)
-    } else if (isObjectType(currentType)) {
-      if (fieldValue === undefined || fieldValue === null) {
-        if (hasNonNullParent) {
-          throw new Error(
-            `Cannot generate a default value for NonNull field "${info.fieldName}" of type "${info.parentType.name}".`,
-          )
-        } else {
-          return new Promise((resolve) => resolve(null))
-        }
-      }
-
-      if (this.entryTypeUtil.hasEntryDirective(currentType)) {
-        return this.entryReferenceResolver.resolve(
-          fieldValue,
-          args,
-          context,
-          info,
-        )
-      }
-
-      return fieldValue
-    }
-
-    return fieldValue
-  }
-}

package/src/graphql/field-resolver/union-value-resolver.ts

@@ -1,46 +0,0 @@
-import { GraphQLFieldResolver } from 'graphql/type/definition'
-import { EntryData } from '@commitspark/git-adapter'
-import {
-  FieldResolver,
-  FieldResolverContext,
-  ResolvedEntryData,
-} from './fieldResolver'
-import { UnionTypeUtil } from '../schema-utils/union-type-util'
-
-export class UnionValueResolver implements FieldResolver<any> {
-  resolve: GraphQLFieldResolver<
-    any,
-    FieldResolverContext,
-    any,
-    Promise<ResolvedEntryData<EntryData | EntryData[] | null>>
-  >
-
-  constructor(private readonly unionTypeUtil: UnionTypeUtil) {
-    this.resolve = (
-      fieldValue,
-      args,
-      context,
-      info,
-    ): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> =>
-      this.resolveFieldValue(fieldValue)
-  }
-
-  private resolveFieldValue(
-    fieldValue: any,
-  ): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> {
-    const typeName =
-      this.unionTypeUtil.getUnionTypeNameFromFieldValue(fieldValue)
-    const unionValue = this.unionTypeUtil.getUnionValue(fieldValue)
-
-    // We replace the helper type name field that holds our field's actual data
-    // with this actual data and add 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).
-    const res: EntryData = {
-      ...unionValue,
-      __typename: typeName,
-    }
-
-    return new Promise((resolve) => resolve(res))
-  }
-}

package/src/graphql/input-type-generator.service.ts

@@ -1,127 +0,0 @@
-import {
-  GraphQLEnumType,
-  GraphQLInputObjectType,
-  GraphQLInterfaceType,
-  GraphQLNullableType,
-  GraphQLObjectType,
-  GraphQLScalarType,
-  GraphQLUnionType,
-  isInterfaceType,
-  isListType,
-  isNonNullType,
-  isObjectType,
-  isScalarType,
-  isUnionType,
-} from 'graphql'
-import { ISchemaAnalyzerResult } from './schema-analyzer.service'
-import { EntryTypeUtil } from './schema-utils/entry-type-util'
-
-export class InputTypeGeneratorService {
-  constructor(private readonly entryTypeUtil: EntryTypeUtil) {}
-
-  public generateFieldInputTypeString(type: GraphQLNullableType): string {
-    if (isListType(type)) {
-      return `[${this.generateFieldInputTypeString(type.ofType)}]`
-    } else if (isNonNullType(type)) {
-      return `${this.generateFieldInputTypeString(type.ofType)}!`
-    } else if (isObjectType(type)) {
-      if (this.entryTypeUtil.hasEntryDirective(type)) {
-        return `${type.name}IdInput`
-      } else {
-        return `${type.name}Input`
-      }
-    } else if (isInterfaceType(type)) {
-      // TODO
-      return ''
-    } else if (isUnionType(type)) {
-      if (this.entryTypeUtil.buildsOnTypeWithEntryDirective(type)) {
-        return `${type.name}IdInput`
-      } else {
-        return `${type.name}Input`
-      }
-    } else {
-      return (
-        type as GraphQLScalarType | GraphQLEnumType | GraphQLInputObjectType
-      ).name
-    }
-  }
-
-  public generateIdInputTypeStrings(
-    schemaAnalyzerResult: ISchemaAnalyzerResult,
-  ): string[] {
-    let typesWithIdField: (
-      | GraphQLObjectType
-      | GraphQLInterfaceType
-      | GraphQLUnionType
-    )[] = []
-    typesWithIdField = typesWithIdField.concat(
-      schemaAnalyzerResult.entryDirectiveTypes,
-    )
-    typesWithIdField = typesWithIdField.concat(
-      schemaAnalyzerResult.interfaceTypes,
-    )
-    typesWithIdField = typesWithIdField.concat(schemaAnalyzerResult.unionTypes)
-
-    return typesWithIdField.map((type): string => {
-      return `input ${type.name}IdInput {\n` + '  id: ID!\n' + '}\n'
-    })
-  }
-
-  public generateObjectInputTypeStrings(
-    objectTypes: GraphQLObjectType[],
-  ): string[] {
-    return objectTypes.map((objectType): string => {
-      const name = objectType.name
-      const inputTypeName = `${name}Input`
-      let inputType = `input ${inputTypeName} {\n`
-      let inputTypeFieldStrings = ''
-      for (const fieldsKey in objectType.getFields()) {
-        const field = objectType.getFields()[fieldsKey]
-        if (
-          (isNonNullType(field.type) &&
-            isScalarType(field.type.ofType) &&
-            field.type.ofType.name === 'ID') ||
-          (isScalarType(field.type) && field.type.name === 'ID')
-        ) {
-          continue
-        }
-        const inputTypeString = this.generateFieldInputTypeString(field.type)
-        inputTypeFieldStrings += `  ${field.name}: ${inputTypeString}\n`
-      }
-
-      if (inputTypeFieldStrings.length > 0) {
-        inputType += `${inputTypeFieldStrings}`
-      } else {
-        // generate a dummy field as empty input types are not permitted
-        inputType += '  _: Boolean\n'
-      }
-      inputType += '}\n'
-
-      return inputType
-    })
-  }
-
-  public generateUnionInputTypeStrings(
-    unionTypes: GraphQLUnionType[],
-  ): string[] {
-    const typeStrings = unionTypes.map((unionType): string => {
-      if (this.entryTypeUtil.buildsOnTypeWithEntryDirective(unionType)) {
-        return ''
-      }
-
-      // see https://github.com/graphql/graphql-spec/pull/825
-      let unionInputType = `input ${unionType.name}Input @oneOf {\n`
-      for (const innerType of unionType.getTypes()) {
-        unionInputType += `  ${innerType.name}: ${innerType.name}Input\n`
-      }
-      unionInputType += '}\n'
-      return unionInputType
-    })
-
-    if (typeStrings.join('').length > 0) {
-      typeStrings.push('directive @oneOf on INPUT_OBJECT\n')
-    }
-
-    return typeStrings
-  }
-}

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

@@ -1,154 +0,0 @@
-import { EntryData } from '@commitspark/git-adapter'
-import { ApolloContext } from '../app/api.service'
-import { GraphQLFieldResolver, GraphQLObjectType } from 'graphql'
-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<EntryData[]>
-      > = 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<EntryData>
-      > = this.queryByIdResolverGenerator.createResolver(typeName)
-
-      const inputTypeName = `${typeName}Input`
-      const createMutationName = `create${typeName}`
-      const createMutationString = `${createMutationName}(id: ID!, data: ${inputTypeName}!, commitMessage: String): ${typeName}`
-      const createMutationResolver: GraphQLFieldResolver<
-        any,
-        ApolloContext,
-        any,
-        Promise<EntryData>
-      > = this.mutationCreateResolverGenerator.createResolver(typeName)
-
-      const updateMutationName = `update${typeName}`
-      const updateMutationString = `${updateMutationName}(id: ID!, data: ${inputTypeName}!, commitMessage: String): ${typeName}`
-      const updateMutationResolver: GraphQLFieldResolver<
-        any,
-        ApolloContext,
-        any,
-        Promise<EntryData>
-      > = this.mutationUpdateResolverGenerator.createResolver(typeName)
-
-      const deleteMutationName = `delete${typeName}`
-      const deleteMutationString = `${deleteMutationName}(id: ID!, commitMessage: String): ID`
-      const deleteMutationResolver: GraphQLFieldResolver<
-        any,
-        ApolloContext,
-        any,
-        Promise<EntryData>
-      > = 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 entryTypeQueryName = '_typeName'
-    const entryTypeQueryString = `${entryTypeQueryName}(id: ID!): String!`
-    const entryTypeQueryResolver: GraphQLFieldResolver<
-      any,
-      ApolloContext,
-      any,
-      Promise<string>
-    > = this.queryTypeByIdResolverGenerator.createResolver()
-
-    return {
-      name: entryTypeQueryName,
-      schemaString: entryTypeQueryString,
-      resolver: entryTypeQueryResolver,
-    }
-  }
-}
-
-export interface IGeneratedSchema {
-  queryAll: IGeneratedQuery<Promise<EntryData[]>>
-  queryAllMeta: IGeneratedQuery<Promise<TypeCount>>
-  queryById: IGeneratedQuery<Promise<EntryData>>
-  createMutation: IGeneratedQuery<Promise<EntryData>>
-  updateMutation: IGeneratedQuery<Promise<EntryData>>
-  deleteMutation: IGeneratedQuery<Promise<EntryData>>
-}
-
-export interface IGeneratedQuery<T> {
-  name: string
-  schemaString: string
-  resolver: GraphQLFieldResolver<any, ApolloContext, any, T>
-}
-
-export type TypeCount = {
-  count: number
-}

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

@@ -1,120 +0,0 @@
-import { ApolloContext } from '../../app/api.service'
-import { PersistenceService } from '../../persistence/persistence.service'
-import { GraphQLError, GraphQLFieldResolver, isObjectType } from 'graphql'
-import { EntryReferenceUtil } from '../schema-utils/entry-reference-util'
-import {
-  ENTRY_ID_INVALID_CHARACTERS,
-  EntryData,
-  EntryDraft,
-} from '@commitspark/git-adapter'
-
-export class MutationCreateResolverGenerator {
-  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 create an ObjectType')
-      }
-
-      const idValidationResult = args.id.match(ENTRY_ID_INVALID_CHARACTERS)
-      if (idValidationResult) {
-        throw new GraphQLError(
-          `"id" contains invalid characters "${idValidationResult.join(', ')}"`,
-          {
-            extensions: {
-              code: 'BAD_USER_INPUT',
-              argumentName: 'id',
-            },
-          },
-        )
-      }
-
-      let existingEntry
-      try {
-        existingEntry = await this.persistence.findById(
-          context.gitAdapter,
-          context.getCurrentRef(),
-          args.id,
-        )
-      } catch (_) {
-        /* empty */
-      }
-      if (existingEntry) {
-        throw new GraphQLError(`An entry with id "${args.id}" already exists`, {
-          extensions: {
-            code: 'BAD_USER_INPUT',
-            argumentName: 'id',
-          },
-        })
-      }
-
-      const referencedEntryIds =
-        await this.entryReferenceUtil.getReferencedEntryIds(
-          info.returnType,
-          context,
-          null,
-          info.returnType,
-          args.data,
-        )
-
-      const referencedEntryUpdates: EntryDraft[] = []
-      for (const referencedEntryId of referencedEntryIds) {
-        const referencedEntry = await this.persistence.findById(
-          context.gitAdapter,
-          context.getCurrentRef(),
-          referencedEntryId,
-        )
-        const newReferencedEntryIds: string[] = [
-          ...(referencedEntry.metadata.referencedBy ?? []),
-          args.id,
-        ].sort()
-        const newReferencedEntryDraft: EntryDraft = {
-          ...referencedEntry,
-          metadata: {
-            ...referencedEntry.metadata,
-            referencedBy: newReferencedEntryIds,
-          },
-          deletion: false,
-        }
-        referencedEntryUpdates.push(newReferencedEntryDraft)
-      }
-
-      const newEntryDraft: EntryDraft = {
-        id: args.id,
-        metadata: {
-          type: typeName,
-          referencedBy: [],
-        },
-        data: args.data,
-        deletion: false,
-      }
-
-      const commit = await context.gitAdapter.createCommit({
-        ref: context.branch,
-        parentSha: context.getCurrentRef(),
-        entries: [newEntryDraft, ...referencedEntryUpdates],
-        message: args.commitMessage,
-      })
-      context.setCurrentRef(commit.ref)
-
-      const newEntry = await this.persistence.findByTypeId(
-        context.gitAdapter,
-        context.getCurrentRef(),
-        typeName,
-        args.id,
-      )
-      return { ...newEntry.data, id: newEntry.id }
-    }
-  }
-}

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

@@ -1,96 +0,0 @@
-import { PersistenceService } from '../../persistence/persistence.service'
-import { ApolloContext } from '../../app/api.service'
-import { Entry, EntryData, EntryDraft } from '@commitspark/git-adapter'
-import { EntryReferenceUtil } from '../schema-utils/entry-reference-util'
-import { GraphQLError, GraphQLFieldResolver, isObjectType } from 'graphql'
-
-export class MutationDeleteResolverGenerator {
-  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> => {
-      const entry: Entry = await this.persistence.findByTypeId(
-        context.gitAdapter,
-        context.getCurrentRef(),
-        typeName,
-        args.id,
-      )
-
-      if (
-        entry.metadata.referencedBy &&
-        entry.metadata.referencedBy.length > 0
-      ) {
-        const otherIds = entry.metadata.referencedBy
-          .map((referenceId) => `"${referenceId}"`)
-          .join(', ')
-        throw new GraphQLError(
-          `Entry with id "${args.id}" is referenced by other entries: [${otherIds}]`,
-          {
-            extensions: {
-              code: 'IN_USE',
-              argumentName: 'id',
-            },
-          },
-        )
-      }
-
-      const entryType = info.schema.getType(typeName)
-      if (!isObjectType(entryType)) {
-        throw new Error('Expected to delete an ObjectType')
-      }
-
-      const referencedEntryIds =
-        await this.entryReferenceUtil.getReferencedEntryIds(
-          entryType,
-          context,
-          null,
-          entryType,
-          entry.data,
-        )
-      const referencedEntryUpdates: EntryDraft[] = []
-      for (const referencedEntryId of referencedEntryIds) {
-        const noLongerReferencedEntry = await this.persistence.findById(
-          context.gitAdapter,
-          context.getCurrentRef(),
-          referencedEntryId,
-        )
-        referencedEntryUpdates.push({
-          ...noLongerReferencedEntry,
-          metadata: {
-            ...noLongerReferencedEntry.metadata,
-            referencedBy: noLongerReferencedEntry.metadata.referencedBy?.filter(
-              (entryId) => entryId !== args.id,
-            ),
-          },
-          deletion: false,
-        })
-      }
-
-      const commit = await context.gitAdapter.createCommit({
-        ref: context.branch,
-        parentSha: context.getCurrentRef(),
-        entries: [
-          {
-            ...entry,
-            deletion: true,
-          },
-          ...referencedEntryUpdates,
-        ],
-        message: args.commitMessage,
-      })
-      context.setCurrentRef(commit.ref)
-
-      return args.id
-    }
-  }
-}