@commitspark/graphql-api 2.0.0-beta.3 → 2.0.0-beta.5

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

@@ -1,9 +1,13 @@
-import { findById, findByTypeId } from '../../../persistence/persistence.ts'
-import { Entry, EntryDraft } from '@commitspark/git-adapter'
-import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
-import { isObjectType } from 'graphql'
+import {
+  assertExpectedVersion,
+  findByTypeId,
+} from '../../../persistence/persistence.ts'
+import { Entry } from '@commitspark/git-adapter'
+import { getReferencingEntryIds } from '../../schema-utils/entry-reference-util.ts'
 import { QueryMutationResolver } from '../types.ts'
 import { createError, ErrorCode } from '../../errors.ts'
+import { getCommitMessage } from '../commit-message.ts'
+import { commitWithRetry } from '../../../persistence/commit-with-retry.ts'
 
 export const mutationDeleteResolver: QueryMutationResolver<string> = async (
   source,
@@ -11,66 +15,47 @@ export const mutationDeleteResolver: QueryMutationResolver<string> = async (
   context,
   info,
 ) => {
-  const entry: Entry = await findByTypeId(context, 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 commitMessage = getCommitMessage(
+    args.commit,
+    'Delete',
+    context.type.name,
+    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,
-      {},
-    )
-  }
+  await commitWithRetry(context, async () => {
+    const entry: Entry = await findByTypeId(context, context.type.name, args.id)
+    await assertExpectedVersion(context, args.id, args.expectedVersion)
 
-  const referencedEntryIds = await getReferencedEntryIds(
-    entryType,
-    context,
-    null,
-    entryType,
-    entry.data ?? null,
-  )
-  const referencedEntryUpdates: EntryDraft[] = []
-  for (const referencedEntryId of referencedEntryIds) {
-    const noLongerReferencedEntry = await findById(context, referencedEntryId)
-    referencedEntryUpdates.push({
-      ...noLongerReferencedEntry,
-      metadata: {
-        ...noLongerReferencedEntry.metadata,
-        referencedBy: noLongerReferencedEntry.metadata.referencedBy?.filter(
-          (entryId) => entryId !== args.id,
-        ),
-      },
-      deletion: false,
-    })
-  }
+    // references held by the entry itself are deleted together with the entry
+    const otherReferencingIds = (
+      await getReferencingEntryIds(context, info.schema, args.id)
+    ).filter((referencingId) => referencingId !== args.id)
+    if (otherReferencingIds.length > 0) {
+      const otherIds = otherReferencingIds
+        .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 commit = await context.gitAdapter.createCommit({
-    ref: context.branch,
-    parentSha: context.getCurrentHash(),
-    entries: [
-      {
-        ...entry,
-        deletion: true,
-      },
-      ...referencedEntryUpdates,
-    ],
-    message: args.commitMessage,
+    return {
+      ref: context.branch,
+      parentSha: context.getCurrentHash(),
+      entries: [
+        {
+          ...entry,
+          deletion: true,
+        },
+      ],
+      ...commitMessage,
+    }
   })
-  context.setCurrentHash(commit.commitHash)
 
   return args.id
 }

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

@@ -1,9 +1,14 @@
-import { findById, findByTypeId } from '../../../persistence/persistence.ts'
-import { getReferencedEntryIds } from '../../schema-utils/entry-reference-util.ts'
+import {
+  assertExpectedVersion,
+  findByTypeId,
+} from '../../../persistence/persistence.ts'
+import { validateEntryReferences } from '../../schema-utils/entry-reference-util.ts'
 import { isObjectType } from 'graphql'
-import { EntryData, EntryDraft } from '@commitspark/git-adapter'
+import { EntryData } from '@commitspark/git-adapter'
 import { QueryMutationResolver } from '../types.ts'
 import { createError, ErrorCode } from '../../errors.ts'
+import { getCommitMessage } from '../commit-message.ts'
+import { commitWithRetry } from '../../../persistence/commit-with-retry.ts'
 
 function mergeData(
   existingEntryData: EntryData,
@@ -21,6 +26,7 @@ export const mutationUpdateResolver: QueryMutationResolver<EntryData> = async (
   context,
   info,
 ) => {
+  void info
   if (!isObjectType(context.type)) {
     throw createError(
       `Type "${context.type.name}" cannot be mutated as is not an ObjectType.`,
@@ -28,76 +34,41 @@ export const mutationUpdateResolver: QueryMutationResolver<EntryData> = async (
       {},
     )
   }
-
-  const existingEntry = await findByTypeId(context, context.type.name, args.id)
-
-  const existingReferencedEntryIds = await getReferencedEntryIds(
-    context.type,
-    context,
-    null,
-    info.returnType,
-    existingEntry.data ?? null,
-  )
-
-  const mergedData = mergeData(existingEntry.data ?? null, args.data ?? null)
-  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),
+  // narrowed type, as narrowing does not apply within the callback below
+  const entryType = context.type
+  const commitMessage = getCommitMessage(
+    args.commit,
+    'Update',
+    context.type.name,
+    args.id,
   )
 
-  const referencedEntryUpdates: EntryDraft[] = []
-  for (const noLongerReferencedEntryId of noLongerReferencedIds) {
-    const noLongerReferencedEntry = await findById(
+  await commitWithRetry(context, async () => {
+    const existingEntry = await findByTypeId(
       context,
-      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, newlyReferencedEntryId)
-    const updatedReferenceList: string[] = [
-      ...(newlyReferencedEntry.metadata.referencedBy ?? []),
+      context.type.name,
       args.id,
-    ].sort()
-    referencedEntryUpdates.push({
-      ...newlyReferencedEntry,
-      metadata: {
-        ...newlyReferencedEntry.metadata,
-        referencedBy: updatedReferenceList,
-      },
-      deletion: false,
-    })
-  }
+    )
+    await assertExpectedVersion(context, args.id, args.expectedVersion)
+
+    const mergedData = mergeData(existingEntry.data ?? null, args.data ?? null)
+    await validateEntryReferences(entryType, context, mergedData)
 
-  const commit = await context.gitAdapter.createCommit({
-    ref: context.branch,
-    parentSha: context.getCurrentHash(),
-    entries: [
-      { ...existingEntry, data: mergedData, deletion: false },
-      ...referencedEntryUpdates,
-    ],
-    message: args.commitMessage,
+    return {
+      ref: context.branch,
+      parentSha: context.getCurrentHash(),
+      entries: [
+        {
+          id: existingEntry.id,
+          // only the type is written, which removes metadata no longer in use from existing entries
+          metadata: { type: existingEntry.metadata.type },
+          data: mergedData,
+          deletion: false,
+        },
+      ],
+      ...commitMessage,
+    }
   })
-  context.setCurrentHash(commit.commitHash)
 
   const updatedEntry = await findByTypeId(context, context.type.name, args.id)
   return { ...updatedEntry.data, id: updatedEntry.id }

package/src/graphql/resolvers/types.ts

@@ -8,14 +8,24 @@ import { EntryData } from '@commitspark/git-adapter'
 import { SearchHit } from '@commitspark/search-adapter'
 import { RecursiveArray } from './field-resolvers/types.ts'
 
-export interface QueryMutationResolverContext extends ApolloContext {
+export interface CommitInput {
+  message?: string | null
+  body?: string | null
+}
+
+interface QueryMutationResolverContext extends ApolloContext {
   type: GraphQLNamedType
 }
 
 export type QueryMutationResolver<ResultType> = GraphQLFieldResolver<
   unknown,
   QueryMutationResolverContext,
-  { id: string; data?: EntryData; commitMessage: string },
+  {
+    id: string
+    data?: EntryData
+    commit?: CommitInput | null
+    expectedVersion?: string | null
+  },
   Promise<ResultType>
 >
 
@@ -42,3 +52,17 @@ export type ContextInjectionResolver = GraphQLFieldResolver<
   Record<string, unknown>,
   Promise<RecursiveArray<EntryData>>
 >
+
+export type ReferencedByResolver = GraphQLFieldResolver<
+  EntryData & { id: string },
+  ApolloContext,
+  Record<string, never>,
+  Promise<string[]>
+>
+
+export type VersionResolver = GraphQLFieldResolver<
+  EntryData & { id: string },
+  ApolloContext,
+  Record<string, never>,
+  Promise<string>
+>

package/src/graphql/schema-generator.ts

@@ -1,5 +1,7 @@
 import {
+  generateCommitInputType,
   generateQueriesAndMutations,
+  generateEntryFields,
   generateSearchQuery,
   generateTypeNameQuery,
 } from './queries-mutations-generator.ts'
@@ -25,8 +27,10 @@ import { FieldResolver } from './resolvers/field-resolvers/types.ts'
 import {
   ContextInjectionResolver,
   QueryMutationResolver,
+  ReferencedByResolver,
   SearchQueryResolver,
   UnionTypeResolver,
+  VersionResolver,
 } from './resolvers/types.ts'
 import { EntryData } from '@commitspark/git-adapter'
 
@@ -61,6 +65,9 @@ export async function generateSchema(
   const generatedTypeNameQuery = generateTypeNameQuery()
   const generatedSearchQuery =
     context.searchAdapter !== undefined ? generateSearchQuery() : undefined
+  const generatedEntryFields = generateEntryFields(
+    schemaAnalyzerResult.entryDirectiveTypes,
+  )
 
   const generatedObjectInputTypeStrings = generateObjectInputTypeStrings(
     schemaAnalyzerResult.objectTypes,
@@ -132,6 +139,8 @@ ${generatedSchemaRootTypeStrings}`
         | GraphQLTypeResolver<unknown, ApolloContext>
         | ContextInjectionResolver
         | FieldResolver
+        | ReferencedByResolver
+        | VersionResolver
       >
     | UnionTypeResolverRecord
   > = {
@@ -151,13 +160,23 @@ ${generatedSchemaRootTypeStrings}`
       ...generatedObjectTypeFieldResolvers[typeName],
     }
   }
+  for (const entryFields of generatedEntryFields) {
+    allGeneratedResolvers[entryFields.typeName] = {
+      ...(allGeneratedResolvers[entryFields.typeName] ?? {}),
+      ...entryFields.resolvers,
+    }
+  }
 
   const typeDefs = [
     filteredOriginalSchemaString,
     generatedSchemaString,
+    generateCommitInputType(),
     generatedIdInputTypeStrings.join('\n'),
     generatedObjectInputTypeStrings.join('\n'),
     generatedUnionInputTypeStrings.join('\n'),
+    generatedEntryFields
+      .map((entryFields) => entryFields.typeExtensionString)
+      .join('\n'),
     generatedSearchQuery?.typeDefinitionString ?? '',
   ].filter((typeDef) => typeDef.length > 0)