@wundergraph/composition 0.36.0 → 0.37.0

package/dist/utils/utils.d.ts

@@ -1,20 +1,13 @@
-import { ConstDirectiveNode, FieldDefinitionNode, Kind } from 'graphql';
-import { EnumTypeNode, InterfaceTypeNode, ObjectTypeNode, ScalarTypeNode } from '../ast/utils';
-import { FieldConfiguration } from '../router-configuration/router-configuration';
-import { FieldData } from '../schema-building/type-definition-data';
+import { ConstDirectiveNode, Kind } from 'graphql/index';
+import { SimpleFieldData } from '../schema-building/types';
 export declare function areSetsEqual<T>(set: Set<T>, other: Set<T>): boolean;
 export declare function getAllMutualEntries<T>(set: Set<T>, other: Set<T>): Set<T>;
 export declare function getOrThrowError<K, V>(map: Map<K, V>, key: K, mapName: string): V;
 export declare function getAllSetDisparities<T>(set: Set<T>, other: Set<T>): T[];
 export declare function getEntriesNotInHashSet<T>(iterable: Iterable<T>, comparison: Set<T> | Map<T, any>): T[];
-export declare function doSetsIntersect<T>(set: Set<T>, other: Set<T>): boolean;
-export declare function subtractSourceSetFromTargetSet<T>(source: Set<T>, target: Set<T>): void;
-export declare function mapToArrayOfValues<K, V>(map: Map<K, V>): V[];
 export declare function numberToOrdinal(num: number): string;
 export declare function addIterableValuesToSet<T>(source: T[] | Iterable<T>, target: Set<T>): void;
-export declare function addSetsAndReturnMutationBoolean<T>(source: Set<T>, target: Set<T>): boolean;
 export declare function kindToTypeString(kind: Kind): string;
