@commitspark/graphql-api 0.9.4 → 0.10.0

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

@@ -0,0 +1,131 @@
+import {
+  Entry,
+  PersistenceService,
+} from '../../persistence/persistence.service'
+import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { ApolloContext } from '../../app/api.service'
+import { EntryReferenceUtil } from '../schema-utils/entry-reference-util'
+import { isObjectType } from 'graphql'
+import { ContentEntryData, ContentEntryDraft } from '@commitspark/git-adapter'
+
+export class MutationUpdateResolverGenerator {
+  constructor(
+    private readonly persistence: PersistenceService,
+    private readonly entryReferenceUtil: EntryReferenceUtil,
+  ) {}
+
+  public createResolver(
+    typeName: string,
+  ): GraphQLFieldResolver<any, ApolloContext, any, Promise<Entry>> {
+    return async (
+      source,
+      args,
+      context: ApolloContext,
+      info,
+    ): Promise<Entry> => {
+      if (!isObjectType(info.returnType)) {
+        throw new Error('Expected to update an ObjectType')
+      }
+
+      const existingEntry = await this.persistence.findByTypeId(
+        context.gitAdapter,
+        context.getCurrentRef(),
+        typeName,
+        args.id,
+      )
+
+      const existingReferencedEntryIds =
+        await this.entryReferenceUtil.getReferencedEntryIds(
+          info.returnType,
+          context,
+          null,
+          info.returnType,
+          existingEntry.data,
+        )
+
+      const mergedData = this.mergeData(existingEntry.data ?? null, args.data)
+      const updatedReferencedEntryIds =
+        await this.entryReferenceUtil.getReferencedEntryIds(
+          info.returnType,
+          context,
+          null,
+          info.returnType,
+          mergedData,
+        )
+
+      const noLongerReferencedIds = existingReferencedEntryIds.filter(
+        (entryId) => !updatedReferencedEntryIds.includes(entryId),
+      )
+      const newlyReferencedIds = updatedReferencedEntryIds.filter(
+        (entryId) => !existingReferencedEntryIds.includes(entryId),
+      )
+
+      const referencedEntryUpdates: ContentEntryDraft[] = []
+      for (const noLongerReferencedEntryId of noLongerReferencedIds) {
+        const noLongerReferencedEntry = await this.persistence.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 this.persistence.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(),
+        contentEntries: [
+          { ...existingEntry, data: mergedData, deletion: false },
+          ...referencedEntryUpdates,
+        ],
+        message: args.message,
+      })
+      context.setCurrentRef(commit.ref)
+
+      const updatedEntry = await this.persistence.findByTypeId(
+        context.gitAdapter,
+        context.getCurrentRef(),
+        typeName,
+        args.id,
+      )
+      return { ...updatedEntry.data, id: updatedEntry.id }
+    }
+  }
+
+  private mergeData(
+    existingEntryData: ContentEntryData,
+    updateData: ContentEntryData,
+  ): ContentEntryData {
+    return {
+      ...existingEntryData,
+      ...updateData,
+    }
+  }
+}

package/src/graphql/resolver-generators/object-type-field-default-value-resolver-generator.ts

