@graphql-mesh/fusion-composition/cjs/transforms.js

Basic composition utility for Fusion spec

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createExtendTransform = exports.createTypeReplaceTransform = exports.createNamingConventionTransform = exports.createFilterTransform = exports.createPrefixTransform = exports.createRenameFieldTransform = exports.createRenameTypeTransform = void 0;
const tslib_1 = require("tslib");
const graphql_1 = require("graphql");
const utils_1 = require("@graphql-tools/utils");
const getDirectiveExtensions_js_1 = require("./getDirectiveExtensions.js");
function createRenameTypeTransform(renameFn, kind = utils_1.MapperKind.TYPE) {
    return function renameTypeTransform(schema, subgraphConfig) {
        return (0, utils_1.mapSchema)(schema, {
            [kind]: (type) => (0, graphql_1.isSpecifiedScalarType)(type)
                ? type
                : new (Object.getPrototypeOf(type).constructor)({
                    ...type.toConfig(),
                    name: renameFn(type, subgraphConfig) || type.name,
                }),
        });
    };
}
exports.createRenameTypeTransform = createRenameTypeTransform;
function createRenameFieldTransform(renameFn, kind = utils_1.MapperKind.FIELD) {
    return function renameFieldTransform(schema, subgraphConfig) {
        return (0, utils_1.mapSchema)(schema, {
            [kind]: (field, fieldName, typeName) => [renameFn(field, fieldName, typeName, subgraphConfig) || fieldName, field],
        });
    };
}
exports.createRenameFieldTransform = createRenameFieldTransform;
function createPrefixTransform({ value, ignore = [], includeRootOperations = false, includeTypes = true, } = {}) {
    return function prefixTransform(schema, subgraphConfig) {
        value = value || subgraphConfig.name;
        const transforms = [];
        const rootTypeNames = [...(0, utils_1.getRootTypes)(schema)].map(type => type.name);
        if (includeTypes) {
            transforms.push(createRenameTypeTransform(type => {
                if (ignore.includes(type.name)) {
                    return type.name;
                }
                return `${value}${type.name}`;
            }));
        }
        if (includeRootOperations) {
            transforms.push(createRenameFieldTransform((_field, fieldName, typeName) => {
                if (rootTypeNames.includes(typeName) && !ignore.includes(typeName)) {
                    return `${value}${fieldName}`;
                }
                return fieldName;
            }, utils_1.MapperKind.ROOT_FIELD));
        }
        for (const transform of transforms) {
            schema = transform(schema, subgraphConfig);
        }
        return schema;
    };
}
exports.createPrefixTransform = createPrefixTransform;
function addHiddenDirective(directableObj) {
    const directives = (0, getDirectiveExtensions_js_1.getDirectiveExtensions)(directableObj);
    directives.hidden = [{}];
    const extensions = (directableObj.extensions ||= {});
    extensions.directives = directives;
}
function createFilterTransform(config) {
    const schemaMapper = {};
    if (config.rootFieldFilter) {
        schemaMapper[utils_1.MapperKind.ROOT_FIELD] = (fieldConfig, fieldName, typeName) => {
            if (!config.rootFieldFilter(typeName, fieldName)) {
                addHiddenDirective(fieldConfig);
            }
            return [fieldName, fieldConfig];
        };
    }
    if (config.typeFilter) {
        schemaMapper[utils_1.MapperKind.TYPE] = type => {
            if (!config.typeFilter(type)) {
                addHiddenDirective(type);
            }
            return type;
        };
    }
    if (config.fieldFilter) {
        schemaMapper[utils_1.MapperKind.FIELD] = (fieldConfig, fieldName, typeName) => {
            if (!config.fieldFilter(typeName, fieldName)) {
                addHiddenDirective(fieldConfig);
            }
            return fieldConfig;
        };
    }
    if (config.objectFieldFilter) {
        schemaMapper[utils_1.MapperKind.OBJECT_FIELD] = (fieldConfig, fieldName, typeName) => {
            if (!config.objectFieldFilter(typeName, fieldName)) {
                addHiddenDirective(fieldConfig);
            }
            return [fieldName, fieldConfig];
        };
    }
    if (config.interfaceFieldFilter) {
        schemaMapper[utils_1.MapperKind.INTERFACE_FIELD] = (fieldConfig, fieldName, typeName) => {
            if (!config.interfaceFieldFilter(typeName, fieldName)) {
                addHiddenDirective(fieldConfig);
            }
            return [fieldName, fieldConfig];
        };
    }
    if (config.inputObjectFieldFilter) {
        schemaMapper[utils_1.MapperKind.INPUT_OBJECT_FIELD] = (fieldConfig, fieldName, typeName) => {
            if (!config.inputObjectFieldFilter(typeName, fieldName)) {
                addHiddenDirective(fieldConfig);
            }
            return fieldConfig;
        };
    }
    // TODO
    /*
    if (config.argumentFilter) {
      schemaMapper[MapperKind.ARGUMENT] = (argConfig, fieldName, typeName) => {
        if (config.argumentFilter(typeName, fieldName, argConfig)) {
          return argConfig;
        }
        return null;
      };
    }
    */
    return function filterTransform(schema) {
        return (0, utils_1.mapSchema)(schema, schemaMapper);
    };
}
exports.createFilterTransform = createFilterTransform;
tslib_1.__exportStar(require("change-case"), exports);
function createNamingConventionTransform(config) {
    const schemaMapper = {};
    if (config.typeNames) {
        schemaMapper[utils_1.MapperKind.TYPE] = type => {
            if ((0, graphql_1.isSpecifiedScalarType)(type)) {
                return type;
            }
            return new (Object.getPrototypeOf(type).constructor)({
                ...type.toConfig(),
                name: config.typeNames(type.name),
            });
        };
    }
    if (config.fieldNames) {
        schemaMapper[utils_1.MapperKind.FIELD] = (fieldConfig, fieldName) => [
            config.fieldNames(fieldName),
            fieldConfig,
        ];
    }
    if (config.enumValues) {
        schemaMapper[utils_1.MapperKind.ENUM_VALUE] = (valueConfig, _typeName, _schema, externalValue) => [
            config.enumValues(externalValue),
            valueConfig,
        ];
    }
    if (config.fieldArgumentNames) {
        schemaMapper[utils_1.MapperKind.ARGUMENT] = (argumentConfig, argumentName) => ({
            ...argumentConfig,
            name: config.fieldArgumentNames(argumentName),
        });
    }
    return function namingConventionTransform(schema) {
        return (0, utils_1.mapSchema)(schema, schemaMapper);
    };
}
exports.createNamingConventionTransform = createNamingConventionTransform;
function createTypeReplaceTransform(replacerFn) {
    return function typeReplaceTransform(schema) {
        return (0, utils_1.mapSchema)(schema, {
            [utils_1.MapperKind.FIELD]: (fieldConfig, fieldName, typeName) => {
                const newTypeName = replacerFn(typeName, fieldName, fieldConfig.type);
                if (newTypeName) {
                    const newType = (0, graphql_1.typeFromAST)(schema, (0, graphql_1.parseType)(newTypeName));
                    if (!newType) {
                        throw new Error(`No type found for ${newTypeName}`);
                    }
                    return [fieldName, { ...fieldConfig, type: newType }];
                }
                return undefined;
            },
        });
    };
}
exports.createTypeReplaceTransform = createTypeReplaceTransform;
function createExtendTransform(typeDefs) {
    const typeDefsDoc = typeof typeDefs === 'string' ? (0, graphql_1.parse)(typeDefs, { noLocation: true }) : typeDefs;
    return function extendTransform(schema) {
        return (0, graphql_1.extendSchema)(schema, typeDefsDoc, {
            assumeValid: true,
            assumeValidSDL: true,
        });
    };
}
exports.createExtendTransform = createExtendTransform;