@commitspark/graphql-api 0.9.4 → 0.10.0

package/src/container.ts

@@ -1,6 +1,5 @@
 import { ApiService } from './app/api.service'
 import { ApolloConfigFactoryService } from './graphql/apollo-config-factory.service'
-import { EntryReferenceResolverGenerator } from './graphql/resolver-generators/entry-reference-resolver.generator'
 import { InputTypeGeneratorService } from './graphql/input-type-generator.service'
 import { QueriesMutationsGeneratorService } from './graphql/queries-mutations-generator.service'
 import { SchemaAnalyzerService } from './graphql/schema-analyzer.service'
@@ -10,36 +9,46 @@ import { PersistenceService } from './persistence/persistence.service'
 import { SchemaGeneratorService } from './graphql/schema-generator.service'
 import { MutationCreateResolverGenerator } from './graphql/resolver-generators/mutation-create-resolver-generator'
 import { MutationDeleteResolverGenerator } from './graphql/resolver-generators/mutation-delete-resolver-generator'
-import { MutationUpdateResolverGenerator } from './graphql/resolver-generators/mutation-update.resolver-generator'
+import { MutationUpdateResolverGenerator } from './graphql/resolver-generators/mutation-update-resolver-generator'
 import { QueryAllResolverGenerator } from './graphql/resolver-generators/query-all-resolver-generator'
 import { QueryByIdResolverGenerator } from './graphql/resolver-generators/query-by-id-resolver-generator'
 import { QueryCountAllResolverGenerator } from './graphql/resolver-generators/query-count-all-resolver-generator'
 import { QueryTypeByIdResolverGenerator } from './graphql/resolver-generators/query-type-by-id-resolver-generator'
 import { SchemaValidator } from './graphql/schema-validator'
-import { UnionValueResolverGenerator } from './graphql/resolver-generators/union-value-resolver-generator'
+import { UnionValueResolver } from './graphql/field-resolver/union-value-resolver'
 import { EntryReferenceUtil } from './graphql/schema-utils/entry-reference-util'
+import { ObjectTypeFieldDefaultValueResolverGenerator } from './graphql/resolver-generators/object-type-field-default-value-resolver-generator'
+import { FieldDefaultValueResolver } from './graphql/field-resolver/field-default-value-resolver'
+import { EntryReferenceResolver } from './graphql/field-resolver/entry-reference-resolver'
+import { UnionTypeUtil } from './graphql/schema-utils/union-type-util'
+import { EntryTypeUtil } from './graphql/schema-utils/entry-type-util'
 
 // we used to have a DI container here, however that doesn't work well with webpack & co, so doing it by hand for now
 
-const entryReferenceUtil = new EntryReferenceUtil()
 const schemaValidator = new SchemaValidator()
 const persistenceService = new PersistenceService()
+const entryTypeUtil = new EntryTypeUtil()
+const unionTypeUtil = new UnionTypeUtil()
+const entryReferenceUtil = new EntryReferenceUtil(
+  persistenceService,
+  entryTypeUtil,
+  unionTypeUtil,
+)
 const schemaRootTypeGeneratorService = new SchemaRootTypeGeneratorService()
 
