@graphprotocol/graph-cli 0.37.2 → 0.37.3-alpha-20230110163550-d64bef6

package/dist/commands/test.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const binary_install_raw_1 = require("binary-install-raw");
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const gluegun_1 = require("gluegun");
+const gluegun_2 = require("../command-helpers/gluegun");
+const path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const child_process_1 = require("child_process");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const HELP = `
+${chalk_1.default.bold('graph test')} ${chalk_1.default.dim('[options]')} ${chalk_1.default.bold('<datasource>')}
+
+${chalk_1.default.dim('Options:')}
+  -c, --coverage                Run the tests in coverage mode
+  -d, --docker                  Run the tests in a docker container(Note: Please execute from the root folder of the subgraph)
+  -f  --force                   Binary - overwrites folder + file when downloading. Docker - rebuilds the docker image
+  -h, --help                    Show usage information
+  -l, --logs                    Logs to the console information about the OS, CPU model and download url (debugging purposes)
+  -r, --recompile               Force-recompile tests
+  -v, --version <tag>           Choose the version of the rust binary that you want to be downloaded/used
+  `;
+exports.default = {
+    description: 'Runs rust binary for subgraph testing',
+    run: async (toolbox) => {
+        // Read CLI parameters
+        let { c, coverage, d, docker, f, force, h, help, l, logs, r, recompile, v, version } = toolbox.parameters.options;
+        let opts = {};
+        // Support both long and short option variants
+        opts.coverage = coverage || c;
+        opts.docker = docker || d;
+        opts.force = force || f;
+        opts.help = help || h;
+        opts.logs = logs || l;
+        opts.recompile = recompile || r;
+        opts.version = version || v;
+        opts.testsFolder = './tests';
+        // Fix if a boolean flag (e.g -c, --coverage) has an argument
+        try {
+            (0, gluegun_2.fixParameters)(toolbox.parameters, {
+                h,
+                help,
+                c,
+                coverage,
+                d,
+                docker,
+                f,
+                force,
+                l,
+                logs,
+                r,
+                recompile,
+            });
+        }
+        catch (e) {
+            gluegun_1.print.error(e.message);
+            process.exitCode = 1;
+            return;
+        }
+        let datasource = toolbox.parameters.first || toolbox.parameters.array[0];
+        // Show help text if requested
+        if (opts.help) {
+            gluegun_1.print.info(HELP);
+            return;
+        }
+        // Check if matchstick.yaml config exists
+        if (gluegun_1.filesystem.exists('matchstick.yaml')) {
+            try {
+                // Load the config
+                let config = await js_yaml_1.default.load(gluegun_1.filesystem.read('matchstick.yaml', 'utf8'));
+                // Check if matchstick.yaml and testsFolder not null
+                if (config && config.testsFolder) {
+                    // assign test folder from matchstick.yaml if present
+                    opts.testsFolder = config.testsFolder;
+                }
+            }
+            catch (error) {
+                gluegun_1.print.info('A problem occurred while reading matchstick.yaml. Please attend to the errors below:');
+                gluegun_1.print.error(error.message);
+                process.exit(1);
+            }
+        }
+        opts.cachePath = path_1.default.join(opts.testsFolder, '.latest.json');
+        setVersionFromCache(opts);
+        // Fetch the latest version tag if version is not specified with -v/--version or if the version is not cached
+        if (opts.force || (!opts.version && !opts.latestVersion)) {
+            gluegun_1.print.info('Fetching latest version tag');
+            let result = await (0, node_fetch_1.default)('https://api.github.com/repos/LimeChain/matchstick/releases/latest');
+            let json = await result.json();
+            opts.latestVersion = json.tag_name;
+            gluegun_1.filesystem.file(opts.cachePath, {
+                content: {
+                    version: json.tag_name,
+                    timestamp: Date.now(),
+                },
+            });
+        }
+        if (opts.docker) {
+            runDocker(datasource, opts);
+        }
+        else {
+            runBinary(datasource, opts);
+        }
+    },
+};
+async function setVersionFromCache(opts) {
+    if (gluegun_1.filesystem.exists(opts.cachePath) == 'file') {
+        let cached = gluegun_1.filesystem.read(opts.cachePath, 'json');
+        // Get the cache age in days
+        let cacheAge = (Date.now() - cached.timestamp) / (1000 * 60 * 60 * 24);
+        // If cache age is less than 1 day, use the cached version
+        if (cacheAge < 1) {
+            opts.latestVersion = cached.version;
+        }
+    }
+}
+async function runBinary(datasource, opts) {
+    let coverageOpt = opts.coverage;
+    let forceOpt = opts.force;
+    let logsOpt = opts.logs;
+    let versionOpt = opts.version;
+    let latestVersion = opts.latestVersion;
+    let recompileOpt = opts.recompile;
+    const platform = await getPlatform(logsOpt);
+    const url = `https://github.com/LimeChain/matchstick/releases/download/${versionOpt || latestVersion}/${platform}`;
+    if (logsOpt) {
+        gluegun_1.print.info(`Download link: ${url}`);
+    }
+    let binary = new binary_install_raw_1.Binary(platform, url, versionOpt || latestVersion);
+    forceOpt ? await binary.install(true) : await binary.install(false);
+    let args = new Array();
+    if (coverageOpt)
+        args.push('-c');
+    if (recompileOpt)
+        args.push('-r');
+    if (datasource)
+        args.push(datasource);
+    args.length > 0 ? binary.run(...args) : binary.run();
+}
+async function getPlatform(logsOpt) {
+    const type = os_1.default.type();
+    const arch = os_1.default.arch();
+    const cpuCore = os_1.default.cpus()[0];
+    const isAppleSilicon = arch === 'arm64' && /Apple (M1|M2|processor)/.test(cpuCore.model);
+    const linuxInfo = type === 'Linux' ? await getLinuxInfo() : {};
+    const linuxDistro = linuxInfo.name;
+    const release = linuxInfo.version || os_1.default.release();
+    const majorVersion = parseInt(linuxInfo.version, 10) || semver_1.default.major(release);
+    if (logsOpt) {
+        gluegun_1.print.info(`OS type: ${linuxDistro || type}\nOS arch: ${arch}\nOS release: ${release}\nOS major version: ${majorVersion}\nCPU model: ${cpuCore.model}`);
+    }
+    if (arch === 'x64' || isAppleSilicon) {
+        if (type === 'Darwin') {
+            if (majorVersion === 18 || majorVersion === 19) {
+                return 'binary-macos-10.15'; // GitHub dropped support for macOS 10.14 in Actions, but it seems 10.15 binary works on 10.14 too
+            }
+            else if (isAppleSilicon) {
+                return 'binary-macos-11-m1';
+            }
+            return 'binary-macos-11';
+        }
+        else if (type === 'Linux') {
+            if (majorVersion === 18) {
+                return 'binary-linux-18';
+            }
+            if (majorVersion === 22) {
+                return 'binary-linux-22';
+            }
+            else {
+                return 'binary-linux-20';
+            }
+        }
+    }
+    throw new Error(`Unsupported platform: ${type} ${arch} ${majorVersion}`);
+}
+async function getLinuxInfo() {
+    try {
+        let result = await gluegun_1.system.run("cat /etc/*-release | grep -E '(^VERSION|^NAME)='", {
+            trim: true,
+        });
+        let infoArray = result
+            .replace(/['"]+/g, '')
+            .split('\n')
+            .map(p => p.split('='));
+        let linuxInfo = {};
+        infoArray.forEach(val => {
+            linuxInfo[val[0].toLowerCase()] = val[1];
+        });
+        return linuxInfo;
+    }
+    catch (error) {
+        gluegun_1.print.error(`Error fetching the Linux version:\n ${error}`);
+        process.exit(1);
+    }
+}
+async function runDocker(datasource, opts) {
+    let coverageOpt = opts.coverage;
+    let forceOpt = opts.force;
+    let versionOpt = opts.version;
+    let latestVersion = opts.latestVersion;
+    let recompileOpt = opts.recompile;
+    // Remove binary-install-raw binaries, because docker has permission issues
+    // when building the docker images
+    await gluegun_1.filesystem.remove('./node_modules/binary-install-raw/bin');
+    // Get current working directory
+    let current_folder = await gluegun_1.filesystem.cwd();
+    // Declate dockerfilePath with default location
+    let dockerfilePath = path_1.default.join(opts.testsFolder || 'tests', '.docker/Dockerfile');
+    // Check if the Dockerfil already exists
+    let dockerfileExists = gluegun_1.filesystem.exists(dockerfilePath);
+    // Generate the Dockerfile only if it doesn't exists,
+    // version flag and/or force flag is passed.
+    if (!dockerfileExists || versionOpt || forceOpt) {
+        await dockerfile(dockerfilePath, versionOpt, latestVersion);
+    }
+    // Run a command to check if matchstick image already exists
+    (0, child_process_1.exec)('docker images -q matchstick', (error, stdout, stderr) => {
+        // Collect all(if any) flags and options that have to be passed to the matchstick binary
+        let testArgs = '';
+        if (coverageOpt)
+            testArgs = testArgs + ' -c';
+        if (recompileOpt)
+            testArgs = testArgs + ' -r';
+        if (datasource)
+            testArgs = testArgs + ' ' + datasource;
+        // Build the `docker run` command options and flags
+        let dockerRunOpts = [
+            'run',
+            '-it',
+            '--rm',
+            '--mount',
+            `type=bind,source=${current_folder},target=/matchstick`,
+        ];
+        if (testArgs !== '') {
+            dockerRunOpts.push('-e');
+            dockerRunOpts.push(`ARGS=${testArgs.trim()}`);
+        }
+        dockerRunOpts.push('matchstick');
+        // If a matchstick image does not exists, the command returns an empty string,
+        // else it'll return the image ID. Skip `docker build` if an image already exists
+        // Delete current image(if any) and rebuild.
+        // Use spawn() and {stdio: 'inherit'} so we can see the logs in real time.
+        if (!dockerfileExists || stdout === '' || versionOpt || forceOpt) {
+            if (stdout !== '') {
+                (0, child_process_1.exec)('docker image rm matchstick', (error, stdout, stderr) => {
+                    gluegun_1.print.info(chalk_1.default.bold(`Removing matchstick image\n${stdout}`));
+                });
+            }
+            // Build a docker image. If the process has executed successfully
+            // run a container from that image.
+            (0, child_process_1.spawn)('docker', ['build', '-f', dockerfilePath, '-t', 'matchstick', '.'], {
+                stdio: 'inherit',
+            }).on('close', code => {
+                if (code === 0) {
+                    (0, child_process_1.spawn)('docker', dockerRunOpts, { stdio: 'inherit' });
+                }
+            });
+        }
+        else {
+            gluegun_1.print.info('Docker image already exists. Skipping `docker build` command.');
+            // Run the container from the existing matchstick docker image
+            (0, child_process_1.spawn)('docker', dockerRunOpts, { stdio: 'inherit' });
+        }
+    });
+}
+// Downloads Dockerfile template from the demo-subgraph repo
+// Replaces the placeholders with their respective values
+async function dockerfile(dockerfilePath, versionOpt, latestVersion) {
+    let spinner = gluegun_1.print.spin('Generating Dockerfile...');
+    try {
+        // Fetch the Dockerfile template content from the demo-subgraph repo
+        let content = await (0, node_fetch_1.default)('https://raw.githubusercontent.com/LimeChain/demo-subgraph/main/Dockerfile').then(response => {
+            if (response.ok) {
+                return response.text();
+            }
+            else {
+                throw new Error(`Status Code: ${response.status}, with error: ${response.statusText}`);
+            }
+        });
+        // Write the Dockerfile
+        await gluegun_1.filesystem.write(dockerfilePath, content);
+        // Replaces the version placeholders
+        await gluegun_1.patching.replace(dockerfilePath, '<MATCHSTICK_VERSION>', versionOpt || latestVersion);
+    }
+    catch (error) {
+        spinner.fail(`A problem occurred while generating the Dockerfile. Please attend to the errors below:\n ${error.message}`);
+        process.exit(1);
+    }
+    spinner.succeed('Successfully generated Dockerfile.');
+}

package/dist/compiler/asc.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = exports.ready = void 0;
+const asc = __importStar(require("assemblyscript/cli/asc"));
+const createExitHandler = (inputFile) => () => {
+    throw new Error(`The AssemblyScript compiler crashed when compiling this file: '${inputFile}'
+Suggestion: try to comment the whole file and uncomment it little by little while re-running the graph-cli until you isolate the line where the problem happens.
+Also, please contact us so we can make the CLI better by handling errors like this. You can reach out in any of these links:
+- Discord channel: https://discord.gg/eM8CA6WA9r
+- Github issues: https://github.com/graphprotocol/graph-cli/issues`);
+};
+const setupExitHandler = (exitHandler) => process.addListener('exit', exitHandler);
+const removeExitHandler = (exitHandler) => process.removeListener('exit', exitHandler);
+// Important note, the `asc.main` callback function parameter is synchronous,
+// that's why this function doesn't need to be `async` and the throw works properly.
+const assemblyScriptCompiler = (argv, options) => asc.main(argv, options, err => {
+    if (err) {
+        throw err;
+    }
+    return 0;
+});
+const compilerDefaults = {
+    stdout: process.stdout,
+    stderr: process.stdout,
+};
+// You MUST call this function once before compiling anything.
+// Internally it just delegates to the AssemblyScript compiler
+// which just delegates to the binaryen lib.
+const ready = async () => {
+    await asc.ready;
+};
+exports.ready = ready;
+// For now this function doesn't check if `asc` is ready, because
+// it requires an asynchronous wait. Whenever you call this function,
+// it doesn't matter how many times, just make sure you call `ready`
+// once before everything..
+const compile = ({ inputFile, global, baseDir, libs, outputFile, }) => {
+    const exitHandler = createExitHandler(inputFile);
+    setupExitHandler(exitHandler);
+    const compilerArgs = [
+        '--explicitStart',
+        '--exportRuntime',
+        '--runtime',
+        'stub',
+        inputFile,
+        global,
+        '--baseDir',
+        baseDir,
+        '--lib',
+        libs,
+        '--outFile',
+        outputFile,
+        '--optimize',
+        '--debug',
+    ];
+    assemblyScriptCompiler(compilerArgs, compilerDefaults);
+    // only if compiler succeded, that is, when the line above doesn't throw
+    removeExitHandler(exitHandler);
+};
+exports.compile = compile;