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

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

@@ -0,0 +1,85 @@
+import { findById, findByTypeId } from '../../../persistence/persistence'
+import { Entry, EntryData, EntryDraft } from '@commitspark/git-adapter'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
+import { GraphQLFieldResolver, isObjectType } from 'graphql'
+import { QueryMutationResolverContext } from '../types'
+import { createError, ErrorCode } from '../../errors'
+
+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 createError(
+      `Entry with ID "${args.id}" is still referenced by entries [${otherIds}].`,
+      ErrorCode.IN_USE,
+      {
+        argumentName: 'id',
+        argumentValue: args.id,
+      },
+    )
+  }
+
+  const entryType = info.schema.getType(context.type.name)
+  if (!isObjectType(entryType)) {
+    throw createError(
+      `Type "${context.type.name}" is not an ObjectType.`,
+      ErrorCode.INTERNAL_ERROR,
+      {},
+    )
+  }
+
+  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
+}

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

@@ -0,0 +1,119 @@
+import { findById, findByTypeId } from '../../../persistence/persistence'
+import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util'
+import { GraphQLFieldResolver, isObjectType } from 'graphql'
+import { EntryData, EntryDraft } from '@commitspark/git-adapter'
+import { QueryMutationResolverContext } from '../types'
+import { createError, ErrorCode } from '../../errors'
+
+function mergeData(
+  existingEntryData: EntryData,
+  updateData: EntryData,
+): EntryData {
+  return {
+    ...existingEntryData,
+    ...updateData,
+  }
+}
+
+export const mutationUpdateResolver: GraphQLFieldResolver<
+  any,
+  QueryMutationResolverContext,
+  any,
+  Promise<EntryData>
+> = async (source, args, context, info) => {
+  if (!isObjectType(context.type)) {
+    throw createError(
+      `Type "${context.type.name}" cannot be mutated as is not an ObjectType.`,
+      ErrorCode.INTERNAL_ERROR,
+      {},
+    )
+  }
+
+  const existingEntry = await findByTypeId(
+    context.gitAdapter,
+    context.getCurrentRef(),
+    context.type.name,
+    args.id,
+  )
+
+  const existingReferencedEntryIds = await getReferencedEntryIds(
+    context.type,
+    context,
+    null,
+    info.returnType,
+    existingEntry.data,
+  )
+
+  const mergedData = mergeData(existingEntry.data ?? null, args.data)
+  const updatedReferencedEntryIds = await getReferencedEntryIds(
+    context.type,
+    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 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 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 findByTypeId(
+    context.gitAdapter,
+    context.getCurrentRef(),
+    context.type.name,
+    args.id,
+  )
+  return { ...updatedEntry.data, id: updatedEntry.id }
+}

package/src/graphql/resolvers/query-mutation-resolvers/query-by-id-resolver.ts

@@ -0,0 +1,20 @@
+import { EntryData } from '@commitspark/git-adapter'
+import { findByTypeId } from '../../../persistence/persistence'
+import { GraphQLFieldResolver } from 'graphql'
+import { QueryMutationResolverContext } from '../types'
+
+export const queryByIdResolver: GraphQLFieldResolver<
+  any,
+  QueryMutationResolverContext,
+  any,
+  Promise<EntryData>
+> = async (obj, args, context, info) => {
+  const entry = await findByTypeId(
+    context.gitAdapter,
+    context.getCurrentRef(),
+    context.type.name,
+    args.id,
+  )
+
+  return { ...entry.data, id: entry.id }
+}

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

@@ -0,0 +1,21 @@
+import { EntryData } from '@commitspark/git-adapter'
+import { findByType } from '../../../persistence/persistence'
+import { GraphQLFieldResolver } from 'graphql'
+import { QueryMutationResolverContext } from '../types'
+
+export const queryEveryResolver: GraphQLFieldResolver<
+  any,
+  QueryMutationResolverContext,
+  any,
+  Promise<EntryData[]>
+> = async (obj, args, context, info) => {
+  const entries = await findByType(
+    context.gitAdapter,
+    context.getCurrentRef(),
+    context.type.name,
+  )
+
+  return entries.map((entry) => {
+    return { ...entry.data, id: entry.id }
+  })
+}

package/src/graphql/resolvers/query-mutation-resolvers/query-type-by-id-resolver.ts

@@ -0,0 +1,12 @@
+import { getTypeById } from '../../../persistence/persistence'
+import { GraphQLFieldResolver } from 'graphql'
+import { ApolloContext } from '../../../client'
+
+export const queryTypeByIdResolver: GraphQLFieldResolver<
+  any,
+  ApolloContext,
+  any,
+  Promise<string>
+> = async (source, args, context, info) => {
+  return getTypeById(context.gitAdapter, context.getCurrentRef(), args.id)
+}

package/src/graphql/resolvers/query-mutation-resolvers/union-type-resolver.ts

@@ -0,0 +1,19 @@
+import { ApolloContext } from '../../../client'
+import { getTypeById } from '../../../persistence/persistence'
+import { GraphQLTypeResolver } from 'graphql'
+import { buildsOnTypeWithEntryDirective } from '../../schema-utils/entry-type-util'
+
+export const unionTypeResolver: GraphQLTypeResolver<
+  any,
+  ApolloContext
+> = async (obj, context, info, abstractType) => {
+  if (buildsOnTypeWithEntryDirective(abstractType)) {
+    return 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/resolvers/types.ts

@@ -0,0 +1,14 @@
+import { ApolloContext } from '../../client'
+import { GraphQLNamedType } from 'graphql/type'
+import { GraphQLFieldResolver } from 'graphql'
+
+export interface QueryMutationResolverContext extends ApolloContext {
+  type: GraphQLNamedType
+}
+
+export type QueryMutationResolver<ResultType> = GraphQLFieldResolver<
+  any,
+  ApolloContext,
+  any,
+  Promise<ResultType>
+>

package/src/graphql/schema-analyzer.ts

@@ -0,0 +1,55 @@
+import {
+  GraphQLInterfaceType,
+  GraphQLObjectType,
+  GraphQLSchema,
+  GraphQLUnionType,
+  isInterfaceType,
+  isObjectType,
+  isUnionType,
+} from 'graphql'
+import { getDirective } from '@graphql-tools/utils'
+
+export function analyzeSchema(schema: GraphQLSchema): SchemaAnalyzerResult {
+  const result: SchemaAnalyzerResult = {
+    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 SchemaAnalyzerResult {
+  entryDirectiveTypes: GraphQLObjectType[]
+  objectTypes: GraphQLObjectType[]
+  interfaceTypes: GraphQLInterfaceType[]
+  unionTypes: GraphQLUnionType[]
+}

package/src/graphql/schema-generator.ts

@@ -0,0 +1,166 @@
+import {
+  generateQueriesAndMutations,
+  generateTypeNameQuery,
+} from './queries-mutations-generator'
+import {
+  IExecutableSchemaDefinition,
+  makeExecutableSchema,
+} from '@graphql-tools/schema'
+import { analyzeSchema } from './schema-analyzer'
+import {
+  generateIdInputTypeStrings,
+  generateObjectInputTypeStrings,
+  generateUnionInputTypeStrings,
+} from './input-type-generator'
+import { generateSchemaRootTypeStrings } from './schema-root-type-generator'
+import { printSchemaWithDirectives } from '@graphql-tools/utils'
+import { unionTypeResolver } from './resolvers/query-mutation-resolvers/union-type-resolver'
+import { ApolloContext } from '../client'
+import { GraphQLFieldResolver, GraphQLTypeResolver } from 'graphql'
+import { getValidationResult } from './schema-validator'
+import { EntryData } from '@commitspark/git-adapter'
+import { createObjectTypeFieldResolvers } from './resolvers/object-type-field-default-value-resolver-generator'
+import { createError, ErrorCode } from './errors'
+
+export async function generateSchema(
+  context: ApolloContext,
+): Promise<IExecutableSchemaDefinition> {
+  const originalSchemaString = await context.gitAdapter.getSchema(
+    context.getCurrentRef(),
+  )
+  const schema = makeExecutableSchema({
+    typeDefs: originalSchemaString,
+  })
+
+  const validationResult = getValidationResult(schema)
+  if (validationResult.length > 0) {
+    throw createError(`Invalid schema.`, ErrorCode.BAD_SCHEMA, {
+      schema: printSchemaWithDirectives(schema),
+      argumentValue: validationResult.join('\n'),
+    })
+  }
+  const schemaAnalyzerResult = analyzeSchema(schema)
+
+  const filteredOriginalSchemaString = printSchemaWithDirectives(schema) + '\n'
+
+  const generatedIdInputTypeStrings =
+    generateIdInputTypeStrings(schemaAnalyzerResult)
+
+  const generatedQueriesMutations = generateQueriesAndMutations(
+    schemaAnalyzerResult.entryDirectiveTypes,
+  )
+  const generatedTypeNameQuery = generateTypeNameQuery()
+
+  const generatedEntryReferenceResolvers: Record<
+    string,
+    Record<
+      string,
+      GraphQLFieldResolver<
+        Record<string, any>,
+        ApolloContext,
+        any,
+        Promise<EntryData | EntryData[] | null>
+      >
+    >
+  > = {}
+
+  const generatedObjectInputTypeStrings = generateObjectInputTypeStrings(
+    schemaAnalyzerResult.objectTypes,
+  )
+
+  const generatedUnionInputTypeStrings = generateUnionInputTypeStrings(
+    schemaAnalyzerResult.unionTypes,
+  )
+
+  const generatedSchemaRootTypeStrings = generateSchemaRootTypeStrings(
+    generatedQueriesMutations,
+    generatedTypeNameQuery,
+  )
+
+  const generatedSchemaString = `schema {
+  query: Query
+  mutation: Mutation
+}
+
+${generatedSchemaRootTypeStrings}`
+
+  const generatedUnionTypeResolvers: Record<string, UnionTypeResolver> = {}
+  for (const unionType of schemaAnalyzerResult.unionTypes) {
+    generatedUnionTypeResolvers[unionType.name] = {
+      __resolveType: unionTypeResolver,
+    }
+  }
+  const generatedObjectTypeFieldResolvers =
+    createObjectTypeFieldResolvers(schema)
+
+  const generatedQueryResolvers: Record<
+    string,
+    GraphQLFieldResolver<any, ApolloContext>
+  > = {}
+  const generatedMutationResolvers: Record<
+    string,
+    GraphQLFieldResolver<any, ApolloContext>
+  > = {}
+
+  for (const element of generatedQueriesMutations) {
+    generatedQueryResolvers[element.queryEvery.name] =
+      element.queryEvery.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(generatedObjectTypeFieldResolvers)) {
+    allGeneratedResolvers[typeName] = {
+      ...(allGeneratedResolvers[typeName] ?? {}),
+      ...generatedObjectTypeFieldResolvers[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.ts

@@ -0,0 +1,35 @@
+import { GeneratedQuery, GeneratedSchema } from './queries-mutations-generator'
+
+export function generateSchemaRootTypeStrings(
+  generatedSchemas: GeneratedSchema[],
+  typeQuery: GeneratedQuery<Promise<string>>,
+): string {
+  return (
+    `type Query {\n` +
+    generatedSchemas
+      .map((generated) => '  ' + generated.queryEvery.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'
+  )
+}