-export declare function kindToConvertedTypeString(kind: Kind): string;
 export type InvalidArgumentImplementation = {
     actualType: string;
     argumentName: string;
@@ -32,6 +25,14 @@ export type ImplementationErrors = {
     invalidFieldImplementations: Map<string, InvalidFieldImplementation>;
     unimplementedFields: string[];
 };
+export declare function getValueOrDefault<K, V>(map: Map<K, V>, key: K, constructor: () => V): V;
+export type GraphFieldData = {
+    name: string;
+    namedTypeName: string;
+    isLeaf: boolean;
+    subgraphNames: Set<string>;
+};
+export declare function add<T>(set: Set<T>, key: T): boolean;
 export type InvalidRequiredInputValueData = {
     inputValueName: string;
     missingSubgraphs: string[];
@@ -43,26 +44,6 @@ export type InvalidArgument = {
     typeName: string;
     typeString: string;
 };
-export type SimpleFieldData = {
-    name: string;
-    namedTypeName: string;
-};
-export declare function fieldDatasToSimpleFieldDatas(fieldDatas: IterableIterator<FieldData>): Array<SimpleFieldData>;
-export declare function isNodeLeaf(kind?: Kind): boolean;
-export type GraphFieldData = {
-    name: string;
-    namedTypeName: string;
-    isLeaf: boolean;
-    subgraphNames: Set<string>;
-};
-export type EntityInterfaceSubgraphData = {
-    fieldDatas: Array<SimpleFieldData>;
-    interfaceFieldNames: Set<string>;
-    interfaceObjectFieldNames: Set<string>;
-    isInterfaceObject: boolean;
-    typeName: string;
-    concreteTypeNames?: Set<string>;
-};
 export type EntityInterfaceFederationData = {
     fieldDatasBySubgraphName: Map<string, Array<SimpleFieldData>>;
     interfaceFieldNames: Set<string>;
@@ -71,54 +52,9 @@ export type EntityInterfaceFederationData = {
     typeName: string;
     concreteTypeNames?: Set<string>;
 };
-export declare function newEntityInterfaceFederationData(entityInterfaceData: EntityInterfaceSubgraphData, subgraphName: string): EntityInterfaceFederationData;
-export declare function upsertEntityInterfaceFederationData(federationData: EntityInterfaceFederationData, subgraphData: EntityInterfaceSubgraphData, subgraphName: string): boolean;
 export type InvalidEntityInterface = {
     subgraphName: string;
     concreteTypeNames: Set<string>;
 };
-export declare function getValueOrDefault<K, V>(map: Map<K, V>, key: K, constructor: () => V): V;
-export type EntityData = {
-    fieldNames: Set<string>;
-    keyFieldSets: Set<string>;
-    subgraphNames: Set<string>;
-    typeName: string;
-};
-export type EntityDataParams = {
-    typeName: string;
-    fieldNames?: Iterable<string>;
-    keyFieldSets?: Iterable<string>;
-    subgraphNames?: Iterable<string>;
-};
-export declare function newEntityData(params: EntityDataParams): EntityData;
-export declare function upsertEntityDataProperties(entityDataByTypeName: Map<string, EntityData>, params: EntityDataParams): void;
-export declare function upsertEntityData(entityDataByTypeName: Map<string, EntityData>, incomingData: EntityData): void;
-export type FieldAuthorizationData = {
-    fieldName: string;
-    requiresAuthentication: boolean;
-    requiredScopes: Set<string>[];
-};
-export declare function newFieldAuthorizationData(fieldName: string): FieldAuthorizationData;
-export type AuthorizationData = {
-    fieldAuthorizationDataByFieldName: Map<string, FieldAuthorizationData>;
-    hasParentLevelAuthorization: boolean;
-    requiresAuthentication: boolean;
-    requiredScopes: Set<string>[];
-    typeName: string;
-};
-export declare function resetAuthorizationData(authorizationData?: AuthorizationData): void;
-export declare function getAuthorizationDataToUpdate(authorizationContainer: AuthorizationData, node: EnumTypeNode | FieldDefinitionNode | InterfaceTypeNode | ObjectTypeNode | ScalarTypeNode): AuthorizationData | FieldAuthorizationData;
-export declare function newAuthorizationData(typeName: string): AuthorizationData;
-export declare const maxOrScopes = 16;
-export declare function mergeAuthorizationDataByAND(source: AuthorizationData | FieldAuthorizationData, target: AuthorizationData | FieldAuthorizationData): boolean;
-export declare function upsertFieldAuthorizationData(fieldAuthorizationDataByFieldName: Map<string, FieldAuthorizationData>, incomingFieldAuthorizationData: FieldAuthorizationData): boolean;
-export declare function upsertAuthorizationData(authorizationDataByParentTypeName: Map<string, AuthorizationData>, incomingAuthorizationData: AuthorizationData, invalidOrScopesFieldPaths: Set<string>): void;
-export declare function upsertAuthorizationConfiguration(fieldConfigurationByFieldPath: Map<string, FieldConfiguration>, authorizationData: AuthorizationData): void;
-export declare function setAndGetValue<K, V>(map: Map<K, V>, key: K, value: V): V;
 export declare function generateSimpleDirective(name: string): ConstDirectiveNode;
 export declare function generateRequiresScopesDirective(orScopes: Set<string>[]): ConstDirectiveNode;
-export declare function isNodeKindInterface(kind: Kind): kind is Kind.INTERFACE_TYPE_DEFINITION | Kind.INTERFACE_TYPE_EXTENSION;
-export declare function isNodeKindObject(kind: Kind): kind is Kind.OBJECT_TYPE_DEFINITION | Kind.OBJECT_TYPE_EXTENSION;
-export declare function addMapEntries<K, V>(source: Map<K, V>, target: Map<K, V>): void;
-export declare function getSingleSetEntry<T>(set: Set<T>): T | undefined;
-export declare function add<T>(set: Set<T>, key: T): boolean;

package/dist/utils/utils.js

@@ -1,44 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maxOrScopes = void 0;
 exports.areSetsEqual = areSetsEqual;
 exports.getAllMutualEntries = getAllMutualEntries;
 exports.getOrThrowError = getOrThrowError;
 exports.getAllSetDisparities = getAllSetDisparities;
 exports.getEntriesNotInHashSet = getEntriesNotInHashSet;
-exports.doSetsIntersect = doSetsIntersect;
-exports.subtractSourceSetFromTargetSet = subtractSourceSetFromTargetSet;
-exports.mapToArrayOfValues = mapToArrayOfValues;
 exports.numberToOrdinal = numberToOrdinal;
 exports.addIterableValuesToSet = addIterableValuesToSet;
-exports.addSetsAndReturnMutationBoolean = addSetsAndReturnMutationBoolean;
 exports.kindToTypeString = kindToTypeString;
-exports.kindToConvertedTypeString = kindToConvertedTypeString;
-exports.fieldDatasToSimpleFieldDatas = fieldDatasToSimpleFieldDatas;
-exports.isNodeLeaf = isNodeLeaf;
-exports.newEntityInterfaceFederationData = newEntityInterfaceFederationData;
-exports.upsertEntityInterfaceFederationData = upsertEntityInterfaceFederationData;
 exports.getValueOrDefault = getValueOrDefault;
-exports.newEntityData = newEntityData;
-exports.upsertEntityDataProperties = upsertEntityDataProperties;
-exports.upsertEntityData = upsertEntityData;
-exports.newFieldAuthorizationData = newFieldAuthorizationData;
-exports.resetAuthorizationData = resetAuthorizationData;
-exports.getAuthorizationDataToUpdate = getAuthorizationDataToUpdate;
-exports.newAuthorizationData = newAuthorizationData;
-exports.mergeAuthorizationDataByAND = mergeAuthorizationDataByAND;
-exports.upsertFieldAuthorizationData = upsertFieldAuthorizationData;
-exports.upsertAuthorizationData = upsertAuthorizationData;
-exports.upsertAuthorizationConfiguration = upsertAuthorizationConfiguration;
-exports.setAndGetValue = setAndGetValue;
+exports.add = add;
 exports.generateSimpleDirective = generateSimpleDirective;
 exports.generateRequiresScopesDirective = generateRequiresScopesDirective;
-exports.isNodeKindInterface = isNodeKindInterface;
-exports.isNodeKindObject = isNodeKindObject;
-exports.addMapEntries = addMapEntries;
-exports.getSingleSetEntry = getSingleSetEntry;
-exports.add = add;
-const graphql_1 = require("graphql");
+const index_1 = require("graphql/index");
 const string_constants_1 = require("./string-constants");
 const errors_1 = require("../errors/errors");
 const utils_1 = require("../ast/utils");
@@ -91,26 +65,6 @@ function getEntriesNotInHashSet(iterable, comparison) {
     }
     return disparities;
 }
-function doSetsIntersect(set, other) {
-    for (const entry of set) {
-        if (other.has(entry)) {
-            return true;
-        }
-    }
-    return false;
-}
-function subtractSourceSetFromTargetSet(source, target) {
-    for (const entry of source) {
-        target.delete(entry);
-    }
-}
-function mapToArrayOfValues(map) {
-    const output = [];
-    for (const value of map.values()) {
-        output.push(value);
-    }
-    return output;
-}
 function numberToOrdinal(num) {
     const numString = num.toString();
     const lastNumber = numString[numString.length - 1];
@@ -130,223 +84,76 @@ function addIterableValuesToSet(source, target) {
         target.add(value);
     }
 }
-function addSetsAndReturnMutationBoolean(source, target) {
-    let wasMutated = false;
-    for (const entry of source) {
-        if (target.has(entry)) {
-            continue;
-        }
-        wasMutated = true;
-        target.add(entry);
-    }
-    return wasMutated;
-}
 function kindToTypeString(kind) {
     switch (kind) {
-        case graphql_1.Kind.BOOLEAN: {
+        case index_1.Kind.BOOLEAN: {
             return string_constants_1.BOOLEAN_SCALAR;
         }
-        case graphql_1.Kind.ENUM:
+        case index_1.Kind.ENUM:
         // intentional fallthrough
-        case graphql_1.Kind.ENUM_TYPE_DEFINITION: {
+        case index_1.Kind.ENUM_TYPE_DEFINITION: {
             return string_constants_1.ENUM;
         }
-        case graphql_1.Kind.ENUM_TYPE_EXTENSION: {
+        case index_1.Kind.ENUM_TYPE_EXTENSION: {
             return 'Enum extension';
         }
-        case graphql_1.Kind.ENUM_VALUE_DEFINITION: {
+        case index_1.Kind.ENUM_VALUE_DEFINITION: {
             return string_constants_1.ENUM_VALUE;
         }
-        case graphql_1.Kind.FIELD_DEFINITION: {
+        case index_1.Kind.FIELD_DEFINITION: {
             return string_constants_1.FIELD;
         }
-        case graphql_1.Kind.FLOAT: {
+        case index_1.Kind.FLOAT: {
             return string_constants_1.FLOAT_SCALAR;
         }
-        case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
+        case index_1.Kind.INPUT_OBJECT_TYPE_DEFINITION: {
             return string_constants_1.INPUT_OBJECT;
         }
-        case graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
+        case index_1.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
             return 'Input Object extension';
         }
-        case graphql_1.Kind.INPUT_VALUE_DEFINITION: {
+        case index_1.Kind.INPUT_VALUE_DEFINITION: {
             return string_constants_1.INPUT_VALUE;
         }
-        case graphql_1.Kind.INT: {
+        case index_1.Kind.INT: {
             return string_constants_1.INT_SCALAR;
         }
-        case graphql_1.Kind.INTERFACE_TYPE_DEFINITION: {
+        case index_1.Kind.INTERFACE_TYPE_DEFINITION: {
             return string_constants_1.INTERFACE;
         }
-        case graphql_1.Kind.INTERFACE_TYPE_EXTENSION: {
+        case index_1.Kind.INTERFACE_TYPE_EXTENSION: {
             return 'Interface extension';
         }
-        case graphql_1.Kind.NULL: {
+        case index_1.Kind.NULL: {
             return string_constants_1.NULL;
         }
-        case graphql_1.Kind.OBJECT:
+        case index_1.Kind.OBJECT:
         // intentional fallthrough
-        case graphql_1.Kind.OBJECT_TYPE_DEFINITION: {
+        case index_1.Kind.OBJECT_TYPE_DEFINITION: {
             return string_constants_1.OBJECT;
         }
-        case graphql_1.Kind.OBJECT_TYPE_EXTENSION: {
+        case index_1.Kind.OBJECT_TYPE_EXTENSION: {
             return 'Object extension';
         }
-        case graphql_1.Kind.STRING: {
+        case index_1.Kind.STRING: {
             return string_constants_1.STRING_SCALAR;
         }
-        case graphql_1.Kind.SCALAR_TYPE_DEFINITION: {
+        case index_1.Kind.SCALAR_TYPE_DEFINITION: {
             return string_constants_1.SCALAR;
         }
-        case graphql_1.Kind.SCALAR_TYPE_EXTENSION: {
+        case index_1.Kind.SCALAR_TYPE_EXTENSION: {
             return 'Scalar extension';
         }
-        case graphql_1.Kind.UNION_TYPE_DEFINITION: {
+        case index_1.Kind.UNION_TYPE_DEFINITION: {
             return string_constants_1.UNION;
         }
-        case graphql_1.Kind.UNION_TYPE_EXTENSION: {
+        case index_1.Kind.UNION_TYPE_EXTENSION: {
             return 'Union extension';
         }
         default:
             return kind;
     }
 }
-function kindToConvertedTypeString(kind) {
-    switch (kind) {
-        case graphql_1.Kind.BOOLEAN: {
-            return string_constants_1.BOOLEAN_SCALAR;
-        }
-        case graphql_1.Kind.ENUM:
-        // intentional fallthrough
-        case graphql_1.Kind.ENUM_TYPE_DEFINITION:
-        // intentional fallthrough
-        case graphql_1.Kind.ENUM_TYPE_EXTENSION: {
-            return string_constants_1.ENUM;
-        }
-        case graphql_1.Kind.ENUM_VALUE_DEFINITION: {
-            return string_constants_1.ENUM_VALUE;
-        }
-        case graphql_1.Kind.FIELD_DEFINITION: {
-            return string_constants_1.FIELD;
-        }
-        case graphql_1.Kind.FLOAT: {
-            return string_constants_1.FLOAT_SCALAR;
-        }
-        case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-        // intentional fallthrough
-        case graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
-            return string_constants_1.INPUT_OBJECT;
-        }
-        case graphql_1.Kind.INPUT_VALUE_DEFINITION: {
-            return string_constants_1.INPUT_VALUE;
-        }
-        case graphql_1.Kind.INT: {
-            return string_constants_1.INT_SCALAR;
-        }
-        case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-        // intentional fallthrough
-        case graphql_1.Kind.INTERFACE_TYPE_EXTENSION: {
-            return string_constants_1.INTERFACE;
-        }
-        case graphql_1.Kind.NULL: {
-            return string_constants_1.NULL;
-        }
-        case graphql_1.Kind.OBJECT:
-        // intentional fallthrough
-        case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-        // intentional fallthrough
-        case graphql_1.Kind.OBJECT_TYPE_EXTENSION: {
-            return string_constants_1.OBJECT;
-        }
-        case graphql_1.Kind.STRING: {
-            return string_constants_1.STRING_SCALAR;
-        }
-        case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
-        // intentional fallthrough
-        case graphql_1.Kind.SCALAR_TYPE_EXTENSION: {
-            return string_constants_1.SCALAR;
-        }
-        case graphql_1.Kind.UNION_TYPE_DEFINITION:
-        // intentional fallthrough
-        case graphql_1.Kind.UNION_TYPE_EXTENSION: {
-            return string_constants_1.UNION;
-        }
-        default:
-            return kind;
-    }
-}
-function fieldDatasToSimpleFieldDatas(fieldDatas) {
-    const simpleFieldDatas = [];
-    for (const { name, namedTypeName } of fieldDatas) {
-        simpleFieldDatas.push({ name, namedTypeName });
-    }
-    return simpleFieldDatas;
-}
-// Only used to assess the output type of field definitions for graph selection set rendering
-function isNodeLeaf(kind) {
-    // Base scalars are not added to parent definition data
-    if (!kind) {
-        return true;
-    }
-    switch (kind) {
-        case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
-        case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
-        case graphql_1.Kind.UNION_TYPE_DEFINITION:
-            return false;
-        default:
-            return true;
-    }
-}
-function newEntityInterfaceFederationData(entityInterfaceData, subgraphName) {
-    return {
-        fieldDatasBySubgraphName: new Map().set(subgraphName, entityInterfaceData.fieldDatas),
-        interfaceFieldNames: new Set(entityInterfaceData.interfaceFieldNames),
-        interfaceObjectFieldNames: new Set(entityInterfaceData.interfaceObjectFieldNames),
-        interfaceObjectSubgraphs: new Set(entityInterfaceData.isInterfaceObject ? [subgraphName] : []),
-        typeName: entityInterfaceData.typeName,
-        ...(entityInterfaceData.isInterfaceObject
-            ? {}
-            : { concreteTypeNames: new Set(entityInterfaceData.concreteTypeNames) }),
-    };
-}
-// Returns true if the federation data concrete types set was mutated and false otherwise
-function upsertEntityInterfaceFederationData(federationData, subgraphData, subgraphName) {
-    federationData.fieldDatasBySubgraphName.set(subgraphName, subgraphData.fieldDatas);
-    addIterableValuesToSet(subgraphData.interfaceFieldNames, federationData.interfaceFieldNames);
-    addIterableValuesToSet(subgraphData.interfaceObjectFieldNames, federationData.interfaceObjectFieldNames);
-    // interface objects should not define any concrete types
-    if (subgraphData.isInterfaceObject) {
-        federationData.interfaceObjectSubgraphs.add(subgraphName);
-        return false;
-    }
-    // the concreteTypeNames set is null if only interfaceObjects have been encountered
-    if (!federationData.concreteTypeNames) {
-        federationData.concreteTypeNames = new Set(subgraphData.concreteTypeNames);
-        return false;
-    }
-    // entity interface concrete types should be consistent
-    return addSetsAndReturnMutationBoolean(subgraphData.concreteTypeNames || new Set(), federationData.concreteTypeNames);
-}
-class StackSet {
-    set = new Set();
-    stack = [];
-    constructor(value) {
-        this.push(value);
-    }
-    has(value) {
-        return this.set.has(value);
-    }
-    push(value) {
-        this.stack.push(value);
-        this.set.add(value);
-    }
-    pop() {
-        const value = this.stack.pop();
-        if (value) {
-            this.set.delete(value);
-        }
-    }
-}
 function getValueOrDefault(map, key, constructor) {
     const existingValue = map.get(key);
     if (existingValue) {
@@ -356,153 +163,16 @@ function getValueOrDefault(map, key, constructor) {
     map.set(key, value);
     return value;
 }
-function newEntityData(params) {
-    return {
-        fieldNames: new Set(params.fieldNames),
-        keyFieldSets: new Set(params.keyFieldSets),
-        subgraphNames: new Set(params.subgraphNames),
-        typeName: params.typeName,
-    };
-}
-function addEntityDataProperties(source, target) {
-    addIterableValuesToSet(source.fieldNames || [], target.fieldNames);
-    addIterableValuesToSet(source.keyFieldSets || [], target.keyFieldSets);
-    addIterableValuesToSet(source.subgraphNames || [], target.subgraphNames);
-}
-function upsertEntityDataProperties(entityDataByTypeName, params) {
-    const existingData = entityDataByTypeName.get(params.typeName);
-    existingData
-        ? addEntityDataProperties(params, existingData)
-        : entityDataByTypeName.set(params.typeName, newEntityData(params));
-}
-function upsertEntityData(entityDataByTypeName, incomingData) {
-    const existingData = entityDataByTypeName.get(incomingData.typeName);
-    existingData
-        ? addEntityDataProperties(incomingData, existingData)
-        : entityDataByTypeName.set(incomingData.typeName, incomingData);
-}
-function newFieldAuthorizationData(fieldName) {
-    return {
-        fieldName,
-        requiresAuthentication: false,
-        requiredScopes: [],
-    };
-}
-function resetAuthorizationData(authorizationData) {
-    if (!authorizationData) {
-        return;
-    }
-    authorizationData.requiresAuthentication = false;
-    authorizationData.requiredScopes = [];
-    authorizationData.hasParentLevelAuthorization = false;
-}
-function getAuthorizationDataToUpdate(authorizationContainer, node) {
-    if (node.kind === graphql_1.Kind.FIELD_DEFINITION) {
-        const name = node.name.value;
-        return getValueOrDefault(authorizationContainer.fieldAuthorizationDataByFieldName, name, () => newFieldAuthorizationData(name));
-    }
-    authorizationContainer.hasParentLevelAuthorization = true;
-    return authorizationContainer;
-}
-function newAuthorizationData(typeName) {
-    return {
-        fieldAuthorizationDataByFieldName: new Map(),
-        hasParentLevelAuthorization: false,
-        requiresAuthentication: false,
-        requiredScopes: [],
-        typeName,
-    };
-}
-exports.maxOrScopes = 16;
-function mergeAuthorizationDataByAND(source, target) {
-    target.requiresAuthentication ||= source.requiresAuthentication;
-    const sourceScopesLength = source.requiredScopes.length;
-    if (sourceScopesLength < 1) {
-        return true;
-    }
-    const targetScopesLength = target.requiredScopes.length;
-    if (targetScopesLength < 1) {
-        if (sourceScopesLength > exports.maxOrScopes) {
-            return false;
-        }
-        for (const andScopes of source.requiredScopes) {
-            target.requiredScopes.push(new Set(andScopes));
-        }
-        return true;
-    }
-    if (sourceScopesLength * targetScopesLength > exports.maxOrScopes) {
+function add(set, key) {
+    if (set.has(key)) {
         return false;
     }
-    const mergedOrScopes = [];
-    for (const existingAndScopes of target.requiredScopes) {
-        for (const incomingAndScopes of source.requiredScopes) {
-            const newAndScopes = new Set(existingAndScopes);
-            addIterableValuesToSet(incomingAndScopes, newAndScopes);
-            mergedOrScopes.push(newAndScopes);
-        }
-    }
-    target.requiredScopes = mergedOrScopes;
+    set.add(key);
     return true;
 }
-function upsertFieldAuthorizationData(fieldAuthorizationDataByFieldName, incomingFieldAuthorizationData) {
-    const fieldName = incomingFieldAuthorizationData.fieldName;
-    const existingFieldAuthorizationData = fieldAuthorizationDataByFieldName.get(fieldName);
-    if (!existingFieldAuthorizationData) {
-        if (incomingFieldAuthorizationData.requiredScopes.length > exports.maxOrScopes) {
-            return false;
-        }
-        const fieldAuthorizationData = newFieldAuthorizationData(fieldName);
-        fieldAuthorizationData.requiresAuthentication ||= incomingFieldAuthorizationData.requiresAuthentication;
-        for (const andScopes of incomingFieldAuthorizationData.requiredScopes) {
-            fieldAuthorizationData.requiredScopes.push(new Set(andScopes));
-        }
-        fieldAuthorizationDataByFieldName.set(fieldName, fieldAuthorizationData);
-        return true;
-    }
-    existingFieldAuthorizationData.requiresAuthentication ||= incomingFieldAuthorizationData.requiresAuthentication;
-    return mergeAuthorizationDataByAND(incomingFieldAuthorizationData, existingFieldAuthorizationData);
-}
-function upsertAuthorizationData(authorizationDataByParentTypeName, incomingAuthorizationData, invalidOrScopesFieldPaths) {
-    const existingAuthorizationData = authorizationDataByParentTypeName.get(incomingAuthorizationData.typeName);
-    if (!existingAuthorizationData) {
-        authorizationDataByParentTypeName.set(incomingAuthorizationData.typeName, incomingAuthorizationData);
-        return;
-    }
-    for (const [fieldName, fieldAuthorizationData] of incomingAuthorizationData.fieldAuthorizationDataByFieldName) {
-        if (!upsertFieldAuthorizationData(existingAuthorizationData.fieldAuthorizationDataByFieldName, fieldAuthorizationData)) {
-            invalidOrScopesFieldPaths.add(`${incomingAuthorizationData.typeName}.${fieldName}`);
-        }
-    }
-}
-function upsertAuthorizationConfiguration(fieldConfigurationByFieldPath, authorizationData) {
-    const typeName = authorizationData.typeName;
-    for (const [fieldName, fieldAuthorizationData] of authorizationData.fieldAuthorizationDataByFieldName) {
-        const fieldPath = `${typeName}.${fieldName}`;
-        const existingFieldConfiguration = fieldConfigurationByFieldPath.get(fieldPath);
-        if (existingFieldConfiguration) {
-            existingFieldConfiguration.requiresAuthentication = fieldAuthorizationData.requiresAuthentication;
-            existingFieldConfiguration.requiredScopes = fieldAuthorizationData.requiredScopes.map((orScopes) => [
-                ...orScopes,
-            ]);
-        }
-        else {
-            fieldConfigurationByFieldPath.set(fieldPath, {
-                argumentNames: [],
-                typeName,
-                fieldName,
-                requiresAuthentication: fieldAuthorizationData.requiresAuthentication,
-                requiredScopes: fieldAuthorizationData.requiredScopes.map((orScopes) => [...orScopes]),
-            });
-        }
-    }
-}
-function setAndGetValue(map, key, value) {
-    map.set(key, value);
-    return value;
-}
 function generateSimpleDirective(name) {
     return {
-        kind: graphql_1.Kind.DIRECTIVE,
+        kind: index_1.Kind.DIRECTIVE,
         name: (0, utils_1.stringToNameNode)(name),
     };
 }
@@ -512,48 +182,25 @@ function generateRequiresScopesDirective(orScopes) {
         const scopes = [];
         for (const scope of andScopes) {
             scopes.push({
-                kind: graphql_1.Kind.STRING,
+                kind: index_1.Kind.STRING,
                 value: scope,
             });
         }
-        values.push({ kind: graphql_1.Kind.LIST, values: scopes });
+        values.push({ kind: index_1.Kind.LIST, values: scopes });
     }
     return {
-        kind: graphql_1.Kind.DIRECTIVE,
+        kind: index_1.Kind.DIRECTIVE,
         name: (0, utils_1.stringToNameNode)(string_constants_1.REQUIRES_SCOPES),
         arguments: [
             {
-                kind: graphql_1.Kind.ARGUMENT,
+                kind: index_1.Kind.ARGUMENT,
                 name: (0, utils_1.stringToNameNode)(string_constants_1.SCOPES),
                 value: {
-                    kind: graphql_1.Kind.LIST,
+                    kind: index_1.Kind.LIST,
                     values,
                 },
             },
         ],
     };
 }
-function isNodeKindInterface(kind) {
-    return kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION || kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION;
-}
-function isNodeKindObject(kind) {
-    return kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION || kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION;
-}
-function addMapEntries(source, target) {
-    for (const [key, value] of source) {
-        target.set(key, value);
-    }
-}
-function getSingleSetEntry(set) {
-    for (const entry of set) {
-        return entry;
-    }
-}
-function add(set, key) {
-    if (set.has(key)) {
-        return false;
-    }
-    set.add(key);
-    return true;
-}
 //# sourceMappingURL=utils.js.map