@ehmpathy/as-command/dist/asCommand.js

easily create commands within a pit-of-success

"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;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.asCommand = void 0;
const bottleneck_1 = __importDefault(require("bottleneck"));
const crypto = __importStar(require("crypto"));
const date_fns_1 = require("date-fns");
const fs = __importStar(require("fs/promises"));
const bottleneckFileLog = new bottleneck_1.default({ maxConcurrency: 1 });
/**
 * converts any function into a pit-of-success command
 *
 * features
 * - observability
 *   - logs inputs, outputs, and errors to console
 *   - persists inputs, outputs, and errors to file storage (locally and optionally to s3)
 * - parallelism
 *   - supports parallel operations with progress reporting
 * - experience
 *   - easily pass in inputs from the command line
 */
const asCommand = (options, logic) => (input) => __awaiter(void 0, void 0, void 0, function* () {
    const calledAt = new Date();
    // define the log file directory and name
    const inputHash = crypto
        .createHash('sha256')
        .update(JSON.stringify(input))
        .digest('hex');
    const logFileDirectory = `${options.dir}/__tmp__/${options.stage}/${options.name}`;
    const logFilePrefix = `${(0, date_fns_1.format)(calledAt, 'yyyyMMdd.HHmmss')}.${inputHash}`;
    const logFileName = `${logFilePrefix}.log.json`;
    const outFileName = `${logFilePrefix}.out.json`;
    // find or create the temp log table
    yield fs.mkdir(logFileDirectory, {
        recursive: true,
    });
    // define how to log something
    const logLevelAbstraction = (level, message, metadata) => __awaiter(void 0, void 0, void 0, function* () {
        return bottleneckFileLog.schedule(() => __awaiter(void 0, void 0, void 0, function* () {
            options.log[level](message, metadata);
            return fs.appendFile(`${logFileDirectory}/${logFileName}`, `${JSON.stringify({ level, timestamp: new Date().toISOString(), message, metadata }, null, 2)},\n`);
        }));
    });
    // define the wrapped logger
    const log = {
        debug: (message, metadata) => logLevelAbstraction('debug', message, metadata),
        info: (message, metadata) => logLevelAbstraction('info', message, metadata),
        warn: (message, metadata) => logLevelAbstraction('warn', message, metadata),
        error: (message, metadata) => logLevelAbstraction('error', message, metadata),
    };
    // log the inputs
    yield fs.appendFile(`${logFileDirectory}/${logFileName}`, '[\n');
    yield log.info('input', { input });
    try {
        // execute the logic
        const output = yield logic(input, {
            log,
            out: {
                write: (_a) => __awaiter(void 0, [_a], void 0, function* ({ name, data }) {
                    const path = `${logFileDirectory}/${logFilePrefix}.out.${name}`;
                    yield fs.writeFile(path, data);
                    return { path };
                }),
            },
        });
        // log the output
        yield log.info('output.result', { output });
        // save the output
        yield fs.appendFile(`${logFileDirectory}/${outFileName}`, typeof output === 'string'
            ? output
            : JSON.stringify(output, null, 2) || 'undefined');
        // log out where the user can find them
        yield log.info('output.files', {
            log: `${logFileDirectory}/${logFileName}`,
            out: `${logFileDirectory}/${outFileName}`,
        });
        // return the output
        return output;
    }
    catch (error) {
        if (!(error instanceof Error))
            throw error;
        // log the error
        yield log.error('output.error', {
            error: Object.assign(Object.assign({}, error), { message: error.message }),
        });
        // rethrow the error
        throw error;
    }
    finally {
        yield fs.appendFile(`${logFileDirectory}/${logFileName}`, ']\n');
    }
});
exports.asCommand = asCommand;
//# sourceMappingURL=asCommand.js.map