@@ -0,0 +1,119 @@
+import {
+  GraphQLFieldResolver,
+  GraphQLOutputType,
+} from 'graphql/type/definition'
+import { ApolloContext } from '../../app/api.service'
+import { Entry } from '../../persistence/persistence.service'
+import {
+  GraphQLField,
+  GraphQLObjectType,
+  GraphQLSchema,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isUnionType,
+} from 'graphql'
+import { ResolvedEntryData } from '../field-resolver/fieldResolver'
+import { FieldDefaultValueResolver } from '../field-resolver/field-default-value-resolver'
+
+export class ObjectTypeFieldDefaultValueResolverGenerator {
+  constructor(
+    private readonly fieldDefaultValueResolver: FieldDefaultValueResolver,
+  ) {}
+
+  public createResolver(
+    schema: GraphQLSchema,
+  ): Record<
+    string,
+    Record<
+      string,
+      GraphQLFieldResolver<
+        any,
+        ApolloContext,
+        any,
+        Promise<ResolvedEntryData<Entry | Entry[] | null>>
+      >
+    >
+  > {
+    const resolvers: Record<
+      string,
+      Record<
+        string,
+        GraphQLFieldResolver<
+          any,
+          ApolloContext,
+          any,
+          Promise<ResolvedEntryData<Entry | Entry[] | null>>
+        >
+      >
+    > = {}
+    for (const typeName of Object.keys(schema.getTypeMap())) {
+      const type = schema.getType(typeName)
+      if (!isObjectType(type) || type.name.startsWith('__')) {
+        continue
+      }
+      const objectType = type as GraphQLObjectType
+      const fieldsForCustomDefaultValueResolver =
+        this.getFieldsForCustomDefaultValueResolver(objectType)
+
+      const fieldResolvers: Record<
+        string,
+        GraphQLFieldResolver<
+          any,
+          ApolloContext,
+          any,
+          Promise<ResolvedEntryData<Entry | Entry[] | null>>
+        >
+      > = {}
+      for (const field of fieldsForCustomDefaultValueResolver) {
+        fieldResolvers[field.name] = (
+          obj,
+          args,
+          context,
+          info,
+        ): Promise<ResolvedEntryData<Entry | Entry[] | null>> =>
+          this.fieldDefaultValueResolver.resolve(
+            field.name in obj ? obj[field.name] : undefined,
+            args,
+            {
+              gitAdapter: context.gitAdapter,
+              getCurrentRef: context.getCurrentRef,
+            },
+            info,
+          )
+      }
+
+      if (Object.keys(fieldResolvers).length > 0) {
+        resolvers[typeName] = fieldResolvers
+      }
+    }
+
+    return resolvers
+  }
+
+  private getFieldsForCustomDefaultValueResolver(
+    objectType: GraphQLObjectType,
+  ): GraphQLField<any, any>[] {
+    const fields = []
+    for (const fieldsKey in objectType.getFields()) {
+      const field: GraphQLField<any, any> = objectType.getFields()[fieldsKey]
+      if (this.requiresCustomDefaultValueResolver(field.type)) {
+        fields.push(field)
+      }
+    }
+    return fields
+  }
+
+  private requiresCustomDefaultValueResolver(type: GraphQLOutputType): boolean {
+    if (isNonNullType(type)) {
+      return this.requiresCustomDefaultValueResolver(type.ofType)
+    } else if (isListType(type)) {
+      return true
+    } else if (isUnionType(type)) {
+      return true
+    } else if (isObjectType(type)) {
+      return true
+    }
+    return false
+  }
+}

package/src/graphql/resolver-generators/query-all-resolver-generator.ts

@@ -17,11 +17,15 @@ export class QueryAllResolverGenerator {
       context: ApolloContext,
       info,
     ): Promise<Entry[]> => {
-      return this.persistence.findByType(
+      const entries = await this.persistence.findByType(
         context.gitAdapter,
         context.getCurrentRef(),
         typeName,
       )
+
+      return entries.map((entry) => {
+        return { ...entry.data, id: entry.id }
+      })
     }
   }
 }

package/src/graphql/resolver-generators/query-by-id-resolver-generator.ts

@@ -12,12 +12,14 @@ export class QueryByIdResolverGenerator {
     typeName: string,
   ): GraphQLFieldResolver<any, ApolloContext, any, Promise<Entry>> {
     return async (obj, args, context, info): Promise<Entry> => {
-      return this.persistence.findByTypeId(
+      const entry = await this.persistence.findByTypeId(
         context.gitAdapter,
         context.getCurrentRef(),
         typeName,
         args.id,
       )
+
+      return { ...entry.data, id: entry.id }
     }
   }
 }

package/src/graphql/resolver-generators/union-type-resolver-generator.ts

