@graphql-mesh/transform-snapshot/index.mjs

import { addResolversToSchema } from '@graphql-tools/schema';
import { composeResolvers } from '@graphql-tools/resolvers-composition';
import { path } from '@graphql-mesh/cross-helpers';
import objectHash from 'object-hash';
import { extractResolvers, pathExists, writeJSON } from '@graphql-mesh/utils';

function computeSnapshotFilePath(options) {
    const typeName = options.info.parentType.name;
    const fieldName = options.info.fieldName;
    const hashObj = options.respectSelectionSet
        ? {
            args: options.args,
            fieldNodes: options.info.fieldNodes,
        }
        : options.args;
    const hash = objectHash(hashObj, { ignoreUnknown: true }).toString();
    const fileName = [typeName, fieldName, hash].join('_') + '.json';
    return path.join(options.outputDir, fileName);
}

const writeSnapshotFile = async (path, json) => {
    try {
        await writeJSON(path, json, null, 2);
    }
    catch (e) {
        console.error(`Snapshot cannot saved to ${path}: ${e.message}`);
    }
};
class SnapshotTransform {
    constructor({ baseDir, config, importFn }) {
        this.noWrap = true;
        this.config = config;
        this.baseDir = baseDir;
        this.importFn = importFn;
    }
    transformSchema(schema) {
        // TODO: Needs to be changed!
        const configIf = 'if' in this.config
            ? typeof this.config.if === 'boolean'
                ? this.config.if
                : // eslint-disable-next-line no-new-func
                    this.config.if && new Function(`return ${this.config.if}`)()
            : true;
        if (configIf) {
            const resolvers = extractResolvers(schema);
            const resolversComposition = {};
            const outputDir = path.isAbsolute(this.config.outputDir)
                ? this.config.outputDir
                : path.join(this.baseDir, this.config.outputDir);
            const snapshotComposition = next => async (root, args, context, info) => {
                const snapshotFilePath = computeSnapshotFilePath({
                    info,
                    args,
                    outputDir,
                    respectSelectionSet: this.config.respectSelectionSet,
                });
                if (snapshotFilePath in require.cache || (await pathExists(snapshotFilePath))) {
                    return this.importFn(snapshotFilePath);
                }
                const result = await next(root, args, context, info);
                await writeSnapshotFile(snapshotFilePath, result);
                return result;
            };
            for (const field of this.config.apply) {
                resolversComposition[field] = snapshotComposition;
            }
            const composedResolvers = composeResolvers(resolvers, resolversComposition);
            return addResolversToSchema({
                schema,
                resolvers: composedResolvers,
                updateResolversInPlace: true,
            });
        }
        return schema;
    }
}

export default SnapshotTransform;