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

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

@@ -0,0 +1,126 @@
+import {
+  GraphQLEnumType,
+  GraphQLInputObjectType,
+  GraphQLInterfaceType,
+  GraphQLNullableType,
+  GraphQLObjectType,
+  GraphQLScalarType,
+  GraphQLUnionType,
+  isInterfaceType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isScalarType,
+  isUnionType,
+} from 'graphql'
+import { SchemaAnalyzerResult } from './schema-analyzer'
+import {
+  buildsOnTypeWithEntryDirective,
+  hasEntryDirective,
+} from './schema-utils/entry-type-util'
+
+function generateFieldInputTypeString(type: GraphQLNullableType): string {
+  if (isListType(type)) {
+    return `[${generateFieldInputTypeString(type.ofType)}]`
+  } else if (isNonNullType(type)) {
+    return `${generateFieldInputTypeString(type.ofType)}!`
+  } else if (isObjectType(type)) {
+    if (hasEntryDirective(type)) {
+      return `${type.name}IdInput`
+    } else {
+      return `${type.name}Input`
+    }
+  } else if (isInterfaceType(type)) {
+    // TODO
+    return ''
+  } else if (isUnionType(type)) {
+    if (buildsOnTypeWithEntryDirective(type)) {
+      return `${type.name}IdInput`
+    } else {
+      return `${type.name}Input`
+    }
+  } else {
+    return (
+      type as GraphQLScalarType | GraphQLEnumType | GraphQLInputObjectType
+    ).name
+  }
+}
+
+export function generateIdInputTypeStrings(
+  schemaAnalyzerResult: SchemaAnalyzerResult,
+): 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'
+  })
+}
+
+export function 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 = 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
+  })
+}
+
+export function generateUnionInputTypeStrings(
+  unionTypes: GraphQLUnionType[],
+): string[] {
+  const typeStrings = unionTypes.map((unionType): string => {
+    if (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.ts

@@ -0,0 +1,138 @@
+import { EntryData } from '@commitspark/git-adapter'
+import { ApolloContext } from '../client'
+import { GraphQLFieldResolver, GraphQLObjectType } from 'graphql'
+import { queryEveryResolver } from './resolvers/query-mutation-resolvers/query-every-resolver'
+import { queryByIdResolver } from './resolvers/query-mutation-resolvers/query-by-id-resolver'
+import { mutationCreateResolver } from './resolvers/query-mutation-resolvers/mutation-create-resolver'
+import { mutationUpdateResolver } from './resolvers/query-mutation-resolvers/mutation-update-resolver'
+import { mutationDeleteResolver } from './resolvers/query-mutation-resolvers/mutation-delete-resolver'
+import { queryTypeByIdResolver } from './resolvers/query-mutation-resolvers/query-type-by-id-resolver'
+import { QueryMutationResolver } from './resolvers/types'
+
+export function generateQueriesAndMutations(
+  entryDirectiveTypes: GraphQLObjectType[],
+): GeneratedSchema[] {
+  return entryDirectiveTypes.map((objectType): GeneratedSchema => {
+    const typeName = objectType.name
+
+    // The semantics of `every` aren't a perfect replacement of `all` but this way we don't need to do non-trivial
+    // pluralization of user-provided typeName
+    const queryEveryName = `every${typeName}`
+    const queryEveryString = `${queryEveryName}: [${objectType.name}!]`
+    const queryEveryResolverFunc: GraphQLFieldResolver<
+      any,
+      ApolloContext,
+      any,
+      Promise<EntryData[]>
+    > = (source, args, context, info) =>
+      queryEveryResolver(source, args, { ...context, type: objectType }, info)
+
+    const queryByIdName = typeName
+    const queryByIdString = `${queryByIdName}(id: ID!): ${objectType.name}`
+    const queryByIdResolverFunc: QueryMutationResolver<EntryData> = (
+      source,
+      args,
+      context,
+      info,
+    ) => queryByIdResolver(source, args, { ...context, type: objectType }, info)
+
+    const inputTypeName = `${typeName}Input`
+    const createMutationName = `create${typeName}`
+    const createMutationString = `${createMutationName}(id: ID!, data: ${inputTypeName}!, commitMessage: String): ${typeName}`
+    const createMutationResolver: QueryMutationResolver<EntryData> = (
+      source,
+      args,
+      context,
+      info,
+    ) =>
+      mutationCreateResolver(
+        source,
+        args,
+        { ...context, type: objectType },
+        info,
+      )
+
+    const updateMutationName = `update${typeName}`
+    const updateMutationString = `${updateMutationName}(id: ID!, data: ${inputTypeName}!, commitMessage: String): ${typeName}`
+    const updateMutationResolver: QueryMutationResolver<EntryData> = (
+      source,
+      args,
+      context,
+      info,
+    ) =>
+      mutationUpdateResolver(
+        source,
+        args,
+        { ...context, type: objectType },
+        info,
+      )
+
+    const deleteMutationName = `delete${typeName}`
+    const deleteMutationString = `${deleteMutationName}(id: ID!, commitMessage: String): ID`
+    const deleteMutationResolver: QueryMutationResolver<EntryData> = (
+      source,
+      args,
+      context,
+      info,
+    ) =>
+      mutationDeleteResolver(
+        source,
+        args,
+        { ...context, type: objectType },
+        info,
+      )
+
+    return {
+      queryEvery: {
+        name: queryEveryName,
+        schemaString: queryEveryString,
+        resolver: queryEveryResolverFunc,
+      },
+      queryById: {
+        name: queryByIdName,
+        schemaString: queryByIdString,
+        resolver: queryByIdResolverFunc,
+      },
+      createMutation: {
+        name: createMutationName,
+        schemaString: createMutationString,
+        resolver: createMutationResolver,
+      },
+      updateMutation: {
+        name: updateMutationName,
+        schemaString: updateMutationString,
+        resolver: updateMutationResolver,
+      },
+      deleteMutation: {
+        name: deleteMutationName,
+        schemaString: deleteMutationString,
+        resolver: deleteMutationResolver,
+      },
+    }
+  })
+}
+
+export function generateTypeNameQuery(): GeneratedQuery<Promise<string>> {
+  const entryTypeQueryName = '_typeName'
+  const entryTypeQueryString = `${entryTypeQueryName}(id: ID!): String!`
+
+  return {
+    name: entryTypeQueryName,
+    schemaString: entryTypeQueryString,
+    resolver: queryTypeByIdResolver,
+  }
+}
+
+export interface GeneratedSchema {
+  queryEvery: GeneratedQuery<Promise<EntryData[]>>
+  queryById: GeneratedQuery<Promise<EntryData>>
+  createMutation: GeneratedQuery<Promise<EntryData>>
+  updateMutation: GeneratedQuery<Promise<EntryData>>
+  deleteMutation: GeneratedQuery<Promise<EntryData>>
+}
+
+export interface GeneratedQuery<T> {
+  name: string
+  schemaString: string
+  resolver: GraphQLFieldResolver<any, ApolloContext, any, T>
+}

package/src/graphql/resolvers/field-resolvers/entry-reference-resolver.ts

@@ -0,0 +1,29 @@
+import { FieldResolver, FieldResolverContext } from './types'
+import { GraphQLResolveInfo, isNamedType } from 'graphql'
+import { findById } from '../../../persistence/persistence'
+import { createError, ErrorCode } from '../../errors'
+
+export const resolveEntryReference: FieldResolver<any> = async (
+  fieldValue: any,
+  args: any,
+  context: FieldResolverContext,
+  info: GraphQLResolveInfo,
+) => {
+  if (!isNamedType(context.currentType)) {
+    throw createError(
+      `Expected context.currentType type to be a named type.`,
+      ErrorCode.INTERNAL_ERROR,
+      {
+        fieldValue: fieldValue,
+      },
+    )
+  }
+
+  const entry = await findById(
+    context.gitAdapter,
+    context.getCurrentRef(),
+    fieldValue.id,
+  )
+
+  return { ...entry.data, id: entry.id }
+}

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

@@ -0,0 +1,125 @@
+import { FieldResolver, FieldResolverContext, ResolvedEntryData } from './types'
+import { EntryData } from '@commitspark/git-adapter'
+import {
+  GraphQLNonNull,
+  GraphQLResolveInfo,
+  GraphQLUnionType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isUnionType,
+} from 'graphql'
+import {
+  buildsOnTypeWithEntryDirective,
+  hasEntryDirective,
+} from '../../schema-utils/entry-type-util'
+import { resolveEntryReference } from './entry-reference-resolver'
+import { resolveUnionValue } from './union-value-resolver'
+import { createError, ErrorCode } from '../../errors'
+
+export const resolveFieldDefaultValue: FieldResolver<any> = async (
+  fieldValue: any,
+  args: any,
+  context: FieldResolverContext,
+  info: GraphQLResolveInfo,
+): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> => {
+  if (isNonNullType(context.currentType)) {
+    return resolveFieldDefaultValue(
+      fieldValue,
+      args,
+      {
+        gitAdapter: context.gitAdapter,
+        getCurrentRef: context.getCurrentRef,
+        currentType: context.currentType.ofType,
+        hasNonNullParent: true,
+      },
+      info,
+    )
+  } else if (isListType(context.currentType)) {
+    if (fieldValue === undefined || fieldValue === null) {
+      if (context.hasNonNullParent) {
+        return new Promise((resolve) => resolve([]))
+      } else {
+        return new Promise((resolve) => resolve(null))
+      }
+    }
+
+    if (!Array.isArray(fieldValue)) {
+      throw createError(
+        `Expected array while resolving value for field "${info.fieldName}".`,
+        ErrorCode.SCHEMA_DATA_MISMATCH,
+        {
+          fieldName: info.fieldName,
+          fieldValue: fieldValue,
+        },
+      )
+    }
+
+    const resultPromises = []
+    for (const item of fieldValue) {
+      const resultPromise = resolveFieldDefaultValue(
+        item,
+        args,
+        {
+          gitAdapter: context.gitAdapter,
+          getCurrentRef: context.getCurrentRef,
+          currentType: context.currentType.ofType,
+          hasNonNullParent: context.hasNonNullParent,
+        },
+        info,
+      )
+      resultPromises.push(resultPromise)
+    }
+    return Promise.all(resultPromises)
+  } else if (isUnionType(context.currentType)) {
+    if (fieldValue === undefined || fieldValue === null) {
+      if (context.hasNonNullParent) {
+        throw createError(
+          `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
+          }". Set a value in your repository data or remove the NonNull declaration in your schema.`,
+          ErrorCode.BAD_REPOSITORY_DATA,
+          {
+            typeName: info.parentType.name,
+            fieldName: info.fieldName,
+          },
+        )
+      } else {
+        return new Promise((resolve) => resolve(null))
+      }
+    }
+
+    if (buildsOnTypeWithEntryDirective(context.currentType)) {
+      return resolveEntryReference(fieldValue, args, context, info)
+    }
+
+    return resolveUnionValue(fieldValue, args, context, info)
+  } else if (isObjectType(context.currentType)) {
+    if (fieldValue === undefined || fieldValue === null) {
+      if (context.hasNonNullParent) {
+        throw createError(
+          `Cannot generate a default value for NonNull field "${info.fieldName}" of type ` +
+            `"${info.parentType.name}". Set a value in your repository data or remove the NonNull ` +
+            `declaration in your schema.`,
+          ErrorCode.BAD_REPOSITORY_DATA,
+          {
+            typeName: info.parentType.name,
+            fieldName: info.fieldName,
+          },
+        )
+      } else {
+        return new Promise((resolve) => resolve(null))
+      }
+    }
+
+    if (hasEntryDirective(context.currentType)) {
+      return resolveEntryReference(fieldValue, args, context, info)
+    }
+
+    return fieldValue
+  }
+
+  return fieldValue
+}

package/src/graphql/{field-resolver/fieldResolver.ts → resolvers/field-resolvers/types.ts}

@@ -1,18 +1,19 @@
 import { GraphQLFieldResolver } from 'graphql/type/definition'
 import { EntryData, GitAdapter } from '@commitspark/git-adapter'
+import { GraphQLOutputType } from 'graphql'
 
 export interface FieldResolverContext {
   gitAdapter: GitAdapter
   getCurrentRef(): string
+  currentType: GraphQLOutputType
+  hasNonNullParent?: boolean
 }
 
-export interface FieldResolver<
+export type FieldResolver<
   TSource,
   TContext = FieldResolverContext,
   TArgs = any,
   TResult = Promise<ResolvedEntryData<EntryData | EntryData[] | null>>,
-> {
-  resolve: GraphQLFieldResolver<TSource, TContext, TArgs, TResult>
-}
+> = GraphQLFieldResolver<TSource, TContext, TArgs, TResult>
 
 export type ResolvedEntryData<T> = T | Array<ResolvedEntryData<T>>

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

@@ -0,0 +1,24 @@
+import { EntryData } from '@commitspark/git-adapter'
+import { FieldResolver, ResolvedEntryData } from './types'
+import {
+  getUnionTypeNameFromFieldValue,
+  getUnionValue,
+} from '../../schema-utils/union-type-util'
+
+export const resolveUnionValue: FieldResolver<any> = async (
+  fieldValue: any,
+): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> => {
+  const typeName = getUnionTypeNameFromFieldValue(fieldValue)
+  const unionValue = 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/resolvers/object-type-field-default-value-resolver-generator.ts

@@ -0,0 +1,91 @@
+import {
+  GraphQLField,
+  GraphQLFieldResolver,
+  GraphQLObjectType,
+  GraphQLOutputType,
+  GraphQLSchema,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isUnionType,
+} from 'graphql'
+import { EntryData } from '@commitspark/git-adapter'
+import { ResolvedEntryData } from './field-resolvers/types'
+import { resolveFieldDefaultValue } from './field-resolvers/field-default-value-resolver'
+import { ApolloContext } from '../../client'
+
+function requiresCustomDefaultValueResolver(type: GraphQLOutputType): boolean {
+  if (isNonNullType(type)) {
+    return requiresCustomDefaultValueResolver(type.ofType)
+  } else if (isListType(type)) {
+    return true
+  } else if (isUnionType(type)) {
+    return true
+  } else if (isObjectType(type)) {
+    return true
+  }
+  return false
+}
+
+function getFieldsForCustomDefaultValueResolver(
+  objectType: GraphQLObjectType,
+): GraphQLField<any, any>[] {
+  const fields = []
+  for (const fieldsKey in objectType.getFields()) {
+    const field: GraphQLField<any, any> = objectType.getFields()[fieldsKey]
+    if (requiresCustomDefaultValueResolver(field.type)) {
+      fields.push(field)
+    }
+  }
+  return fields
+}
+
+type FieldResolversRecord = Record<
+  string,
+  GraphQLFieldResolver<
+    any,
+    ApolloContext,
+    any,
+    Promise<ResolvedEntryData<EntryData | EntryData[] | null>>
+  >
+>
+
+export function createObjectTypeFieldResolvers(
+  schema: GraphQLSchema,
+): Record<string, FieldResolversRecord> {
+  const fieldResolversByType: Record<string, FieldResolversRecord> = {}
+  for (const typeName of Object.keys(schema.getTypeMap())) {
+    const type = schema.getType(typeName)
+    if (!isObjectType(type) || type.name.startsWith('__')) {
+      continue
+    }
+    const fieldsForCustomDefaultValueResolver =
+      getFieldsForCustomDefaultValueResolver(type)
+
+    const fieldResolversByFieldName: FieldResolversRecord = {}
+    for (const field of fieldsForCustomDefaultValueResolver) {
+      fieldResolversByFieldName[field.name] = (
+        obj,
+        args,
+        context,
+        info,
+      ): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> =>
+        resolveFieldDefaultValue(
+          field.name in obj ? obj[field.name] : undefined,
+          args,
+          {
+            currentType: field.type,
+            gitAdapter: context.gitAdapter,
+            getCurrentRef: context.getCurrentRef,
+          },
+          info,
+        )
+    }
+
+    if (Object.keys(fieldResolversByFieldName).length > 0) {
+      fieldResolversByType[typeName] = fieldResolversByFieldName
+    }
+  }
+
+  return fieldResolversByType
+}

package/src/graphql/resolvers/query-mutation-resolvers/mutation-create-resolver.ts

@@ -0,0 +1,116 @@
+import { findById, findByTypeId } from '../../../persistence/persistence'
+import { GraphQLFieldResolver, isObjectType } from 'graphql'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
+import {
+  ENTRY_ID_INVALID_CHARACTERS,
+  EntryData,
+  EntryDraft,
+} from '@commitspark/git-adapter'
+import { QueryMutationResolverContext } from '../types'
+import { createError, ErrorCode } from '../../errors'
+
+export const mutationCreateResolver: GraphQLFieldResolver<
+  any,
+  QueryMutationResolverContext,
+  any,
+  Promise<EntryData>
+> = async (source, args, context, info) => {
+  if (!isObjectType(context.type)) {
+    throw createError(
+      `Entry of type "${context.type.name}" cannot be created as is not an ObjectType.`,
+      ErrorCode.INTERNAL_ERROR,
+      {},
+    )
+  }
+
+  const idValidationResult = args.id.match(ENTRY_ID_INVALID_CHARACTERS)
+  if (idValidationResult) {
+    throw createError(
+      `Field "id" contains invalid characters "${idValidationResult.join(
+        ', ',
+      )}".`,
+      ErrorCode.BAD_USER_INPUT,
+      {
+        argumentName: 'id',
+        argumentValue: args.id,
+      },
+    )
+  }
+
+  let existingEntry
+  try {
+    existingEntry = await findById(
+      context.gitAdapter,
+      context.getCurrentRef(),
+      args.id,
+    )
+  } catch (_) {
+    /* empty */
+  }
+  if (existingEntry) {
+    throw createError(
+      `An entry with id "${args.id}" already exists.`,
+      ErrorCode.BAD_USER_INPUT,
+      {
+        argumentName: 'id',
+        argumentValue: args.id,
+      },
+    )
+  }
+
+  const referencedEntryIds = await getReferencedEntryIds(
+    context.type,
+    context,
+    null,
+    info.returnType,
+    args.data,
+  )
+
+  const referencedEntryUpdates: EntryDraft[] = []
+  for (const referencedEntryId of referencedEntryIds) {
+    const referencedEntry = await 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: context.type.name,
+      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 findByTypeId(
+    context.gitAdapter,
+    context.getCurrentRef(),
+    context.type.name,
+    args.id,
+  )
+  return { ...newEntry.data, id: newEntry.id }
+}