-const inputTypeGeneratorService = new InputTypeGeneratorService(
-  entryReferenceUtil,
-)
-const schemaAnalyzerService = new SchemaAnalyzerService(entryReferenceUtil)
-const entryReferenceResolverGeneratorService =
-  new EntryReferenceResolverGenerator(persistenceService)
+const inputTypeGeneratorService = new InputTypeGeneratorService(entryTypeUtil)
+const schemaAnalyzerService = new SchemaAnalyzerService()
 const mutationCreateResolverGenerator = new MutationCreateResolverGenerator(
   persistenceService,
+  entryReferenceUtil,
 )
 const mutationDeleteResolverGenerator = new MutationDeleteResolverGenerator(
   persistenceService,
+  entryReferenceUtil,
 )
 const mutationUpdateResolverGenerator = new MutationUpdateResolverGenerator(
   persistenceService,
+  entryReferenceUtil,
 )
 const queryAllResolverGenerator = new QueryAllResolverGenerator(
   persistenceService,
@@ -55,11 +64,17 @@ const queryTypeByIdResolverGenerator = new QueryTypeByIdResolverGenerator(
 )
 const unionTypeResolverGenerator = new UnionTypeResolverGenerator(
   persistenceService,
-  entryReferenceUtil,
+  entryTypeUtil,
 )
-const unionValueResolverGenerator = new UnionValueResolverGenerator(
-  entryReferenceUtil,
+const unionValueResolver = new UnionValueResolver(unionTypeUtil)
+const entryReferenceResolver = new EntryReferenceResolver(persistenceService)
+const fieldDefaultValueResolver = new FieldDefaultValueResolver(
+  entryTypeUtil,
+  unionValueResolver,
+  entryReferenceResolver,
 )
+const objectTypeFieldDefaultValueResolverGenerator =
+  new ObjectTypeFieldDefaultValueResolverGenerator(fieldDefaultValueResolver)
 
 const queriesMutationsGeneratorService = new QueriesMutationsGeneratorService(
   queryAllResolverGenerator,
@@ -76,9 +91,8 @@ const schemaGeneratorService = new SchemaGeneratorService(
   schemaAnalyzerService,
   inputTypeGeneratorService,
   schemaRootTypeGeneratorService,
-  entryReferenceResolverGeneratorService,
   unionTypeResolverGenerator,
-  unionValueResolverGenerator,
+  objectTypeFieldDefaultValueResolverGenerator,
   schemaValidator,
 )
 

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

@@ -0,0 +1,49 @@
+import {
+  FieldResolver,
+  ResolvedEntryData,
+  FieldResolverContext,
+} from './fieldResolver'
+import {
+  GraphQLFieldResolver,
+  GraphQLOutputType,
+  GraphQLResolveInfo,
+} from 'graphql/type/definition'
+import {
+  Entry,
+  PersistenceService,
+} from '../../persistence/persistence.service'
+
+export class EntryReferenceResolver implements FieldResolver<any> {
+  resolve: GraphQLFieldResolver<
+    any,
+    FieldResolverContext,
+    any,
+    Promise<ResolvedEntryData<Entry | Entry[] | null>>
+  >
+
+  constructor(private readonly persistence: PersistenceService) {
+    this.resolve = (
+      fieldValue,
+      args: any,
+      context: FieldResolverContext,
+      info,
+    ): Promise<ResolvedEntryData<Entry | Entry[] | null>> =>
+      this.resolveFieldValue(fieldValue, args, context, info, info.returnType)
+  }
+
+  private async resolveFieldValue(
+    fieldValue: any,
+    args: any,
+    context: FieldResolverContext,
+    info: GraphQLResolveInfo,
+    currentType: GraphQLOutputType,
+  ): Promise<ResolvedEntryData<Entry | Entry[] | null>> {
+    const entry = await this.persistence.findById(
+      context.gitAdapter,
+      context.getCurrentRef(),
+      fieldValue.id,
+    )
+
+    return { ...entry.data, id: entry.id }
+  }
+}

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

@@ -0,0 +1,154 @@
+import {
+  FieldResolver,
+  ResolvedEntryData,
+  FieldResolverContext,
+} from './fieldResolver'
+import { Entry } from '../../persistence/persistence.service'
+import {
+  GraphQLFieldResolver,
+  GraphQLOutputType,
+  GraphQLResolveInfo,
+} from 'graphql/type/definition'
+import {
+  GraphQLNonNull,
+  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<Entry | Entry[] | null>>
+  >
+
+  constructor(
+    private readonly entryTypeUtil: EntryTypeUtil,
+    private readonly unionValueResolver: UnionValueResolver,
+    private readonly entryReferenceResolver: EntryReferenceResolver,
+  ) {
+    this.resolve = (
+      fieldValue,
+      args,
+      context,
+      info,
+    ): Promise<ResolvedEntryData<Entry | Entry[] | 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<Entry | Entry[] | 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/fieldResolver.ts

@@ -0,0 +1,19 @@
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { Entry } from '../../persistence/persistence.service'
+import { GitAdapter } from '@commitspark/git-adapter'
+
+export interface FieldResolverContext {
+  gitAdapter: GitAdapter
+  getCurrentRef(): string
+}
+
+export interface FieldResolver<
+  TSource,
+  TContext = FieldResolverContext,
+  TArgs = any,
+  TResult = Promise<ResolvedEntryData<Entry | Entry[] | null>>,
+> {
+  resolve: GraphQLFieldResolver<TSource, TContext, TArgs, TResult>
+}
+
+export type ResolvedEntryData<T> = T | Array<ResolvedEntryData<T>>

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

@@ -0,0 +1,46 @@
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { Entry } from '../../persistence/persistence.service'
+import {
+  FieldResolver,
+  ResolvedEntryData,
+  FieldResolverContext,
+} from './fieldResolver'
+import { UnionTypeUtil } from '../schema-utils/union-type-util'
+
+export class UnionValueResolver implements FieldResolver<any> {
+  resolve: GraphQLFieldResolver<
+    any,
+    FieldResolverContext,
+    any,
+    Promise<ResolvedEntryData<Entry | Entry[] | null>>
+  >
+
+  constructor(private readonly unionTypeUtil: UnionTypeUtil) {
+    this.resolve = (
+      fieldValue,
+      args,
+      context,
+      info,
+    ): Promise<ResolvedEntryData<Entry | Entry[] | null>> =>
+      this.resolveFieldValue(fieldValue)
+  }
+
+  private resolveFieldValue(
+    fieldValue: any,
+  ): Promise<ResolvedEntryData<Entry | Entry[] | 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: Entry = {
+      ...unionValue,
+      __typename: typeName,
+    }
+
+    return new Promise((resolve) => resolve(res))
+  }
+}

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

@@ -13,10 +13,11 @@ import {
   isUnionType,
 } from 'graphql'
 import { ISchemaAnalyzerResult } from './schema-analyzer.service'
-import { EntryReferenceUtil } from './schema-utils/entry-reference-util'
+import { EntryTypeUtil } from './schema-utils/entry-type-util'
+import { isScalarType } from 'graphql/type/definition'
 
 export class InputTypeGeneratorService {
-  constructor(private readonly entryReferenceUtil: EntryReferenceUtil) {}
+  constructor(private readonly entryTypeUtil: EntryTypeUtil) {}
 
   public generateFieldInputTypeString(type: GraphQLNullableType): string {
     if (isListType(type)) {
@@ -24,7 +25,7 @@ export class InputTypeGeneratorService {
     } else if (isNonNullType(type)) {
       return `${this.generateFieldInputTypeString(type.ofType)}!`
     } else if (isObjectType(type)) {
-      if (this.entryReferenceUtil.hasEntryDirective(type)) {
+      if (this.entryTypeUtil.hasEntryDirective(type)) {
         return `${type.name}IdInput`
       } else {
         return `${type.name}Input`
@@ -33,7 +34,7 @@ export class InputTypeGeneratorService {
       // TODO
       return ''
     } else if (isUnionType(type)) {
-      if (this.entryReferenceUtil.buildsOnTypeWithEntryDirective(type)) {
+      if (this.entryTypeUtil.buildsOnTypeWithEntryDirective(type)) {
         return `${type.name}IdInput`
       } else {
         return `${type.name}Input`
@@ -73,16 +74,29 @@ export class InputTypeGeneratorService {
       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 (field.name === 'id') {
-          // TODO check by type name `ID` (incl. non-null) instead of field name
+        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)
-        inputType += `  ${field.name}: ${inputTypeString}\n`
+        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
     })
   }
@@ -91,7 +105,7 @@ export class InputTypeGeneratorService {
     unionTypes: GraphQLUnionType[],
   ): string[] {
     const typeStrings = unionTypes.map((unionType): string => {
-      if (this.entryReferenceUtil.buildsOnTypeWithEntryDirective(unionType)) {
+      if (this.entryTypeUtil.buildsOnTypeWithEntryDirective(unionType)) {
         return ''
       }
 

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

@@ -5,7 +5,7 @@ import { GraphQLObjectType } from 'graphql/type'
 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 { 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'

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

@@ -5,9 +5,18 @@ import {
   PersistenceService,
 } from '../../persistence/persistence.service'
 import { GraphQLError } from 'graphql/error/GraphQLError'
+import { EntryReferenceUtil } from '../schema-utils/entry-reference-util'
+import { isObjectType } from 'graphql'
+import {
+  ContentEntryDraft,
+  ENTRY_ID_INVALID_CHARACTERS,
+} from '@commitspark/git-adapter'
 
 export class MutationCreateResolverGenerator {
-  constructor(private readonly persistence: PersistenceService) {}
+  constructor(
+    private readonly persistence: PersistenceService,
+    private readonly entryReferenceUtil: EntryReferenceUtil,
+  ) {}
 
   public createResolver(
     typeName: string,
@@ -18,6 +27,23 @@ export class MutationCreateResolverGenerator {
       context: ApolloContext,
       info,
     ): Promise<Entry> => {
+      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(
@@ -35,23 +61,62 @@ export class MutationCreateResolverGenerator {
         })
       }
 
-      // TODO validate ID references within args.data to assert referenced IDs exist and point to correct entry type
-      const commitResult = await this.persistence.createType(
-        context.gitAdapter,
-        context.branch,
-        context.getCurrentRef(),
-        typeName,
-        args.id,
-        args.data,
-        args.message,
-      )
-      context.setCurrentRef(commitResult.ref)
-      return this.persistence.findByTypeId(
+      const referencedEntryIds =
+        await this.entryReferenceUtil.getReferencedEntryIds(
+          info.returnType,
+          context,
+          null,
+          info.returnType,
+          args.data,
+        )
+
+      const referencedEntryUpdates: ContentEntryDraft[] = []
+      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: ContentEntryDraft = {
+          ...referencedEntry,
+          metadata: {
+            ...referencedEntry.metadata,
+            referencedBy: newReferencedEntryIds,
+          },
+          deletion: false,
+        }
+        referencedEntryUpdates.push(newReferencedEntryDraft)
+      }
+
+      const newEntryDraft: ContentEntryDraft = {
+        id: args.id,
+        metadata: {
+          type: typeName,
+          referencedBy: [],
+        },
+        data: args.data,
+        deletion: false,
+      }
+
+      const commit = await context.gitAdapter.createCommit({
+        ref: context.branch,
+        parentSha: context.getCurrentRef(),
+        contentEntries: [newEntryDraft, ...referencedEntryUpdates],
+        message: args.message,
+      })
+      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

@@ -5,9 +5,15 @@ import {
 import { GraphQLFieldResolver } from 'graphql/type/definition'
 import { ApolloContext } from '../../app/api.service'
 import { GraphQLError } from 'graphql/error/GraphQLError'
+import { ContentEntry, ContentEntryDraft } from '@commitspark/git-adapter'
+import { EntryReferenceUtil } from '../schema-utils/entry-reference-util'
+import { isObjectType } from 'graphql'
 
 export class MutationDeleteResolverGenerator {
-  constructor(private readonly persistence: PersistenceService) {}
+  constructor(
+    private readonly persistence: PersistenceService,
+    private readonly entryReferenceUtil: EntryReferenceUtil,
+  ) {}
 
   public createResolver(
     typeName: string,
@@ -18,35 +24,77 @@ export class MutationDeleteResolverGenerator {
       context: ApolloContext,
       info,
     ): Promise<Entry> => {
-      try {
-        await this.persistence.findByTypeId(
-          context.gitAdapter,
-          context.getCurrentRef(),
-          typeName,
-          args.id,
-        )
-      } catch (_) {
+      const entry: ContentEntry = 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(
-          `No entry of type "${typeName}" with id "${args.id}" exists`,
+          `Entry with id "${args.id}" is referenced by other entries: [${otherIds}]`,
           {
             extensions: {
-              code: 'BAD_USER_INPUT',
+              code: 'IN_USE',
               argumentName: 'id',
             },
           },
         )
       }
 
-      // TODO validate ID to delete is not referenced anywhere
-      const deleteResult = await this.persistence.deleteByTypeId(
-        context.gitAdapter,
-        context.branch,
-        context.getCurrentRef(),
-        typeName,
-        args.id,
-        args.message,
-      )
-      context.setCurrentRef(deleteResult.ref)
+      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: ContentEntryDraft[] = []
+      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(),
+        contentEntries: [
+          {
+            ...entry,
+            deletion: true,
+          },
+          ...referencedEntryUpdates,
+        ],
+        message: args.message,
+      })
+      context.setCurrentRef(commit.ref)
+
       return {
         id: args.id,
       }