@commitspark/graphql-api 0.9.4 → 0.11.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,47 @@
+import {
+  FieldResolver,
+  ResolvedEntryData,
+  FieldResolverContext,
+} from './fieldResolver'
+import {
+  GraphQLFieldResolver,
+  GraphQLOutputType,
+  GraphQLResolveInfo,
+} from 'graphql/type/definition'
+import { PersistenceService } from '../../persistence/persistence.service'
+import { EntryData } from '@commitspark/git-adapter'
+
+export class EntryReferenceResolver implements FieldResolver<any> {
+  resolve: GraphQLFieldResolver<
+    any,
+    FieldResolverContext,
+    any,
+    Promise<ResolvedEntryData<EntryData | EntryData[] | null>>
+  >
+
+  constructor(private readonly persistence: PersistenceService) {
+    this.resolve = (
+      fieldValue,
+      args: any,
+      context: FieldResolverContext,
+      info,
+    ): Promise<ResolvedEntryData<EntryData | EntryData[] | null>> =>
+      this.resolveFieldValue(fieldValue, args, context, info, info.returnType)
+  }
+
+  private async resolveFieldValue(
+    fieldValue: any,
+    args: any,
+    context: FieldResolverContext,
+    info: GraphQLResolveInfo,
+    currentType: GraphQLOutputType,
+  ): Promise<ResolvedEntryData<EntryData | EntryData[] | 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 { EntryData } from '@commitspark/git-adapter'
+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<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/fieldResolver.ts

@@ -0,0 +1,19 @@
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { EntryData } from '@commitspark/git-adapter'
+import { GitAdapter } from '@commitspark/git-adapter'
+
+export interface FieldResolverContext {
+  gitAdapter: GitAdapter
+  getCurrentRef(): string
+}
+
+export interface FieldResolver<
+  TSource,
+  TContext = FieldResolverContext,
+  TArgs = any,
+  TResult = Promise<ResolvedEntryData<EntryData | EntryData[] | 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 { EntryData } from '@commitspark/git-adapter'
+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<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

@@ -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

@@ -1,11 +1,11 @@
-import { Entry } from '../persistence/persistence.service'
+import { EntryData } from '@commitspark/git-adapter'
 import { ApolloContext } from '../app/api.service'
 import { GraphQLFieldResolver } from 'graphql/type/definition'
 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'
@@ -33,7 +33,7 @@ export class QueriesMutationsGeneratorService {
         any,
         ApolloContext,
         any,
-        Promise<Entry[]>
+        Promise<EntryData[]>
       > = this.queryAllResolverGenerator.createResolver(typeName)
 
       const queryAllMetaName = `_${queryAllName}Meta`
@@ -51,7 +51,7 @@ export class QueriesMutationsGeneratorService {
         any,
         ApolloContext,
         any,
-        Promise<Entry>
+        Promise<EntryData>
       > = this.queryByIdResolverGenerator.createResolver(typeName)
 
       const inputTypeName = `${typeName}Input`
@@ -61,7 +61,7 @@ export class QueriesMutationsGeneratorService {
         any,
         ApolloContext,
         any,
-        Promise<Entry>
+        Promise<EntryData>
       > = this.mutationCreateResolverGenerator.createResolver(typeName)
 
       const updateMutationName = `update${typeName}`
@@ -70,7 +70,7 @@ export class QueriesMutationsGeneratorService {
         any,
         ApolloContext,
         any,
-        Promise<Entry>
+        Promise<EntryData>
       > = this.mutationUpdateResolverGenerator.createResolver(typeName)
 
       const deleteMutationName = `delete${typeName}`
@@ -79,7 +79,7 @@ export class QueriesMutationsGeneratorService {
         any,
         ApolloContext,
         any,
-        Promise<Entry>
+        Promise<EntryData>
       > = this.mutationDeleteResolverGenerator.createResolver(typeName)
 
       return {
@@ -118,9 +118,9 @@ export class QueriesMutationsGeneratorService {
   }
 
   public generateTypeNameQuery(): IGeneratedQuery<Promise<string>> {
-    const contentTypeQueryName = '_typeName'
-    const contentTypeQueryString = `${contentTypeQueryName}(id: ID!): String`
-    const contentTypeQueryResolver: GraphQLFieldResolver<
+    const entryTypeQueryName = '_typeName'
+    const entryTypeQueryString = `${entryTypeQueryName}(id: ID!): String`
+    const entryTypeQueryResolver: GraphQLFieldResolver<
       any,
       ApolloContext,
       any,
@@ -128,20 +128,20 @@ export class QueriesMutationsGeneratorService {
     > = this.queryTypeByIdResolverGenerator.createResolver()
 
     return {
-      name: contentTypeQueryName,
-      schemaString: contentTypeQueryString,
-      resolver: contentTypeQueryResolver,
+      name: entryTypeQueryName,
+      schemaString: entryTypeQueryString,
+      resolver: entryTypeQueryResolver,
     }
   }
 }
 
 export interface IGeneratedSchema {
-  queryAll: IGeneratedQuery<Promise<Entry[]>>
+  queryAll: IGeneratedQuery<Promise<EntryData[]>>
   queryAllMeta: IGeneratedQuery<Promise<TypeCount>>
-  queryById: IGeneratedQuery<Promise<Entry>>
-  createMutation: IGeneratedQuery<Promise<Entry>>
-  updateMutation: IGeneratedQuery<Promise<Entry>>
-  deleteMutation: IGeneratedQuery<Promise<Entry>>
+  queryById: IGeneratedQuery<Promise<EntryData>>
+  createMutation: IGeneratedQuery<Promise<EntryData>>
+  updateMutation: IGeneratedQuery<Promise<EntryData>>
+  deleteMutation: IGeneratedQuery<Promise<EntryData>>
 }
 
 export interface IGeneratedQuery<T> {

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

@@ -1,23 +1,47 @@
 import { GraphQLFieldResolver } from 'graphql/type/definition'
 import { ApolloContext } from '../../app/api.service'
-import {
-  Entry,
-  PersistenceService,
-} from '../../persistence/persistence.service'
+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 {
+  EntryDraft,
+  EntryData,
+  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,
-  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<Entry>> {
+  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<EntryData>> {
     return async (
       source,
       args,
       context: ApolloContext,
       info,
-    ): Promise<Entry> => {
+    ): 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(
@@ -35,23 +59,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: 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.message,
+      })
+      context.setCurrentRef(commit.ref)
+
+      const newEntry = await this.persistence.findByTypeId(
         context.gitAdapter,
         context.getCurrentRef(),
         typeName,
         args.id,
       )
+      return { ...newEntry.data, id: newEntry.id }
     }
   }
 }