@commitspark/graphql-api 0.9.3 → 0.10.0

package/src/graphql/schema-utils/entry-reference-util.ts

@@ -1,49 +1,191 @@
 import {
-  GraphQLField,
-  GraphQLList,
-  GraphQLNonNull,
+  GraphQLNullableType,
   GraphQLObjectType,
-} from 'graphql/type'
-import { GraphQLNullableType, GraphQLUnionType } from 'graphql/type/definition'
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isUnionType,
+} from 'graphql'
+import { ApolloContext } from '../../app/api.service'
+import { GraphQLError } from 'graphql/error/GraphQLError'
+import { PersistenceService } from '../../persistence/persistence.service'
+import { UnionTypeUtil } from './union-type-util'
+import { EntryTypeUtil } from './entry-type-util'
 
 export class EntryReferenceUtil {
-  public getFieldsWithReferenceToTypeWithEntryDirective(
-    objectType: GraphQLObjectType,
-  ): GraphQLField<any, any>[] {
-    const fields = []
-    for (const fieldsKey in objectType.getFields()) {
-      const field: GraphQLField<any, any> = objectType.getFields()[fieldsKey]
-      if (this.buildsOnTypeWithEntryDirective(field.type)) {
-        fields.push(field)
+  constructor(
+    private readonly persistence: PersistenceService,
+    private readonly entryTypeUtil: EntryTypeUtil,
+    private readonly unionTypeUtil: UnionTypeUtil,
+  ) {}
+
+  public async getReferencedEntryIds(
+    rootType: GraphQLObjectType,
+    context: ApolloContext,
+    fieldName: string | null,
+    type: GraphQLNullableType,
+    data: any,
+  ): Promise<string[]> {
+    if (isNonNullType(type)) {
+      return this.getReferencedEntryIds(
+        rootType,
+        context,
+        fieldName,
+        type.ofType,
+        data,
+      )
+    } else if (isListType(type)) {
+      let referencedEntryIds: string[] = []
+      for (const element of data) {
+        referencedEntryIds = [
+          ...referencedEntryIds,
+          ...(await this.getReferencedEntryIds(
+            rootType,
+            context,
+            fieldName,
+            type.ofType,
+            element,
+          )),
+        ]
+      }
+      // deduplicate
+      referencedEntryIds = [...new Set(referencedEntryIds)]
+      return referencedEntryIds
+    } else if (isUnionType(type)) {
+      if (this.entryTypeUtil.isUnionOfEntryTypes(type)) {
+        await this.validateReference(context, '', type, data)
+        return [data.id]
+      }
+
+      const unionTypeName =
+        this.unionTypeUtil.getUnionTypeNameFromFieldValue(data)
+      const unionType = type
+        .getTypes()
+        .find((type) => type.name === unionTypeName)
+      if (!unionType) {
+        throw new Error(
+          `Type "${unionTypeName}" found in field data is not a valid type for union type "${type.name}".`,
+        )
+      }
+      const unionValue = this.unionTypeUtil.getUnionValue(data)
+      return this.getReferencedEntryIds(
+        rootType,
+        context,
+        fieldName,
+        unionType,
+        unionValue,
+      )
+    } else if (isObjectType(type)) {
+      if (
+        type.name !== rootType.name &&
+        this.entryTypeUtil.hasEntryDirective(type)
+      ) {
+        await this.validateReference(context, fieldName ?? '', type, data)
+        return [data.id]
+      } else {
+        let referencedEntryIds: string[] = []
+        for (const [fieldsKey, field] of Object.entries(type.getFields())) {
+          const fieldValue = data[fieldsKey] ?? undefined
+          if (fieldValue !== undefined) {
+            const nestedResult = await this.getReferencedEntryIds(
+              rootType,
+              context,
+              fieldsKey,
+              field.type,
+              fieldValue,
+            )
+            referencedEntryIds = [...referencedEntryIds, ...nestedResult]
+          }
+        }
+        // deduplicate
+        referencedEntryIds = [...new Set(referencedEntryIds)]
+        return referencedEntryIds
       }
     }
-    return fields
+
+    return []
   }
 
-  public buildsOnTypeWithEntryDirective(type: GraphQLNullableType): boolean {
-    if (type instanceof GraphQLNonNull) {
-      return this.buildsOnTypeWithEntryDirective(type.ofType)
-    } else if (type instanceof GraphQLList) {
-      return this.buildsOnTypeWithEntryDirective(type.ofType)
-    } else if (type instanceof GraphQLUnionType) {
-      return (
-        type
-          .getTypes()
-          .filter((unionType) => this.buildsOnTypeWithEntryDirective(unionType))
-          .length > 0
+  private async validateReference(
+    context: ApolloContext,
+    fieldName: string,
+    fieldType: GraphQLNullableType,
+    fieldValue: any,
+  ): Promise<void> {
+    if (isNonNullType(fieldType)) {
+      await this.validateReference(
+        context,
+        fieldName,
+        fieldType.ofType,
+        fieldValue,
       )
-    } else if (type instanceof GraphQLObjectType) {
-      return this.hasEntryDirective(type)
+      return
+    } else if (isListType(fieldType)) {
+      if (!Array.isArray(fieldValue)) {
+        throw new Error(`Expected array value in field "${fieldName}"`)
+      }
+      for (const fieldListElement of fieldValue) {
+        await this.validateReference(
+          context,
+          fieldName,
+          fieldType.ofType,
+          fieldListElement,
+        )
+      }
+      return
+    } else if (isUnionType(fieldType) || isObjectType(fieldType)) {
+      if (!('id' in fieldValue)) {
+        throw new Error('Expected key "id"')
+      }
+      const referencedId = fieldValue.id
+      let referencedTypeName
+      try {
+        referencedTypeName = await this.persistence.getTypeById(
+          context.gitAdapter,
+          context.getCurrentRef(),
+          referencedId,
+        )
+      } catch (error) {
+        throw new GraphQLError(
+          `Reference with id "${referencedId}" points to non-existing entry`,
+          {
+            extensions: {
+              code: 'BAD_USER_INPUT',
+              fieldName: fieldName,
+            },
+          },
+        )
+      }
+      if (!this.isPermittedReferenceType(referencedTypeName, fieldType)) {
+        throw new GraphQLError(
+          `Reference with id "${referencedId}" points to entry of incompatible type`,
+          {
+            extensions: {
+              code: 'BAD_USER_INPUT',
+              fieldName: fieldName,
+            },
+          },
+        )
+      }
     }
-    return false
   }
 
-  public hasEntryDirective(type: GraphQLObjectType): boolean {
-    return (
-      !!type.astNode &&
-      type.astNode.directives?.find(
-        (directive) => directive.name.value === 'Entry',
-      ) !== undefined
-    )
+  private isPermittedReferenceType(
+    referencedTypeName: string,
+    fieldType: GraphQLNullableType,
+  ): boolean {
+    if (isNonNullType(fieldType)) {
+      return this.isPermittedReferenceType(referencedTypeName, fieldType.ofType)
+    } else if (isListType(fieldType)) {
+      return this.isPermittedReferenceType(referencedTypeName, fieldType.ofType)
+    } else if (isUnionType(fieldType)) {
+      return fieldType
+        .getTypes()
+        .map((concreteType) => concreteType.name)
+        .includes(referencedTypeName)
+    } else if (isObjectType(fieldType)) {
+      return fieldType.name === referencedTypeName
+    }
+    return false
   }
 }

package/src/graphql/schema-utils/entry-type-util.ts

@@ -0,0 +1,42 @@
+import {
+  GraphQLNullableType,
+  GraphQLObjectType,
+  GraphQLUnionType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isUnionType,
+} from 'graphql'
+
+export class EntryTypeUtil {
+  public buildsOnTypeWithEntryDirective(type: GraphQLNullableType): boolean {
+    if (isNonNullType(type)) {
+      return this.buildsOnTypeWithEntryDirective(type.ofType)
+    } else if (isListType(type)) {
+      return this.buildsOnTypeWithEntryDirective(type.ofType)
+    } else if (isUnionType(type)) {
+      return this.isUnionOfEntryTypes(type)
+    } else if (isObjectType(type)) {
+      return this.hasEntryDirective(type)
+    }
+    return false
+  }
+
+  public hasEntryDirective(type: GraphQLObjectType): boolean {
+    return (
+      !!type.astNode &&
+      type.astNode.directives?.find(
+        (directive) => directive.name.value === 'Entry',
+      ) !== undefined
+    )
+  }
+
+  public isUnionOfEntryTypes(type: GraphQLUnionType): boolean {
+    return (
+      type
+        .getTypes()
+        .filter((unionType) => this.buildsOnTypeWithEntryDirective(unionType))
+        .length > 0
+    )
+  }
+}

package/src/graphql/schema-utils/union-type-util.ts

@@ -0,0 +1,23 @@
+import { Entry } from '../../persistence/persistence.service'
+
+export class UnionTypeUtil {
+  public getUnionTypeNameFromFieldValue(fieldValue: any): string {
+    if (typeof fieldValue !== 'object') {
+      throw new Error('Expected object as union value')
+    }
+
+    // Based on our @oneOf directive, we expect only one field whose name
+    // corresponds to the concrete type's name.
+    const firstKey = Object.keys(fieldValue)[0]
+    return firstKey.slice(0, 1).toUpperCase() + firstKey.slice(1)
+  }
+
+  public getUnionValue(fieldValue: any): Entry {
+    if (typeof fieldValue !== 'object') {
+      throw new Error('Expected object as union value')
+    }
+
+    const firstKey = Object.keys(fieldValue)[0]
+    return fieldValue[firstKey]
+  }
+}

package/src/persistence/persistence.service.ts

@@ -8,11 +8,15 @@ export class PersistenceService {
     id: string,
   ): Promise<string> {
     const allEntries = await gitAdapter.getContentEntries(commitHash)
-    const requestedEntry = allEntries.filter(
+    const requestedEntry = allEntries.find(
       (contentEntry: ContentEntry) => contentEntry.id === id,
-    )[0]
+    )
     if (requestedEntry === undefined) {
-      throw new Error(`Not found: ${id}`)
+      throw new GraphQLError(`Not found: ${id}`, {
+        extensions: {
+          code: 'NOT_FOUND',
+        },
+      })
     }
 
     return requestedEntry.metadata.type
@@ -22,29 +26,31 @@ export class PersistenceService {
     gitAdapter: GitAdapter,
     commitHash: string,
     id: string,
-  ): Promise<Entry> {
+  ): Promise<ContentEntry> {
     const allEntries = await gitAdapter.getContentEntries(commitHash)
-    const requestedEntry = allEntries.filter(
+    const requestedEntry = allEntries.find(
       (contentEntry: ContentEntry) => contentEntry.id === id,
-    )[0]
+    )
     if (requestedEntry === undefined) {
-      throw new Error(`Not found: ${id}`)
+      throw new GraphQLError(`Not found: ${id}`, {
+        extensions: {
+          code: 'NOT_FOUND',
+        },
+      })
     }
 
-    return { ...requestedEntry.data, id: id }
+    return requestedEntry
   }
 
   public async findByType(
     gitAdapter: GitAdapter,
     commitHash: string,
     type: string,
-  ): Promise<Entry[]> {
+  ): Promise<ContentEntry[]> {
     const allEntries = await gitAdapter.getContentEntries(commitHash)
-    return allEntries
-      .filter(
-        (contentEntry: ContentEntry) => contentEntry.metadata.type === type,
-      )
-      .map((value) => ({ ...value.data, id: value.id }))
+    return allEntries.filter(
+      (contentEntry: ContentEntry) => contentEntry.metadata.type === type,
+    )
   }
 
   public async findByTypeId(
@@ -52,130 +58,25 @@ export class PersistenceService {
     commitHash: string,
     type: string,
     id: string,
-  ): Promise<Entry> {
+  ): Promise<ContentEntry> {
     const allEntries = await gitAdapter.getContentEntries(commitHash)
-    const requestedEntry = allEntries.filter(
-      (contentEntry: ContentEntry) => contentEntry.id === id,
-    )[0]
-    if (requestedEntry === undefined || requestedEntry.metadata.type !== type) {
-      throw new Error(`Not found: ${type}, ${id}`)
-    }
-
-    return { ...requestedEntry.data, id: id }
-  }
-
-  public async createType(
-    gitAdapter: GitAdapter,
-    branch: string,
-    commitHash: string,
-    typeName: string,
-    id: string,
-    data: Entry,
-    message: string,
-  ): Promise<CommitResult> {
-    // TODO expose regex publicly to allow reuse
-    const regex = /^[a-zA-Z0-9\-_]{1,250}$/
-    if (!id.match(regex)) {
-      throw new GraphQLError(`"id" does not match regex "${regex}"`, {
-        extensions: {
-          code: 'BAD_USER_INPUT',
-          argumentName: 'id',
-        },
-      })
-    }
-
-    const commit = await gitAdapter.createCommit({
-      ref: branch,
-      parentSha: commitHash,
-      contentEntries: [
+    const requestedEntry = allEntries.find(
+      (contentEntry: ContentEntry) =>
+        contentEntry.id === id && contentEntry.metadata.type === type,
+    )
+    if (requestedEntry === undefined) {
+      throw new GraphQLError(
+        `No entry of type "${type}" with id "${id}" exists`,
         {
-          id: id,
-          metadata: {
-            type: typeName,
+          extensions: {
+            code: 'BAD_USER_INPUT',
+            argumentName: 'id',
           },
-          data: data,
-          deletion: false,
         },
-      ],
-      message: message,
-    })
-
-    return {
-      ref: commit.ref,
-    }
-  }
-
-  public async updateByTypeId(
-    gitAdapter: GitAdapter,
-    branch: string,
-    commitHash: string,
-    type: string,
-    id: string,
-    data: Entry,
-    message: string,
-  ): Promise<CommitResult> {
-    const allEntries = await gitAdapter.getContentEntries(commitHash)
-    const requestedEntry = allEntries.filter(
-      (contentEntry: ContentEntry) => contentEntry.id === id,
-    )[0]
-    if (requestedEntry === undefined || requestedEntry.metadata.type !== type) {
-      throw new Error(`Not found: ${type}, ${id}`)
-    }
-
-    const newData: Entry = { ...requestedEntry.data, ...data }
-
-    const commit = await gitAdapter.createCommit({
-      ref: branch,
-      parentSha: commitHash,
-      contentEntries: [
-        {
-          id: id,
-          metadata: requestedEntry.metadata,
-          data: newData,
-          deletion: false,
-        },
-      ],
-      message: message,
-    })
-
-    return {
-      ref: commit.ref,
-    }
-  }
-
-  public async deleteByTypeId(
-    gitAdapter: GitAdapter,
-    branch: string,
-    commitHash: string,
-    type: string,
-    id: string,
-    message: string,
-  ): Promise<CommitResult> {
-    const allEntries = await gitAdapter.getContentEntries(commitHash)
-    const requestedEntry = allEntries.filter(
-      (contentEntry: ContentEntry) => contentEntry.id === id,
-    )[0]
-    if (requestedEntry === undefined || requestedEntry.metadata.type !== type) {
-      throw new Error(`Not found: ${type}, ${id}`)
+      )
     }
 
-    const commit = await gitAdapter.createCommit({
-      ref: branch,
-      parentSha: commitHash,
-      contentEntries: [
-        {
-          id: id,
-          metadata: requestedEntry.metadata,
-          data: {},
-          deletion: true,
-        },
-      ],
-      message: message,
-    })
-
-    return {
-      ref: commit.ref,
-    }
+    return requestedEntry
   }
 }
 

package/dist/graphql/resolver-generators/entry-reference-resolver.generator.d.ts

@@ -1,12 +0,0 @@
-import { GraphQLField, GraphQLObjectType } from 'graphql';
-import { Entry, PersistenceService } from '../../persistence/persistence.service';
-import { ApolloContext } from '../../app/api.service';
-import { GraphQLFieldResolver } from 'graphql/type/definition';
-export declare class EntryReferenceResolverGenerator {
-    private readonly persistence;
-    constructor(persistence: PersistenceService);
-    createResolver(context: ApolloContext, obj: {
-        type: GraphQLObjectType;
-        fields: GraphQLField<any, any>[];
-    }): Record<string, GraphQLFieldResolver<Record<string, any>, ApolloContext, any, Promise<Entry | Entry[] | null>>>;
-}

package/dist/graphql/resolver-generators/entry-reference-resolver.generator.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntryReferenceResolverGenerator = void 0;
-class EntryReferenceResolverGenerator {
-    constructor(persistence) {
-        this.persistence = persistence;
-    }
-    createResolver(context, obj) {
-        const persistence = this.persistence;
-        const fieldResolvers = {};
-        for (const field of obj.fields) {
-            const fieldName = field.name;
-            fieldResolvers[fieldName] = async (source, args, context, info) => {
-                if (source[fieldName] === undefined || source[fieldName] === null) {
-                    return null;
-                }
-                if (Array.isArray(source[fieldName])) {
-                    return source[fieldName].map((el) => persistence.findById(context.gitAdapter, context.getCurrentRef(), el.id));
-                }
-                else {
-                    return persistence.findById(context.gitAdapter, context.getCurrentRef(), source[fieldName].id);
-                }
-            };
-        }
-        return fieldResolvers;
-    }
-}
-exports.EntryReferenceResolverGenerator = EntryReferenceResolverGenerator;
-//# sourceMappingURL=entry-reference-resolver.generator.js.map

package/dist/graphql/resolver-generators/entry-reference-resolver.generator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-reference-resolver.generator.js","sourceRoot":"","sources":["../../../src/graphql/resolver-generators/entry-reference-resolver.generator.ts"],"names":[],"mappings":";;;AAQA,MAAa,+BAA+B;IAC1C,YAA6B,WAA+B;QAA/B,gBAAW,GAAX,WAAW,CAAoB;IAAG,CAAC;IAEzD,cAAc,CACnB,OAAsB,EACtB,GAGC;QAUD,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAA;QAEpC,MAAM,cAAc,GAQhB,EAAE,CAAA;QAEN,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE;YAC9B,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;YAC5B,cAAc,CAAC,SAAS,CAAC,GAAG,KAAK,EAC/B,MAAM,EACN,IAAI,EACJ,OAAO,EACP,IAAI,EAC6B,EAAE;gBACnC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,SAAS,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;oBACjE,OAAO,IAAI,CAAA;iBACZ;gBAED,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE;oBACpC,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,EAAO,EAAE,EAAE,CACvC,WAAW,CAAC,QAAQ,CAClB,OAAO,CAAC,UAAU,EAClB,OAAO,CAAC,aAAa,EAAE,EACvB,EAAE,CAAC,EAAE,CACN,CACF,CAAA;iBACF;qBAAM;oBACL,OAAO,WAAW,CAAC,QAAQ,CACzB,OAAO,CAAC,UAAU,EAClB,OAAO,CAAC,aAAa,EAAE,EACvB,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,CACrB,CAAA;iBACF;YACH,CAAC,CAAA;SACF;QAED,OAAO,cAAc,CAAA;IACvB,CAAC;CACF;AA9DD,0EA8DC"}

package/dist/graphql/resolver-generators/mutation-update.resolver-generator.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MutationUpdateResolverGenerator = void 0;
-const GraphQLError_1 = require("graphql/error/GraphQLError");
-class MutationUpdateResolverGenerator {
-    constructor(persistence) {
-        this.persistence = persistence;
-    }
-    createResolver(typeName) {
-        return async (source, args, context, info) => {
-            try {
-                await this.persistence.findByTypeId(context.gitAdapter, context.getCurrentRef(), typeName, args.id);
-            }
-            catch (_) {
-                throw new GraphQLError_1.GraphQLError(`No entry of type "${typeName}" with id "${args.id}" exists`, {
-                    extensions: {
-                        code: 'BAD_USER_INPUT',
-                        argumentName: 'id',
-                    },
-                });
-            }
-            const updateResult = await this.persistence.updateByTypeId(context.gitAdapter, context.branch, context.getCurrentRef(), typeName, args.id, args.data, args.message);
-            context.setCurrentRef(updateResult.ref);
-            return this.persistence.findByTypeId(context.gitAdapter, context.getCurrentRef(), typeName, args.id);
-        };
-    }
-}
-exports.MutationUpdateResolverGenerator = MutationUpdateResolverGenerator;
-//# sourceMappingURL=mutation-update.resolver-generator.js.map

package/dist/graphql/resolver-generators/mutation-update.resolver-generator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutation-update.resolver-generator.js","sourceRoot":"","sources":["../../../src/graphql/resolver-generators/mutation-update.resolver-generator.ts"],"names":[],"mappings":";;;AAMA,6DAAyD;AAEzD,MAAa,+BAA+B;IAC1C,YAA6B,WAA+B;QAA/B,gBAAW,GAAX,WAAW,CAAoB;IAAG,CAAC;IAEzD,cAAc,CACnB,QAAgB;QAEhB,OAAO,KAAK,EACV,MAAM,EACN,IAAI,EACJ,OAAsB,EACtB,IAAI,EACY,EAAE;YAClB,IAAI;gBACF,MAAM,IAAI,CAAC,WAAW,CAAC,YAAY,CACjC,OAAO,CAAC,UAAU,EAClB,OAAO,CAAC,aAAa,EAAE,EACvB,QAAQ,EACR,IAAI,CAAC,EAAE,CACR,CAAA;aACF;YAAC,OAAO,CAAC,EAAE;gBACV,MAAM,IAAI,2BAAY,CACpB,qBAAqB,QAAQ,cAAc,IAAI,CAAC,EAAE,UAAU,EAC5D;oBACE,UAAU,EAAE;wBACV,IAAI,EAAE,gBAAgB;wBACtB,YAAY,EAAE,IAAI;qBACnB;iBACF,CACF,CAAA;aACF;YAGD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CACxD,OAAO,CAAC,UAAU,EAClB,OAAO,CAAC,MAAM,EACd,OAAO,CAAC,aAAa,EAAE,EACvB,QAAQ,EACR,IAAI,CAAC,EAAE,EACP,IAAI,CAAC,IAAI,EACT,IAAI,CAAC,OAAO,CACb,CAAA;YACD,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAA;YACvC,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,CAClC,OAAO,CAAC,UAAU,EAClB,OAAO,CAAC,aAAa,EAAE,EACvB,QAAQ,EACR,IAAI,CAAC,EAAE,CACR,CAAA;QACH,CAAC,CAAA;IACH,CAAC;CACF;AAlDD,0EAkDC"}

package/dist/graphql/resolver-generators/union-value-resolver-generator.d.ts

@@ -1,13 +0,0 @@
-import { GraphQLFieldResolver } from 'graphql/type/definition';
-import { ApolloContext } from '../../app/api.service';
-import { Entry } from '../../persistence/persistence.service';
-import { GraphQLSchema } from 'graphql';
-import { EntryReferenceUtil } from '../schema-utils/entry-reference-util';
-export declare class UnionValueResolverGenerator {
-    private readonly entryReferenceUtil;
-    constructor(entryReferenceUtil: EntryReferenceUtil);
-    createResolver(schema: GraphQLSchema): Record<string, Record<string, GraphQLFieldResolver<any, ApolloContext, any, Entry | null>>>;
-    private getFieldsWithUnionTypeNotUsingEntryTypes;
-    private buildsOnUnionType;
-    private collapseTypeField;
-}

package/dist/graphql/resolver-generators/union-value-resolver-generator.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnionValueResolverGenerator = void 0;
-const definition_1 = require("graphql/type/definition");
-const graphql_1 = require("graphql");
-const type_1 = require("graphql/type");
-class UnionValueResolverGenerator {
-    constructor(entryReferenceUtil) {
-        this.entryReferenceUtil = entryReferenceUtil;
-    }
-    createResolver(schema) {
-        var _a;
-        const resolvers = {};
-        for (const typeName of Object.keys(schema.getTypeMap())) {
-            const type = schema.getType(typeName);
-            if (!type || ((_a = type.astNode) === null || _a === void 0 ? void 0 : _a.kind) !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
-                continue;
-            }
-            const objectType = type;
-            const unionFieldsNotUsingEntry = this.getFieldsWithUnionTypeNotUsingEntryTypes(objectType);
-            const fieldResolvers = {};
-            for (const field of unionFieldsNotUsingEntry) {
-                fieldResolvers[field.name] = (obj, args, context, info) => {
-                    const fieldValue = obj[info.fieldName];
-                    return this.collapseTypeField(field.type, fieldValue);
-                };
-            }
-            if (Object.keys(fieldResolvers).length > 0) {
-                resolvers[typeName] = fieldResolvers;
-            }
-        }
-        return resolvers;
-    }
-    getFieldsWithUnionTypeNotUsingEntryTypes(objectType) {
-        const fields = [];
-        for (const fieldsKey in objectType.getFields()) {
-            const field = objectType.getFields()[fieldsKey];
-            if (this.buildsOnUnionType(field.type) &&
-                !this.entryReferenceUtil.buildsOnTypeWithEntryDirective(field.type)) {
-                fields.push(field);
-            }
-        }
-        return fields;
-    }
-    buildsOnUnionType(type) {
-        if (type instanceof type_1.GraphQLNonNull) {
-            return this.buildsOnUnionType(type.ofType);
-        }
-        else if (type instanceof type_1.GraphQLList) {
-            return this.buildsOnUnionType(type.ofType);
-        }
-        else if (type instanceof definition_1.GraphQLUnionType) {
-            return true;
-        }
-        else if (type instanceof type_1.GraphQLObjectType) {
-            return false;
-        }
-        return false;
-    }
-    collapseTypeField(type, fieldValue) {
-        if (type instanceof type_1.GraphQLNonNull) {
-            return this.collapseTypeField(type.ofType, fieldValue);
-        }
-        else if (fieldValue === null) {
-            return null;
-        }
-        else if (type instanceof type_1.GraphQLList) {
-            if (!Array.isArray(fieldValue)) {
-                throw new Error('Expected array value');
-            }
-            return fieldValue.map((item) => this.collapseTypeField(type.ofType, item));
-        }
-        else {
-            const firstKey = Object.keys(fieldValue)[0];
-            if (Array.isArray(fieldValue)) {
-                throw new Error('Did not expect array value');
-            }
-            return Object.assign(Object.assign({}, fieldValue[firstKey]), { __typename: firstKey.slice(0, 1).toUpperCase() + firstKey.slice(1) });
-        }
-    }
-}
-exports.UnionValueResolverGenerator = UnionValueResolverGenerator;
-//# sourceMappingURL=union-value-resolver-generator.js.map