@graphql-typed-document-node/core/dist/patch-cli.js

#!/usr/bin/env node
'use strict';

const fs = require('fs');
const path = require('path');
const semver = require('semver');

// eslint-disable-next-line
const verbose = (...args) => process.env.VERBOSE ? console.log(...args) : undefined;
const { applyPatch } = require('patch-package/dist/applyPatches');
function applyPatchFile(baseDir, patch, reverse = false) {
    return applyPatch({
        patchFilePath: path.resolve(baseDir, patch.fileName),
        patchDir: baseDir,
        packageDetails: patch.details,
        reverse,
    });
}
async function applyPatches(rootDirectory, reverse = false) {
    const { availablePatches, baseDir } = await getAvailablePatches();
    for (const patch of availablePatches) {
        if (patch.details) {
            const packageResolution = resolvePackage(rootDirectory, patch);
            if (packageResolution) {
                const isValidVersion = semver.satisfies(packageResolution, patch.details.version);
                if (isValidVersion) {
                    const result = applyPatchFile(baseDir, patch, reverse);
                    if (result) {
                        // eslint-disable-next-line
                        console.info(`[TypedDocumentNode] Patch for ${patch.details.name}@${packageResolution} has been ${reverse ? 'reversed' : 'applied'}!`);
                    }
                    else {
                        // eslint-disable-next-line
                        console.warn(`[TypedDocumentNode] Something went wrong, unable to patch ${patch.details.name} (Patch: ${patch.details.version}, Installed: ${packageResolution})`);
                    }
                }
                else {
                    // eslint-disable-next-line
                    verbose(`[TypedDocumentNode] Patch for ${patch.details.name} exists, but you have a version mismatch! (Supported: ${patch.details.version}, you have: ${packageResolution})`);
                }
            }
            else {
                verbose(`[TypedDocumentNode] Skipping ${patch.fileName} patch, didn't find any package resolution!`);
            }
        }
        else {
            verbose(`[TypedDocumentNode] Unable to extract package details for patch file ${patch.fileName}!`);
        }
    }
}
function resolvePackage(rootDirectory, patch) {
    try {
        const packagePath = require.resolve(`${patch.details.name}/package.json`, { paths: [rootDirectory] });
        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
        return packageJson.version || null;
    }
    catch (e) {
        return null;
    }
}
async function getAvailablePatches() {
    const baseDir = path.join(__dirname, './patches/');
    const files = fs.readdirSync(baseDir).filter(d => path.extname(d) === '.patch');
    return {
        baseDir,
        availablePatches: files.map(fileName => {
            const cleanName = path.basename(fileName, path.extname(fileName));
            const parts = cleanName.split('+');
            const versionRange = parts.pop();
            const name = parts.join('/');
            return {
                fileName,
                details: {
                    // This structure and fields are required internally in `patch-package` code.
                    version: versionRange,
                    name,
                    pathSpecifier: name,
                    humanReadablePathSpecifier: name,
                    packageNames: [name],
                },
            };
        })
    };
}

applyPatches(process.cwd(), false);