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

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

@@ -0,0 +1,136 @@
+import { EntryData } from '@commitspark/git-adapter'
+import { ApolloContext } from '../client'
+import { GraphQLFieldResolver, GraphQLObjectType } from 'graphql'
+import { queryAllResolver } from './resolvers/query-mutation-resolvers/query-all-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
+
+    const queryAllName = `all${typeName}s`
+    const queryAllString = `${queryAllName}: [${objectType.name}!]`
+    const queryAllResolverFunc: GraphQLFieldResolver<
+      any,
+      ApolloContext,
+      any,
+      Promise<EntryData[]>
+    > = (source, args, context, info) =>
+      queryAllResolver(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 {
+      queryAll: {
+        name: queryAllName,
+        schemaString: queryAllString,
+        resolver: queryAllResolverFunc,
+      },
+      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 {
+  queryAll: 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,22 @@
+import { FieldResolver, FieldResolverContext } from './types'
+import { GraphQLResolveInfo, isNamedType } from 'graphql'
+import { findById } from '../../../persistence/persistence'
+
+export const resolveEntryReference: FieldResolver<any> = async (
+  fieldValue: any,
+  args: any,
+  context: FieldResolverContext,
+  info: GraphQLResolveInfo,
+) => {
+  if (!isNamedType(context.currentType)) {
+    throw new Error(`Expected context.currentType type to be named type`)
+  }
+
+  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,107 @@
+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'
+
+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 new Error(
+        `Expected array while resolving value for field "${info.fieldName}".`,
+      )
+    }
+
+    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 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 (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 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 (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,108 @@
+import { findById, findByTypeId } from '../../../persistence/persistence'
+import { GraphQLError, 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'
+
+export const mutationCreateResolver: GraphQLFieldResolver<
+  any,
+  QueryMutationResolverContext,
+  any,
+  Promise<EntryData>
+> = async (source, args, context, info) => {
+  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 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 getReferencedEntryIds(
+    info.returnType,
+    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 }
+}

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

@@ -0,0 +1,81 @@
+import { findById, findByTypeId } from '../../../persistence/persistence'
+import { Entry, EntryData, EntryDraft } from '@commitspark/git-adapter'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
+import { GraphQLError, GraphQLFieldResolver, isObjectType } from 'graphql'
+import { QueryMutationResolverContext } from '../types'
+
+export const mutationDeleteResolver: GraphQLFieldResolver<
+  any,
+  QueryMutationResolverContext,
+  any,
+  Promise<EntryData>
+> = async (source, args, context, info) => {
+  const entry: Entry = await findByTypeId(
+    context.gitAdapter,
+    context.getCurrentRef(),
+    context.type.name,
+    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(context.type.name)
+  if (!isObjectType(entryType)) {
+    throw new Error('Expected to delete an ObjectType')
+  }
+
+  const referencedEntryIds = await getReferencedEntryIds(
+    entryType,
+    context,
+    null,
+    entryType,
+    entry.data,
+  )
+  const referencedEntryUpdates: EntryDraft[] = []
+  for (const referencedEntryId of referencedEntryIds) {
+    const noLongerReferencedEntry = await 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
+}