@@ -4,13 +4,13 @@ import {
   GraphQLAbstractType,
   GraphQLResolveInfo,
   GraphQLTypeResolver,
-} from 'graphql/type/definition'
-import { EntryReferenceUtil } from '../schema-utils/entry-reference-util'
+} from 'graphql'
+import { EntryTypeUtil } from '../schema-utils/entry-type-util'
 
 export class UnionTypeResolverGenerator {
   constructor(
     private readonly persistence: PersistenceService,
-    private readonly entryReferenceUtil: EntryReferenceUtil,
+    private readonly entryTypeUtil: EntryTypeUtil,
   ) {}
 
   public createResolver(): GraphQLTypeResolver<any, ApolloContext> {
@@ -20,9 +20,7 @@ export class UnionTypeResolverGenerator {
       info: GraphQLResolveInfo,
       abstractType: GraphQLAbstractType,
     ): Promise<string> => {
-      if (
-        this.entryReferenceUtil.buildsOnTypeWithEntryDirective(abstractType)
-      ) {
+      if (this.entryTypeUtil.buildsOnTypeWithEntryDirective(abstractType)) {
         return this.persistence.getTypeById(
           context.gitAdapter,
           context.getCurrentRef(),
@@ -30,7 +28,7 @@ export class UnionTypeResolverGenerator {
         )
       } else {
         // We have injected an internal `__typename` field into the data of fields pointing to a non-entry union
-        // in UnionValueResolverGenerator. This artificial field holds the type information we need here.
+        // in UnionValueResolver. This artificial field holds the type information we need here.
         return obj.__typename
       }
 

package/src/graphql/schema-analyzer.service.ts

@@ -1,20 +1,20 @@
-import { GraphQLField, GraphQLObjectType, GraphQLSchema } from 'graphql'
+import {
+  GraphQLObjectType,
+  GraphQLSchema,
+  isInterfaceType,
+  isObjectType,
+  isUnionType,
+} from 'graphql'
 import { getDirective } from '@graphql-tools/utils'
 import { GraphQLInterfaceType, GraphQLUnionType } from 'graphql/type/definition'
-import { Kind } from 'graphql/language/kinds'
-import { ApolloContext } from '../app/api.service'
-import { EntryReferenceUtil } from './schema-utils/entry-reference-util'
 
 export class SchemaAnalyzerService {
-  constructor(private readonly entryReferenceUtil: EntryReferenceUtil) {}
-
   public analyzeSchema(schema: GraphQLSchema): ISchemaAnalyzerResult {
     const result: ISchemaAnalyzerResult = {
       entryDirectiveTypes: [],
       objectTypes: [],
       interfaceTypes: [],
       unionTypes: [],
-      typesWithEntryReferences: [],
     }
 
     const typeMap = schema.getTypeMap()
@@ -24,31 +24,21 @@ export class SchemaAnalyzerService {
         continue
       }
 
-      if (type.astNode?.kind === Kind.OBJECT_TYPE_DEFINITION) {
+      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)
         }
-        const fieldsWithEntryReference =
-          this.entryReferenceUtil.getFieldsWithReferenceToTypeWithEntryDirective(
-            objectType,
-          )
-        if (fieldsWithEntryReference.length > 0) {
-          result.typesWithEntryReferences.push({
-            type: objectType,
-            fields: fieldsWithEntryReference,
-          })
-        }
       }
 
-      if (type.astNode?.kind === Kind.INTERFACE_TYPE_DEFINITION) {
+      if (isInterfaceType(type)) {
         const interfaceType = type as GraphQLInterfaceType
         result.interfaceTypes.push(interfaceType)
       }
 
-      if (type.astNode?.kind === Kind.UNION_TYPE_DEFINITION) {
+      if (isUnionType(type)) {
         const unionType = type as GraphQLUnionType
         result.unionTypes.push(unionType)
       }
@@ -63,8 +53,4 @@ export interface ISchemaAnalyzerResult {
   objectTypes: GraphQLObjectType[]
   interfaceTypes: GraphQLInterfaceType[]
   unionTypes: GraphQLUnionType[]
-  typesWithEntryReferences: {
-    type: GraphQLObjectType<any, ApolloContext>
-    fields: GraphQLField<any, ApolloContext>[]
-  }[]
 }

package/src/graphql/schema-generator.service.ts

@@ -1,7 +1,4 @@
-import {
-  IGeneratedSchema,
-  QueriesMutationsGeneratorService,
-} from './queries-mutations-generator.service'
+import { QueriesMutationsGeneratorService } from './queries-mutations-generator.service'
 import {
   IExecutableSchemaDefinition,
   makeExecutableSchema,
@@ -10,7 +7,6 @@ import { SchemaAnalyzerService } from './schema-analyzer.service'
 import { InputTypeGeneratorService } from './input-type-generator.service'
 import { SchemaRootTypeGeneratorService } from './schema-root-type-generator.service'
 import { printSchemaWithDirectives } from '@graphql-tools/utils'
-import { EntryReferenceResolverGenerator } from './resolver-generators/entry-reference-resolver.generator'
 import { UnionTypeResolverGenerator } from './resolver-generators/union-type-resolver-generator'
 import { ApolloContext } from '../app/api.service'
 import {
@@ -19,7 +15,7 @@ import {
 } from 'graphql/type/definition'
 import { SchemaValidator } from './schema-validator'
 import { Entry } from '../persistence/persistence.service'
-import { UnionValueResolverGenerator } from './resolver-generators/union-value-resolver-generator'
+import { ObjectTypeFieldDefaultValueResolverGenerator } from './resolver-generators/object-type-field-default-value-resolver-generator'
 
 export class SchemaGeneratorService {
   constructor(
@@ -27,9 +23,8 @@ export class SchemaGeneratorService {
     private readonly schemaAnalyzer: SchemaAnalyzerService,
     private readonly inputTypeGenerator: InputTypeGeneratorService,
     private readonly schemaRootTypeGenerator: SchemaRootTypeGeneratorService,
-    private readonly entryReferenceResolverGenerator: EntryReferenceResolverGenerator,
     private readonly unionTypeResolverGenerator: UnionTypeResolverGenerator,
-    private readonly unionValueResolverGenerator: UnionValueResolverGenerator,
+    private readonly objectTypeFieldDefaultValueResolverGenerator: ObjectTypeFieldDefaultValueResolverGenerator,
     private readonly schemaValidator: SchemaValidator,
   ) {}
 
@@ -74,10 +69,6 @@ export class SchemaGeneratorService {
         >
       >
     > = {}
-    for (const type of schemaAnalyzerResult.typesWithEntryReferences) {
-      generatedEntryReferenceResolvers[type.type.name] =
-        this.entryReferenceResolverGenerator.createResolver(context, type)
-    }
 
     const generatedObjectInputTypeStrings =
       this.inputTypeGenerator.generateObjectInputTypeStrings(
@@ -112,8 +103,8 @@ export class SchemaGeneratorService {
         __resolveType: this.unionTypeResolverGenerator.createResolver(),
       }
     }
-    const generatedUnionValueResolvers =
-      this.unionValueResolverGenerator.createResolver(schema)
+    const generatedObjectTypeFieldDefaultValueResolvers =
+      this.objectTypeFieldDefaultValueResolverGenerator.createResolver(schema)
 
     const generatedQueryResolvers: Record<
       string,
@@ -124,9 +115,7 @@ export class SchemaGeneratorService {
       GraphQLFieldResolver<any, ApolloContext>
     > = {}
 
-    generatedQueriesMutations.forEach(function (
-      element: IGeneratedSchema,
-    ): void {
+    for (const element of generatedQueriesMutations) {
       generatedQueryResolvers[element.queryAll.name] = element.queryAll.resolver
       generatedQueryResolvers[element.queryAllMeta.name] =
         element.queryAllMeta.resolver
@@ -138,7 +127,7 @@ export class SchemaGeneratorService {
         element.updateMutation.resolver
       generatedMutationResolvers[element.deleteMutation.name] =
         element.deleteMutation.resolver
-    })
+    }
     generatedQueryResolvers[generatedTypeNameQuery.name] =
       generatedTypeNameQuery.resolver
 
@@ -160,10 +149,12 @@ export class SchemaGeneratorService {
         ...generatedUnionTypeResolvers[typeName],
       }
     }
-    for (const typeName of Object.keys(generatedUnionValueResolvers)) {
+    for (const typeName of Object.keys(
+      generatedObjectTypeFieldDefaultValueResolvers,
+    )) {
       allGeneratedResolvers[typeName] = {
         ...(allGeneratedResolvers[typeName] ?? {}),
-        ...generatedUnionValueResolvers[typeName],
+        ...generatedObjectTypeFieldDefaultValueResolvers[typeName],
       }
     }
     for (const typeName of Object.keys(generatedEntryReferenceResolvers)) {