@graphql-mesh/transform-snapshot/index.cjs.js

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

function _interopNamespace(e) {
    if (e && e.__esModule) { return e; } else {
        var n = {};
        if (e) {
            Object.keys(e).forEach(function (k) {
                var d = Object.getOwnPropertyDescriptor(e, k);
                Object.defineProperty(n, k, d.get ? d : {
                    enumerable: true,
                    get: function () {
                        return e[k];
                    }
                });
            });
        }
        n['default'] = e;
        return n;
    }
}

const schema = require('@graphql-tools/schema');
const resolversComposition = require('@graphql-tools/resolvers-composition');
const path = require('path');
const fsExtra = require('fs-extra');
const objectHash = _interopDefault(require('object-hash'));
const utils = require('@graphql-mesh/utils');

function computeSnapshotFilePath(options) {
    const argsHash = objectHash(options.args, { ignoreUnknown: true });
    const fileName = [options.typeName, options.fieldName, argsHash].join('_') + '.json';
    const absoluteOutputDir = path.isAbsolute(options.outputDir) ? options.outputDir : path.join(process.cwd(), options.outputDir);
    return path.join(absoluteOutputDir, fileName);
}

const writeFile = async (path, json) => {
    try {
        await fsExtra.ensureFile(path);
        await fsExtra.writeJSON(path, json, {
            spaces: 2,
        });
    }
    catch (e) {
        console.error(`Snapshot cannot saved to ${path}: ${e.message}`);
    }
};
class SnapshotTransform {
    constructor(options) {
        this.options = options;
        this.noWrap = true;
    }
    transformSchema(schema$1) {
        const { config } = this.options;
        // TODO: Needs to be changed!
        const configIf = 'if' in config ? (typeof config.if === 'boolean' ? config.if : config.if && eval(config.if)) : true;
        if (configIf) {
            const resolvers = utils.extractResolvers(schema$1);
            const resolversComposition$1 = {};
            const outputDir = path.isAbsolute(config.outputDir) ? config.outputDir : path.join(process.cwd(), config.outputDir);
            const snapshotComposition = next => async (root, args, context, info) => {
                const snapshotFilePath = computeSnapshotFilePath({
                    typeName: info.parentType.name,
                    fieldName: info.fieldName,
                    args,
                    outputDir,
                });
                if (snapshotFilePath in require.cache || (await fsExtra.pathExists(snapshotFilePath))) {
                    return new Promise(function (resolve) { resolve(_interopNamespace(require(snapshotFilePath))); });
                }
                const result = await next(root, args, context, info);
                await writeFile(snapshotFilePath, result);
                return result;
            };
            for (const field of config.apply) {
                resolversComposition$1[field] = snapshotComposition;
            }
            const composedResolvers = resolversComposition.composeResolvers(resolvers, resolversComposition$1);
            return schema.addResolversToSchema({
                schema: schema$1,
                resolvers: composedResolvers,
                updateResolversInPlace: true,
            });
        }
        return schema$1;
    }
}

module.exports = SnapshotTransform;
//# sourceMappingURL=index.cjs.js.map