graphql-shield-generator/lib/helpers.js

Emits a GraphQL Shield from your GraphQL schema

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getOutputPath = exports.getTypeResolverMap = exports.constructShield = void 0;
const tslib_1 = require("tslib");
const schema_1 = require("@graphql-tools/schema");
const utils_1 = require("@graphql-tools/utils");
const graphql_1 = require("graphql");
const path_1 = tslib_1.__importDefault(require("path"));
const process_1 = require("process");
const constructShield = ({ typeResolverMap, options }) => {
    let rootItems = '';
    for (const [type, resolverNames] of Object.entries(typeResolverMap)) {
        if (type.length > 0) {
            const subscriptionLinesWrapped = `${type}: ${wrapWithObject({
                shieldItemLines: resolverNames.sort().map((resolverName) => `${resolverName}: allow`),
            })},`;
            rootItems += subscriptionLinesWrapped;
        }
    }
    if (rootItems.length === 0)
        return '';
    let shieldText = getImports('graphql-shield', options);
    shieldText += '\n\n';
    shieldText += wrapWithExport({
        shieldObjectText: wrapWithGraphqlShieldCall({
            shieldObjectTextWrapped: wrapWithObject({ shieldItemLines: rootItems }),
        }),
        options,
    });
    return shieldText;
};
exports.constructShield = constructShield;
const getTypeResolverMap = async (schema) => {
    var _a;
    if (!(schema instanceof graphql_1.GraphQLSchema)) {
        schema = await (0, schema_1.makeExecutableSchema)({ typeDefs: schema.typeDefs, resolvers: schema.resolvers });
    }
    const typeResolverMap = {};
    const rootTypeMap = (0, utils_1.getRootTypeMap)(schema);
    for (const [, rootType] of rootTypeMap.entries()) {
        const typeName = rootType.name;
        const fields = rootType.getFields();
        for (const [resolverName] of Object.entries(fields)) {
            if (!typeResolverMap[typeName]) {
                typeResolverMap[typeName] = [];
            }
            if (typeName === 'Query') {
                typeResolverMap[typeName].push(resolverName);
            }
            else if (typeName === 'Mutation') {
                typeResolverMap[typeName].push(resolverName);
            }
            else if (typeName === 'Subscription') {
                typeResolverMap[typeName].push(resolverName);
            }
        }
    }
    const typeMap = schema.getTypeMap();
    for (const typeName in typeMap) {
        const type = typeMap[typeName];
        if (((_a = type.astNode) === null || _a === void 0 ? void 0 : _a.kind) === 'ObjectTypeDefinition' && !['Query', 'Mutation', 'Subscription'].includes(type.name)) {
            const foundType = schema.getType(type.name);
            //@ts-ignore
            const fields = foundType === null || foundType === void 0 ? void 0 : foundType.toConfig().fields;
            Object.keys(fields).forEach((fieldName) => {
                const field = fields[fieldName];
                const resolver = field.resolve;
                if (resolver) {
                    if (!typeResolverMap[type.name]) {
                        typeResolverMap[type.name] = [];
                    }
                    typeResolverMap[type.name].push(fieldName);
                }
            });
        }
    }
    return typeResolverMap;
};
exports.getTypeResolverMap = getTypeResolverMap;
const getOutputPath = (options) => {
    var _a, _b;
    const ext = `.${(_a = options.extension) !== null && _a !== void 0 ? _a : 'js'}`;
    const dirPath = options.outputDir ? path_1.default.resolve((0, process_1.cwd)(), options.outputDir) : path_1.default.join((0, process_1.cwd)());
    const filePath = path_1.default.format({
        dir: dirPath,
        name: (_b = options.fileName) !== null && _b !== void 0 ? _b : 'shield',
        ext: ext,
    });
    return filePath;
};
exports.getOutputPath = getOutputPath;
const wrapWithObject = ({ shieldItemLines }) => {
    let wrapped = '{';
    wrapped += '\n';
    wrapped += Array.isArray(shieldItemLines) ? '  ' + shieldItemLines.join(',\r\n') : '  ' + shieldItemLines;
    wrapped += '\n';
    wrapped += '}';
    return wrapped;
};
const getImports = (type, options) => {
    switch (options.moduleSystem) {
        case 'ES modules':
            return `import { shield, allow } from '${type}';\n`;
        case 'CommonJS':
        default:
            return `const { shield, allow } = require('${type}');\n`;
    }
};
const wrapWithExport = ({ shieldObjectText, options }) => {
    switch (options.moduleSystem) {
        case 'ES modules':
            return ` export const permissions = ${shieldObjectText};`;
        case 'CommonJS':
        default:
            return ` module.exports.permissions = ${shieldObjectText};`;
    }
};
const wrapWithGraphqlShieldCall = ({ shieldObjectTextWrapped }) => {
    let wrapped = 'shield(';
    wrapped += '\n';
    wrapped += '  ' + shieldObjectTextWrapped;
    wrapped += '\n';
    wrapped += ')';
    return wrapped;
};
//# sourceMappingURL=helpers.js.map