@wundergraph/composition 0.24.0 → 0.25.0

package/dist/federation/federation-factory.js

@@ -16,6 +16,7 @@ const utils_5 = require("../schema-building/utils");
 const walkers_1 = require("./walkers");
 const lodash_1 = require("lodash");
 const type_merging_1 = require("../schema-building/type-merging");
+const integer_constants_1 = require("../utils/integer-constants");
 class FederationFactory {
     authorizationDataByParentTypeName;
     concreteTypeNamesByAbstractTypeName;
@@ -50,6 +51,8 @@ class FederationFactory {
     potentialPersistedDirectiveDefinitionDataByDirectiveName = new Map();
     routerDefinitions = [constants_1.DEPRECATED_DEFINITION, constants_1.TAG_DEFINITION];
     shareableErrorTypeNames = new Map();
+    subscriptionFilterDataByFieldPath = new Map();
+    isMaxDepth = false;
     tagNamesByPath = new Map();
     warnings;
     constructor(authorizationDataByParentTypeName, concreteTypeNamesByAbstractTypeName, entityContainersByTypeName, entityInterfaceFederationDataByTypeName, graph, internalSubgraphBySubgraphName, warnings) {
@@ -634,12 +637,30 @@ class FederationFactory {
             this.inaccessiblePaths.add(argumentPath);
         }
     }
+    handleSubscriptionFilterDirective(incomingData, fieldPath, baseData) {
+        const subscriptionFilters = incomingData.directivesByDirectiveName.get(string_constants_1.SUBSCRIPTION_FILTER);
+        if (subscriptionFilters) {
+            // There should only be a single entry in the set
+            const subgraphName = (0, utils_3.getSingleSetEntry)(incomingData.subgraphNames);
+            if (subgraphName === undefined) {
+                this.errors.push((0, errors_1.unknownFieldSubgraphNameError)(fieldPath));
+                return;
+            }
+            // @openfed__subscriptionFilter is non-repeatable
+            this.subscriptionFilterDataByFieldPath.set(fieldPath, {
+                directive: subscriptionFilters[0],
+                fieldData: baseData || incomingData,
+                directiveSubgraphName: subgraphName,
+            });
+        }
+    }
     upsertFieldData(fieldDataByFieldName, incomingData, isParentInaccessible) {
         const fieldPath = `${incomingData.renamedParentTypeName}.${incomingData.name}`;
         (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, incomingData.namedTypeName, () => new Set()).add(fieldPath);
         this.namedOutputTypeNames.add(incomingData.namedTypeName);
         const existingData = fieldDataByFieldName.get(incomingData.name);
         const baseData = existingData || incomingData;
+        this.handleSubscriptionFilterDirective(incomingData, fieldPath, baseData);
         (0, utils_5.extractPersistedDirectives)(baseData.persistedDirectivesData, incomingData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
         const isFieldInaccessible = (0, utils_5.isNodeDataInaccessible)(incomingData);
         if (isParentInaccessible || isFieldInaccessible) {
@@ -783,6 +804,7 @@ class FederationFactory {
                             type: fieldData.type,
                         };
                         const fieldPath = `${fieldData.renamedParentTypeName}.${fieldData.name}`;
+                        this.handleSubscriptionFilterDirective(fieldData, fieldPath);
                         (0, utils_3.getValueOrDefault)(this.pathsByNamedTypeName, fieldData.namedTypeName, () => new Set()).add(fieldPath);
                         this.namedOutputTypeNames.add(fieldData.namedTypeName);
                         (0, utils_5.extractPersistedDirectives)(fieldData.persistedDirectivesData, fieldData.directivesByDirectiveName, this.persistedDirectiveDefinitionByDirectiveName);
@@ -941,7 +963,7 @@ class FederationFactory {
                 for (const [fieldName, fieldData] of data.fieldDataByFieldName) {
                     const fieldPath = `${fieldData.renamedParentTypeName}.${fieldName}`;
                     this.inaccessiblePaths.add(fieldPath);
-                    for (const [argumentName, inputValueData] of fieldData.argumentDataByArgumentName) {
+                    for (const inputValueData of fieldData.argumentDataByArgumentName.values()) {
                         this.inaccessiblePaths.add(inputValueData.renamedPath);
                     }
                 }
@@ -1327,7 +1349,7 @@ class FederationFactory {
     federateSubgraphData() {
         this.federateInternalSubgraphData();
         this.handleEntityInterfaces();
-        for (const [parentTypeName, objectExtensionData] of this.objectExtensionDataByTypeName) {
+        for (const objectExtensionData of this.objectExtensionDataByTypeName.values()) {
             this.upsertValidObjectExtensionData(objectExtensionData);
         }
         // generate the map of tag data that is used by contracts
@@ -1336,8 +1358,7 @@ class FederationFactory {
     }
     validateInterfaceImplementationsAndPushToDocumentDefinitions(interfaceImplementations) {
         for (const { data, clientSchemaFieldNodes } of interfaceImplementations) {
-            const validInterfaces = this.getValidImplementedInterfaces(data);
-            data.node.interfaces = validInterfaces;
+            data.node.interfaces = this.getValidImplementedInterfaces(data);
             this.routerDefinitions.push((0, utils_5.getNodeForRouterSchemaByData)(data, this.persistedDirectiveDefinitionByDirectiveName, this.errors));
             if ((0, utils_5.isNodeDataInaccessible)(data)) {
                 this.validateReferencesOfInaccessibleType(data);
@@ -1404,7 +1425,272 @@ class FederationFactory {
         }
         this.errors.push(errors_1.noQueryRootTypeError);
     }
+    validateSubscriptionFieldConditionFieldPath(conditionFieldPath, objectData, inputFieldPath, directiveSubgraphName, fieldErrorMessages) {
+        const paths = conditionFieldPath.split(string_constants_1.PERIOD);
+        if (paths.length < 1) {
+            fieldErrorMessages.push((0, errors_1.invalidSubscriptionFieldConditionFieldPathErrorMessage)(inputFieldPath, conditionFieldPath));
+            return [];
+        }
+        let lastData = objectData;
+        if (this.inaccessiblePaths.has(lastData.renamedTypeName)) {
+            fieldErrorMessages.push((0, errors_1.inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage)(inputFieldPath, conditionFieldPath, paths[0], lastData.renamedTypeName));
+            return [];
+        }
+        let partialConditionFieldPath = '';
+        for (let i = 0; i < paths.length; i++) {
+            const fieldName = paths[i];
+            partialConditionFieldPath += partialConditionFieldPath.length > 0 ? `.${fieldName}` : fieldName;
+            if (lastData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                fieldErrorMessages.push((0, errors_1.invalidSubscriptionFieldConditionFieldPathParentErrorMessage)(inputFieldPath, conditionFieldPath, partialConditionFieldPath));
+                return [];
+            }
+            const fieldData = lastData.fieldDataByFieldName.get(fieldName);
+            if (!fieldData) {
+                fieldErrorMessages.push((0, errors_1.undefinedSubscriptionFieldConditionFieldPathFieldErrorMessage)(inputFieldPath, conditionFieldPath, partialConditionFieldPath, fieldName, lastData.renamedTypeName));
+                return [];
+            }
+            const fieldPath = `${lastData.renamedTypeName}.${fieldName}`;
+            if (!fieldData.subgraphNames.has(directiveSubgraphName)) {
+                fieldErrorMessages.push((0, errors_1.invalidSubscriptionFieldConditionFieldPathFieldErrorMessage)(inputFieldPath, conditionFieldPath, partialConditionFieldPath, fieldPath, directiveSubgraphName));
+                return [];
+            }
+            if (constants_1.BASE_SCALARS.has(fieldData.namedTypeName)) {
+                lastData = { kind: graphql_1.Kind.SCALAR_TYPE_DEFINITION, name: fieldData.namedTypeName };
+                continue;
+            }
+            lastData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, fieldData.namedTypeName, string_constants_1.PARENT_DEFINITION_DATA);
+            if (this.inaccessiblePaths.has(fieldPath)) {
+                fieldErrorMessages.push((0, errors_1.inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage)(inputFieldPath, conditionFieldPath, partialConditionFieldPath, fieldPath));
+                return [];
+            }
+        }
+        if (!(0, utils_5.isLeafKind)(lastData.kind)) {
+            fieldErrorMessages.push((0, errors_1.nonLeafSubscriptionFieldConditionFieldPathFinalFieldErrorMessage)(inputFieldPath, conditionFieldPath, paths[paths.length - 1], (0, utils_3.kindToTypeString)(lastData.kind), lastData.name));
+            return [];
+        }
+        return paths;
+    }
+    validateSubscriptionFieldCondition(objectValueNode, condition, objectData, depth, inputPath, directiveSubgraphName, errorMessages) {
+        if (depth > integer_constants_1.MAX_SUBSCRIPTION_FILTER_DEPTH || this.isMaxDepth) {
+            errorMessages.push((0, errors_1.subscriptionFilterConditionDepthExceededErrorMessage)(inputPath));
+            this.isMaxDepth = true;
+            return false;
+        }
+        let hasErrors = false;
+        const validFieldNames = new Set([string_constants_1.FIELD_PATH, string_constants_1.VALUES]);
+        const duplicatedFieldNames = new Set();
+        const invalidFieldNames = new Set();
+        const fieldErrorMessages = [];
+        for (const objectFieldNode of objectValueNode.fields) {
+            const inputFieldName = objectFieldNode.name.value;
+            const inputFieldPath = inputPath + `.${inputFieldName}`;
+            switch (inputFieldName) {
+                case string_constants_1.FIELD_PATH: {
+                    if (validFieldNames.has(string_constants_1.FIELD_PATH)) {
+                        validFieldNames.delete(string_constants_1.FIELD_PATH);
+                    }
+                    else {
+                        hasErrors = true;
+                        duplicatedFieldNames.add(string_constants_1.FIELD_PATH);
+                        break;
+                    }
+                    if (objectFieldNode.value.kind !== graphql_1.Kind.STRING) {
+                        fieldErrorMessages.push((0, errors_1.invalidInputFieldTypeErrorMessage)(inputFieldPath, string_constants_1.STRING, (0, utils_3.kindToTypeString)(objectFieldNode.value.kind)));
+                        hasErrors = true;
+                        break;
+                    }
+                    const fieldPath = this.validateSubscriptionFieldConditionFieldPath(objectFieldNode.value.value, objectData, inputFieldPath, directiveSubgraphName, fieldErrorMessages);
+                    if (fieldPath.length < 1) {
+                        hasErrors = true;
+                        break;
+                    }
+                    condition.fieldPath = fieldPath;
+                    break;
+                }
+                case string_constants_1.VALUES: {
+                    if (validFieldNames.has(string_constants_1.VALUES)) {
+                        validFieldNames.delete(string_constants_1.VALUES);
+                    }
+                    else {
+                        hasErrors = true;
+                        duplicatedFieldNames.add(string_constants_1.VALUES);
+                        break;
+                    }
+                    const objectFieldValueKind = objectFieldNode.value.kind;
+                    if (objectFieldValueKind == graphql_1.Kind.NULL || objectFieldValueKind == graphql_1.Kind.OBJECT) {
+                        fieldErrorMessages.push((0, errors_1.invalidInputFieldTypeErrorMessage)(inputFieldPath, string_constants_1.LIST, (0, utils_3.kindToTypeString)(objectFieldNode.value.kind)));
+                        hasErrors = true;
+                        break;
+                    }
+                    // Coerce scalars into a list
+                    if (objectFieldValueKind !== graphql_1.Kind.LIST) {
+                        condition.values = [(0, utils_5.getSubscriptionFilterValue)(objectFieldNode.value)];
+                        break;
+                    }
+                    // Prevent duplicate values
+                    const values = new Set();
+                    const invalidIndices = [];
+                    for (let i = 0; i < objectFieldNode.value.values.length; i++) {
+                        const valueNode = objectFieldNode.value.values[i];
+                        if (valueNode.kind === graphql_1.Kind.OBJECT || valueNode.kind === graphql_1.Kind.LIST) {
+                            hasErrors = true;
+                            invalidIndices.push(i);
+                            continue;
+                        }
+                        values.add((0, utils_5.getSubscriptionFilterValue)(valueNode));
+                    }
+                    if (invalidIndices.length > 0) {
+                        errorMessages.push((0, errors_1.subscriptionFieldConditionInvalidValuesArrayErrorMessage)(inputFieldPath, invalidIndices));
+                        continue;
+                    }
+                    if (values.size < 1) {
+                        errorMessages.push((0, errors_1.subscriptionFieldConditionEmptyValuesArrayErrorMessage)(inputFieldPath));
+                        continue;
+                    }
+                    condition.values = [...values];
+                    break;
+                }
+                default: {
+                    invalidFieldNames.add(inputFieldName);
+                }
+            }
+        }
+        if (!hasErrors) {
+            return true;
+        }
+        errorMessages.push((0, errors_1.subscriptionFieldConditionInvalidInputFieldErrorMessage)(inputPath, [...validFieldNames], [...duplicatedFieldNames], [...invalidFieldNames], fieldErrorMessages));
+        return false;
+    }
+    validateSubscriptionFilterCondition(objectValueNode, configuration, objectData, depth, inputPath, directiveSubgraphName, errorMessages) {
+        if (depth > integer_constants_1.MAX_SUBSCRIPTION_FILTER_DEPTH || this.isMaxDepth) {
+            errorMessages.push((0, errors_1.subscriptionFilterConditionDepthExceededErrorMessage)(inputPath));
+            this.isMaxDepth = true;
+            return false;
+        }
+        depth += 1;
+        if (objectValueNode.fields.length !== 1) {
+            errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldNumberErrorMessage)(inputPath, objectValueNode.fields.length));
+            return false;
+        }
+        const objectFieldNode = objectValueNode.fields[0];
+        const fieldName = objectFieldNode.name.value;
+        if (!string_constants_1.SUBSCRIPTION_FILTER_INPUT_NAMES.has(fieldName)) {
+            errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldErrorMessage)(inputPath, fieldName));
+            return false;
+        }
+        const inputFieldPath = inputPath + `.${fieldName}`;
+        switch (objectFieldNode.value.kind) {
+            case graphql_1.Kind.OBJECT: {
+                switch (fieldName) {
+                    case string_constants_1.IN_UPPER: {
+                        configuration.in = { fieldPath: [], values: [] };
+                        return this.validateSubscriptionFieldCondition(objectFieldNode.value, configuration.in, objectData, depth, inputPath + `.IN`, directiveSubgraphName, errorMessages);
+                    }
+                    case string_constants_1.NOT_UPPER: {
+                        configuration.not = {};
+                        return this.validateSubscriptionFilterCondition(objectFieldNode.value, configuration.not, objectData, depth, inputPath + `.NOT`, directiveSubgraphName, errorMessages);
+                    }
+                    default:
+                        // The field is guaranteed to be an AND or an OR
+                        errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage)(inputFieldPath, string_constants_1.LIST, string_constants_1.OBJECT));
+                        return false;
+                }
+            }
+            case graphql_1.Kind.LIST: {
+                const listConfigurations = [];
+                switch (fieldName) {
+                    case string_constants_1.AND_UPPER: {
+                        configuration.and = listConfigurations;
+                        break;
+                    }
+                    case string_constants_1.OR_UPPER: {
+                        configuration.or = listConfigurations;
+                        break;
+                    }
+                    default:
+                        // The field is guaranteed to be an IN or a NOT
+                        errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage)(inputFieldPath, string_constants_1.OBJECT, string_constants_1.LIST));
+                        return false;
+                }
+                const listLength = objectFieldNode.value.values.length;
+                if (listLength < 1 || listLength > 5) {
+                    errorMessages.push((0, errors_1.subscriptionFilterArrayConditionInvalidLengthErrorMessage)(inputFieldPath, listLength));
+                    return false;
+                }
+                let isValid = true;
+                const invalidIndices = [];
+                for (let i = 0; i < objectFieldNode.value.values.length; i++) {
+                    const arrayIndexPath = inputFieldPath + `[${i}]`;
+                    const listValueNode = objectFieldNode.value.values[i];
+                    if (listValueNode.kind !== graphql_1.Kind.OBJECT) {
+                        invalidIndices.push(i);
+                        continue;
+                    }
+                    const listConfiguration = {};
+                    isValid &&= this.validateSubscriptionFilterCondition(listValueNode, listConfiguration, objectData, depth, arrayIndexPath, directiveSubgraphName, errorMessages);
+                    if (isValid) {
+                        listConfigurations.push(listConfiguration);
+                    }
+                }
+                if (invalidIndices.length > 0) {
+                    errorMessages.push((0, errors_1.subscriptionFilterArrayConditionInvalidItemTypeErrorMessage)(inputFieldPath, invalidIndices));
+                    return false;
+                }
+                return isValid;
+            }
+            default: {
+                const expectedTypeString = string_constants_1.SUBSCRIPTION_FILTER_LIST_INPUT_NAMES.has(fieldName) ? string_constants_1.LIST : string_constants_1.OBJECT;
+                errorMessages.push((0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage)(inputFieldPath, expectedTypeString, (0, utils_3.kindToTypeString)(objectFieldNode.value.kind)));
+                return false;
+            }
+        }
+    }
+    validateSubscriptionFilterAndGenerateConfiguration(directiveNode, objectData, fieldPath, fieldName, parentTypeName, directiveSubgraphName) {
+        // directive validation occurs elsewhere
+        if (!directiveNode.arguments || directiveNode.arguments.length !== 1) {
+            return;
+        }
+        const argumentNode = directiveNode.arguments[0];
+        if (argumentNode.value.kind !== graphql_1.Kind.OBJECT) {
+            this.errors.push((0, errors_1.invalidSubscriptionFilterDirectiveError)(fieldPath, [
+                (0, errors_1.subscriptionFilterConditionInvalidInputFieldTypeErrorMessage)(string_constants_1.CONDITION, 'object', (0, utils_3.kindToTypeString)(argumentNode.value.kind)),
+            ]));
+            return;
+        }
+        const condition = {};
+        const errorMessages = [];
+        if (!this.validateSubscriptionFilterCondition(argumentNode.value, condition, objectData, 0, string_constants_1.CONDITION, directiveSubgraphName, errorMessages)) {
+            this.errors.push((0, errors_1.invalidSubscriptionFilterDirectiveError)(fieldPath, errorMessages));
+            this.isMaxDepth = false;
+            return;
+        }
+        (0, utils_3.getValueOrDefault)(this.fieldConfigurationByFieldPath, fieldPath, () => ({
+            argumentNames: [],
+            fieldName,
+            typeName: parentTypeName,
+        })).subscriptionFilterCondition = condition;
+    }
+    validateSubscriptionFiltersAndGenerateConfiguration() {
+        for (const [fieldPath, data] of this.subscriptionFilterDataByFieldPath) {
+            if (this.inaccessiblePaths.has(fieldPath)) {
+                continue;
+            }
+            const namedTypeData = (0, utils_3.getOrThrowError)(this.parentDefinitionDataByTypeName, data.fieldData.namedTypeName, string_constants_1.PARENT_DEFINITION_DATA);
+            if ((0, utils_5.isNodeDataInaccessible)(namedTypeData)) {
+                // @inaccessible error are caught elsewhere
+                continue;
+            }
+            // TODO handle Unions and Interfaces
+            if (namedTypeData.kind !== graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                continue;
+            }
+            this.validateSubscriptionFilterAndGenerateConfiguration(data.directive, namedTypeData, fieldPath, data.fieldData.name, data.fieldData.renamedParentTypeName, data.directiveSubgraphName);
+        }
+    }
     buildFederationResult() {
+        if (this.subscriptionFilterDataByFieldPath.size > 0) {
+            this.validateSubscriptionFiltersAndGenerateConfiguration();
+        }
         if (this.invalidOrScopesHostPaths.size > 0) {
             this.errors.push((0, errors_1.orScopesLimitError)(utils_3.maxOrScopes, [...this.invalidOrScopesHostPaths]));
         }
@@ -1557,6 +1843,9 @@ class FederationFactory {
                     }
             }
         }
+        if (this.subscriptionFilterDataByFieldPath.size > 0) {
+            this.validateSubscriptionFiltersAndGenerateConfiguration();
+        }
         for (const data of this.potentialPersistedDirectiveDefinitionDataByDirectiveName.values()) {
             (0, utils_5.addValidPersistedDirectiveDefinitionNodeByData)(this.routerDefinitions, data, this.persistedDirectiveDefinitionByDirectiveName, this.errors);
         }