@theguild/federation-composition 0.0.0-alpha-20230916192321-bb37b43

package/cjs/subgraph/validation/validate-state.js

@@ -0,0 +1,476 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnionType = exports.isInterfaceType = exports.isObjectType = exports.isEnumType = exports.isScalarType = exports.isInputObjectType = exports.typeExists = exports.isInputType = exports.isTypeSubTypeOf = exports.validateSubgraphState = void 0;
+const graphql_1 = require("graphql");
+const format_js_1 = require("../../utils/format.js");
+const state_js_1 = require("../../utils/state.js");
+const state_js_2 = require("../state.js");
+const specifiedScalars = new Set(graphql_1.specifiedScalarTypes.map(t => t.name));
+function validateSubgraphState(state) {
+    const errors = [];
+    function reportError(message) {
+        errors.push(new graphql_1.GraphQLError(message, {
+            extensions: {
+                code: 'INVALID_GRAPHQL',
+            },
+        }));
+    }
+    validateRootTypes(state, reportError);
+    validateTypes(state, reportError);
+    return errors;
+}
+exports.validateSubgraphState = validateSubgraphState;
+function validateRootTypes(state, reportError) {
+    const rootTypesMap = new Map();
+    for (const key in state.schema) {
+        const rootTypeKind = key;
+        const rootTypeName = state.schema[rootTypeKind];
+        if (rootTypeName) {
+            const rootType = state.types.get(rootTypeName);
+            if (!rootType) {
+                continue;
+            }
+            if (!isObjectType(rootType)) {
+                const operationTypeStr = capitalize(rootTypeKind.replace('Type', ''));
+                reportError(rootTypeKind === 'queryType'
+                    ? `${operationTypeStr} root type must be Object type, it cannot be ${rootTypeName}.`
+                    : `${operationTypeStr} root type must be Object type if provided, it cannot be ${rootTypeName}.`);
+            }
+            else {
+                const existing = rootTypesMap.get(rootTypeName);
+                if (existing) {
+                    existing.add(rootTypeKind);
+                }
+                else {
+                    rootTypesMap.set(rootTypeName, new Set([rootTypeKind]));
+                }
+            }
+        }
+    }
+    for (const [rootTypeName, operationTypes] of rootTypesMap) {
+        if (operationTypes.size > 1) {
+            const operationList = (0, format_js_1.andList)(Array.from(operationTypes).map(op => capitalize(op.replace('Type', ''))));
+            reportError(`All root types must be different, "${rootTypeName}" type is used as ${operationList} root types.`);
+        }
+    }
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+function validateTypes(state, reportError) {
+    const validateInputObjectCircularRefs = createInputObjectCircularRefsValidator(state, reportError);
+    const implementationsMap = new Map();
+    for (const type of state.types.values()) {
+        if (isInterfaceType(type)) {
+            for (const iface of type.interfaces) {
+                const interfaceType = state.types.get(iface);
+                if (interfaceType && isInterfaceType(interfaceType)) {
+                    let implementations = implementationsMap.get(iface);
+                    if (implementations === undefined) {
+                        implementationsMap.set(iface, new Set([type.name]));
+                    }
+                    else {
+                        implementations.add(type.name);
+                    }
+                }
+            }
+        }
+        else if (isObjectType(type)) {
+            for (const iface of type.interfaces) {
+                const interfaceType = state.types.get(iface);
+                if (interfaceType && isInterfaceType(interfaceType)) {
+                    let implementations = implementationsMap.get(iface);
+                    if (implementations === undefined) {
+                        implementationsMap.set(iface, new Set([type.name]));
+                    }
+                    else {
+                        implementations.add(type.name);
+                    }
+                }
+            }
+        }
+    }
+    for (const type of state.types.values()) {
+        if (!isIntrospectionType(type.name)) {
+            validateName(reportError, type.name);
+        }
+        if (isObjectType(type)) {
+            validateFields(state, reportError, type);
+            validateInterfaces(state, implementationsMap, reportError, type);
+        }
+        else if (isInterfaceType(type)) {
+            validateFields(state, reportError, type);
+            validateInterfaces(state, implementationsMap, reportError, type);
+        }
+        else if (isUnionType(type)) {
+            validateUnionMembers(state, reportError, type);
+        }
+        else if (isEnumType(type)) {
+            validateEnumValues(reportError, type);
+        }
+        else if (isInputObjectType(type)) {
+            validateInputFields(state, reportError, type);
+            validateInputObjectCircularRefs(type);
+        }
+    }
+}
+function validateName(reportError, name) {
+    if (name.startsWith('__')) {
+        reportError(`Name "${name}" must not begin with "__", which is reserved by GraphQL introspection.`);
+    }
+}
+function validateFields(state, reportError, type) {
+    const fields = type.fields;
+    const isRootType = type.name === state.schema.queryType ||
+        type.name === state.schema.mutationType ||
+        type.name === state.schema.subscriptionType;
+    if (fields.size === 0 && !isRootType) {
+        reportError(`Type ${type.name} must define one or more fields.`);
+    }
+    for (const field of fields.values()) {
+        validateName(reportError, field.name);
+        const fieldTypeName = (0, state_js_1.stripTypeModifiers)(field.type);
+        const fieldTypeExists = typeExists(state, fieldTypeName);
+        if (!fieldTypeExists) {
+            continue;
+        }
+        if (!isOutputType(state, fieldTypeName)) {
+            reportError(`The type of "${type.name}.${field.name}" must be Output Type but got: "${field.type}".`);
+        }
+        for (const arg of field.args.values()) {
+            const argName = arg.name;
+            validateName(reportError, argName);
+            const argTypeName = (0, state_js_1.stripTypeModifiers)(arg.type);
+            const argTypeExists = typeExists(state, argTypeName);
+            if (!argTypeExists) {
+                continue;
+            }
+            if (!isInputType(state, argTypeName)) {
+                const isList = arg.type.endsWith(']');
+                const isNonNull = arg.type.endsWith('!');
+                const extra = isList ? ', a ListType' : isNonNull ? ', a NonNullType' : '';
+                reportError(`The type of "${type.name}.${field.name}(${argName}:)" must be Input Type but got "${arg.type}"${extra}.`);
+            }
+            if (isRequiredArgument(arg) && arg.deprecated?.deprecated) {
+                reportError(`Required argument ${type.name}.${field.name}(${argName}:) cannot be deprecated.`);
+            }
+            if (typeof arg.defaultValue !== 'undefined' &&
+                !isValidateDefaultValue(state, reportError, arg.type, (0, graphql_1.parseValue)(arg.defaultValue))) {
+                reportError(`Invalid default value (got: ${arg.defaultValue}) provided for argument ${type.name}.${field.name}(${arg.name}:) of type ${arg.type}.`);
+            }
+        }
+    }
+}
+function isValidateDefaultValue(state, reportError, inputTypePrinted, value) {
+    if ((0, state_js_1.isNonNull)(inputTypePrinted)) {
+        if (value.kind === graphql_1.Kind.NULL) {
+            return false;
+        }
+        return isValidateDefaultValue(state, reportError, (0, state_js_1.stripNonNull)(inputTypePrinted), value);
+    }
+    if (value.kind === graphql_1.Kind.NULL) {
+        return true;
+    }
+    const inputTypeName = (0, state_js_1.stripTypeModifiers)(inputTypePrinted);
+    const inputType = state.types.get(inputTypeName);
+    if (inputType && isScalarType(inputType)) {
+        return true;
+    }
+    if ((0, state_js_1.isList)(inputTypePrinted)) {
+        if (value.kind === graphql_1.Kind.LIST) {
+            return value.values.every(val => isValidateDefaultValue(state, reportError, (0, state_js_1.stripList)(inputTypePrinted), val));
+        }
+        return isValidateDefaultValue(state, reportError, (0, state_js_1.stripList)(inputTypePrinted), value);
+    }
+    if (specifiedScalars.has(inputTypeName)) {
+        const specifiedScalar = graphql_1.specifiedScalarTypes.find(t => t.name === inputTypeName);
+        try {
+            specifiedScalar.parseLiteral(value);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    if (!inputType) {
+        return true;
+    }
+    if (isInputObjectType(inputType)) {
+        if (value.kind !== graphql_1.Kind.OBJECT) {
+            return false;
+        }
+        const fields = inputType.fields;
+        for (const astField of value.fields) {
+            const field = fields.get(astField.name.value);
+            if (!field) {
+                return false;
+            }
+            if (!isValidateDefaultValue(state, reportError, field.type, astField.value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (isEnumType(inputType)) {
+        if (value.kind !== graphql_1.Kind.ENUM && value.kind !== graphql_1.Kind.STRING) {
+            return false;
+        }
+        return inputType.values.has(value.value);
+    }
+    return false;
+}
+function validateUnionMembers(state, reportError, union) {
+    const memberTypes = union.members;
+    if (memberTypes.size === 0) {
+        reportError(`Union type ${union.name} must define one or more member types.`);
+    }
+    const includedTypeNames = new Set();
+    for (const memberType of memberTypes) {
+        if (includedTypeNames.has(memberType)) {
+            reportError(`Union type ${union.name} can only include type ${memberType} once.`);
+            continue;
+        }
+        includedTypeNames.add(memberType);
+        const type = state.types.get(memberType);
+        if (!type || !isObjectType(type)) {
+            reportError(`Union type ${union.name} can only include Object types, ` +
+                `it cannot include ${memberType}.`);
+        }
+    }
+}
+function validateEnumValues(reportError, enumType) {
+    const enumValues = enumType.values;
+    if (enumValues.size === 0) {
+        reportError(`Enum type ${enumType.name} must define one or more values.`);
+    }
+    for (const enumValue of enumValues.keys()) {
+        validateName(reportError, enumValue);
+    }
+}
+function validateInputFields(state, reportError, inputObj) {
+    const fields = inputObj.fields;
+    if (fields.size === 0) {
+        reportError(`Input Object type ${inputObj.name} must define one or more fields.`);
+    }
+    for (const field of fields.values()) {
+        validateName(reportError, field.name);
+        const fieldTypeName = (0, state_js_1.stripTypeModifiers)(field.type);
+        const fieldTypeExists = typeExists(state, fieldTypeName);
+        if (!fieldTypeExists) {
+            continue;
+        }
+        if (!isInputType(state, fieldTypeName)) {
+            const isList = field.type.endsWith(']');
+            const isNonNull = field.type.endsWith('!');
+            const extra = isList ? ', a ListType' : isNonNull ? ', a NonNullType' : '';
+            reportError(`The type of ${inputObj.name}.${field.name} must be Input Type but got "${field.type}"${extra}.`);
+        }
+        if (isRequiredInputField(field) && field.deprecated?.deprecated) {
+            reportError(`Required input field ${inputObj.name}.${field.name} cannot be deprecated.`);
+        }
+        if (typeof field.defaultValue !== 'undefined' &&
+            !isValidateDefaultValue(state, reportError, field.type, (0, graphql_1.parseValue)(field.defaultValue))) {
+            reportError(`Invalid default value (got: ${field.defaultValue}) provided for input field ${inputObj.name}.${field.name} of type ${field.type}.`);
+        }
+    }
+}
+function validateInterfaces(state, implementationsMap, reportError, type) {
+    const ifaceTypeNames = new Set();
+    for (const iface of type.interfaces) {
+        const interfaceType = state.types.get(iface);
+        if (!interfaceType) {
+            continue;
+        }
+        if (!isInterfaceType(interfaceType)) {
+            reportError(`Type ${type.name} must only implement Interface types, it cannot implement ${iface}.`);
+            continue;
+        }
+        if (type.name === iface) {
+            reportError(`Type ${type.name} cannot implement itself because it would create a circular reference.`);
+            continue;
+        }
+        if (ifaceTypeNames.has(iface)) {
+            reportError(`Type ${type.name} can only implement ${iface} once.`);
+            continue;
+        }
+        ifaceTypeNames.add(iface);
+        validateTypeImplementsAncestors(reportError, type, interfaceType);
+        validateTypeImplementsInterface(state, implementationsMap, reportError, type, interfaceType);
+    }
+}
+function validateTypeImplementsAncestors(reportError, type, interfaceType) {
+    const ifaceInterfaces = type.interfaces;
+    for (const transitive of interfaceType.interfaces) {
+        if (!ifaceInterfaces.has(transitive)) {
+            reportError(transitive === type.name
+                ? `Type ${type.name} cannot implement ${interfaceType.name} because it would create a circular reference.`
+                : `Type ${type.name} must implement ${transitive} because it is implemented by ${interfaceType.name}.`);
+        }
+    }
+}
+function validateTypeImplementsInterface(state, implementationsMap, reportError, type, interfaceType) {
+    const typeFieldMap = type.fields;
+    for (const ifaceField of interfaceType.fields.values()) {
+        const fieldName = ifaceField.name;
+        const typeField = typeFieldMap.get(fieldName);
+        if (typeField == null) {
+            reportError(`Interface field ${interfaceType.name}.${fieldName} expected but ${type.name} does not provide it.`);
+            continue;
+        }
+        if (!isTypeSubTypeOf(state, implementationsMap, typeField.type, ifaceField.type)) {
+            reportError(`Interface field ${interfaceType.name}.${fieldName} expects type ` +
+                `${ifaceField.type} but ${type.name}.${fieldName} is type ${typeField.type}.`);
+        }
+        for (const ifaceArg of ifaceField.args.values()) {
+            const argName = ifaceArg.name;
+            const typeArg = typeField.args.get(argName);
+            if (!typeArg) {
+                reportError(`Interface field argument ${interfaceType.name}.${fieldName}(${argName}:) expected but ${type.name}.${fieldName} does not provide it.`);
+                continue;
+            }
+            if (ifaceArg.type !== typeArg.type) {
+                reportError(`Interface field argument ${interfaceType.name}.${fieldName}(${argName}:) ` +
+                    `expects type ${ifaceArg.type} but ` +
+                    `${type.name}.${fieldName}(${argName}:) is type ` +
+                    `${typeArg.type}.`);
+            }
+        }
+        for (const typeArg of typeField.args.values()) {
+            const argName = typeArg.name;
+            const ifaceArg = ifaceField.args.get(argName);
+            if (!ifaceArg && isRequiredArgument(typeArg)) {
+                reportError(`Object field ${type.name}.${fieldName} includes required argument ${argName} that is missing from the Interface field ${interfaceType.name}.${fieldName}.`);
+            }
+        }
+    }
+}
+function isTypeSubTypeOf(state, implementationsMap, maybeSubTypeName, superTypeName) {
+    if (maybeSubTypeName === superTypeName) {
+        return true;
+    }
+    if ((0, state_js_1.isNonNull)(superTypeName)) {
+        if ((0, state_js_1.isNonNull)(maybeSubTypeName)) {
+            return isTypeSubTypeOf(state, implementationsMap, (0, state_js_1.stripNonNull)(maybeSubTypeName), (0, state_js_1.stripNonNull)(superTypeName));
+        }
+        return false;
+    }
+    if ((0, state_js_1.isNonNull)(maybeSubTypeName)) {
+        return isTypeSubTypeOf(state, implementationsMap, (0, state_js_1.stripNonNull)(maybeSubTypeName), superTypeName);
+    }
+    if ((0, state_js_1.isList)(superTypeName)) {
+        if ((0, state_js_1.isList)(maybeSubTypeName)) {
+            return isTypeSubTypeOf(state, implementationsMap, (0, state_js_1.stripList)(maybeSubTypeName), (0, state_js_1.stripList)(superTypeName));
+        }
+        return false;
+    }
+    if ((0, state_js_1.isList)(maybeSubTypeName)) {
+        return false;
+    }
+    const superType = state.types.get(superTypeName);
+    const maybeSubType = state.types.get(maybeSubTypeName);
+    if (!superType || !maybeSubType) {
+        return false;
+    }
+    return (isAbstractType(superType) &&
+        (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&
+        isSubType(implementationsMap, superType, maybeSubType));
+}
+exports.isTypeSubTypeOf = isTypeSubTypeOf;
+function isSubType(implementationsMap, abstractType, maybeSubType) {
+    if (isUnionType(abstractType)) {
+        return abstractType.members.has(maybeSubType.name);
+    }
+    return implementationsMap.get(abstractType.name)?.has(maybeSubType.name) ?? false;
+}
+function createInputObjectCircularRefsValidator(state, reportError) {
+    const visitedTypes = new Set();
+    const fieldPath = [];
+    const fieldPathIndexByTypeName = Object.create(null);
+    return detectCycleRecursive;
+    function detectCycleRecursive(inputObj) {
+        if (visitedTypes.has(inputObj)) {
+            return;
+        }
+        visitedTypes.add(inputObj);
+        fieldPathIndexByTypeName[inputObj.name] = fieldPath.length;
+        for (const field of inputObj.fields.values()) {
+            if ((0, state_js_1.isNonNull)(field.type)) {
+                const fieldType = state.types.get((0, state_js_1.stripNonNull)(field.type));
+                if (fieldType && isInputObjectType(fieldType)) {
+                    const cycleIndex = fieldPathIndexByTypeName[fieldType.name];
+                    fieldPath.push(field.name);
+                    if (cycleIndex === undefined) {
+                        detectCycleRecursive(fieldType);
+                    }
+                    else {
+                        const cyclePath = fieldPath.slice(cycleIndex);
+                        reportError(`Cannot reference Input Object "${fieldType.name}" within itself through a series of non-null fields: "${cyclePath.join('.')}".`);
+                    }
+                    fieldPath.pop();
+                }
+            }
+        }
+        fieldPathIndexByTypeName[inputObj.name] = undefined;
+    }
+}
+function isIntrospectionType(typeName) {
+    return graphql_1.introspectionTypes.some(t => t.name === typeName);
+}
+function isAbstractType(type) {
+    return isInterfaceType(type) || isUnionType(type);
+}
+function isRequiredArgument(arg) {
+    return (0, state_js_1.isNonNull)(arg.type) && arg.defaultValue === undefined;
+}
+function isRequiredInputField(arg) {
+    return (0, state_js_1.isNonNull)(arg.type) && arg.defaultValue === undefined;
+}
+function isOutputType(state, typeName) {
+    const type = state.types.get(typeName);
+    if (!type) {
+        if (specifiedScalars.has(typeName)) {
+            return true;
+        }
+        throw new Error(`Expected to find ${typeName} type`);
+    }
+    return !isInputObjectType(type);
+}
+function isInputType(state, typeName) {
+    const type = state.types.get(typeName);
+    if (!type) {
+        if (specifiedScalars.has(typeName)) {
+            return true;
+        }
+        throw new Error(`Expected to find ${typeName} type`);
+    }
+    return isScalarType(type) || isEnumType(type) || isInputObjectType(type);
+}
+exports.isInputType = isInputType;
+function typeExists(state, typeName) {
+    return state.types.has(typeName) || specifiedScalars.has(typeName);
+}
+exports.typeExists = typeExists;
+function isInputObjectType(type) {
+    return type.kind === state_js_2.TypeKind.INPUT_OBJECT;
+}
+exports.isInputObjectType = isInputObjectType;
+function isScalarType(type) {
+    return type.kind === state_js_2.TypeKind.SCALAR;
+}
+exports.isScalarType = isScalarType;
+function isEnumType(type) {
+    return type.kind === state_js_2.TypeKind.ENUM;
+}
+exports.isEnumType = isEnumType;
+function isObjectType(type) {
+    return type.kind === state_js_2.TypeKind.OBJECT;
+}
+exports.isObjectType = isObjectType;
+function isInterfaceType(type) {
+    return type.kind === state_js_2.TypeKind.INTERFACE;
+}
+exports.isInterfaceType = isInterfaceType;
+function isUnionType(type) {
+    return type.kind === state_js_2.TypeKind.UNION;
+}
+exports.isUnionType = isUnionType;