asl-validator/dist/bin/asl-validator.js

Amazon States Language validator

#!/usr/bin/env node
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
var _a, _b;
Object.defineProperty(exports, "__esModule", { value: true });
var fs_1 = __importDefault(require("fs"));
var path_1 = __importDefault(require("path"));
var commander_1 = require("commander");
var yaml_1 = __importDefault(require("yaml"));
var validator_1 = __importDefault(require("../src/validator"));
var ExitCode;
(function (ExitCode) {
    ExitCode[ExitCode["Success"] = 0] = "Success";
    ExitCode[ExitCode["ValidationError"] = 1] = "ValidationError";
    ExitCode[ExitCode["ProgramError"] = 2] = "ProgramError";
})(ExitCode || (ExitCode = {}));
function exit(exitCode) {
    process.exit(exitCode);
}
function collect(value, previous) {
    return previous.concat([value]);
}
function getVersion(packageJsonPath) {
    if (!fs_1.default.existsSync(packageJsonPath)) {
        return null;
    }
    var version = JSON.parse(fs_1.default.readFileSync(packageJsonPath).toString()).version;
    return version;
}
commander_1.program
    .description("Amazon States Language validator")
    // make it work whether it is compiled or not
    .version((_b = (_a = getVersion(path_1.default.join(__dirname, "../package.json"))) !== null && _a !== void 0 ? _a : getVersion(path_1.default.join(__dirname, "../../package.json"))) !== null && _b !== void 0 ? _b : "")
    .option("--json-definition <jsonDefinition>", "JSON definition", collect, [])
    .option("--json-path <jsonPath>", "JSON path", collect, [])
    .option("--yaml-definition <yamlDefinition>", "YAML definition", collect, [])
    .option("--yaml-path <yamlPath>", "YAML path", collect, [])
    .option("--silent", "silent mode")
    .option("--no-path-check", "skips checking path expressions")
    .option("--no-arn-check", "skips the arn check for Resource values")
    .parse();
var options = commander_1.program.opts();
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function log() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    if (!options.silent) {
        // eslint-disable-next-line no-console, @typescript-eslint/no-unsafe-argument
        console.log.apply(console, args);
    }
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function error() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    if (!options.silent) {
        // eslint-disable-next-line no-console, @typescript-eslint/no-unsafe-argument
        console.error.apply(console, args);
    }
}
function validate(name, definition) {
    try {
        var validationOpts = {
            checkArn: !options.noArnCheck,
            checkPaths: !options.noPathCheck,
        };
        var result = (0, validator_1.default)(definition, validationOpts);
        if (result.isValid) {
            log("\u2713 State machine definition \"".concat(name, "\" is valid"));
            return ExitCode.Success;
        }
        error("\u2715 State machine definition \"".concat(name, "\" is invalid:\n"), result.errorsText());
        return ExitCode.ValidationError;
    }
    catch (err) {
        error("Validator exception:", err);
        return ExitCode.ProgramError;
    }
}
function main() {
    var _a, _b, _c, _d;
    try {
        var jsonDefinitions = ((_a = options.jsonDefinition) !== null && _a !== void 0 ? _a : []);
        var jsonPaths = ((_b = options.jsonPath) !== null && _b !== void 0 ? _b : []);
        var yamlDefinitions = ((_c = options.yamlDefinition) !== null && _c !== void 0 ? _c : []);
        var yamlPaths = ((_d = options.yamlPath) !== null && _d !== void 0 ? _d : []);
        if (jsonDefinitions.length === 0 &&
            jsonPaths.length === 0 &&
            yamlDefinitions.length === 0 &&
            yamlPaths.length === 0) {
            log("No state machine to validate.");
            commander_1.program.help();
        }
        var exitCode_1 = ExitCode.Success;
        // Validate JSON definitions
        jsonDefinitions.forEach(function (jsonDefinition, index) {
            var name = "JSON definition #".concat(index + 1);
            var definition;
            try {
                definition = JSON.parse(jsonDefinition);
                exitCode_1 = Math.max(validate(name, definition));
            }
            catch (err) {
                error("Unable to parse ".concat(name));
            }
        });
        // Validate JSON paths
        jsonPaths.forEach(function (jsonPath) {
            var definition = JSON.parse(fs_1.default.readFileSync(jsonPath).toString());
            exitCode_1 = Math.max(exitCode_1, validate(jsonPath, definition));
        });
        // Validate YAML definitions
        yamlDefinitions.forEach(function (yamlDefinition, index) {
            var name = "YAML definition #".concat(index + 1);
            var definition;
            try {
                definition = yaml_1.default.parse(yamlDefinition);
                exitCode_1 = Math.max(validate(name, definition));
            }
            catch (err) {
                error("Unable to parse ".concat(name));
            }
        });
        // Validate YAML paths
        yamlPaths.forEach(function (yamlPath) {
            var definition = yaml_1.default.parse(fs_1.default.readFileSync(yamlPath).toString());
            exitCode_1 = Math.max(exitCode_1, validate(yamlPath, definition));
        });
        exit(exitCode_1);
    }
    catch (err) {
        error(err);
        exit(ExitCode.ProgramError);
    }
}
main();