cobolget/out/install.js

COBOL Package Manager

"use strict";
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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.install = void 0;
const api_1 = require("./api");
const path = require("path");
const fs = require("fs");
const unzipper = require("unzipper");
function install(options) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            const fileCopybook = path.join(process.cwd(), api_1.MODULES_DIR, api_1.COPYBOOK_NAME);
            const fileLibrary = path.join(process.cwd(), api_1.MODULES_DIR, api_1.LIBRARY_NAME);
            const modulesDir = path.join(process.cwd(), api_1.MODULES_DIR);
            const manifestParent = JSON.parse(fs.readFileSync(path.join(process.cwd(), api_1.MANIFEST_NAME)).toString());
            // find installed
            let installed = {};
            if (fs.existsSync(fileCopybook)) {
                const regex = /\s+@package\s+([a-z0-9\\-]+)\s+(.*)\s?/g;
                fs.readFileSync(fileCopybook).toString().split(/\n/).forEach((line) => {
                    let match = regex.exec(line);
                    if (match) {
                        installed[match[1]] = match[2];
                    }
                });
            }
            // create modules dir
            if (!fs.existsSync(modulesDir)) {
                fs.mkdirSync(modulesDir);
            }
            // remove modules if any
            if (fs.existsSync(fileCopybook)) {
                fs.unlinkSync(fileCopybook);
            }
            if (fs.existsSync(fileLibrary)) {
                fs.unlinkSync(fileLibrary);
            }
            let copybook = [];
            const lockFile = path.join(process.cwd(), api_1.LOCK_NAME);
            const lock = JSON.parse(fs.readFileSync(lockFile).toString());
            for (let item in lock) {
                copybook.push(`      *> @package ${lock[item].name} ${lock[item].version}`);
                let manifest;
                if (!fs.existsSync(path.join(process.cwd(), api_1.MODULES_DIR, lock[item].name)) || !installed.hasOwnProperty(lock[item].name) || installed[lock[item].name] !== lock[item].version) {
                    // download zip
                    console.log(`Downloading ${lock[item].name} ${lock[item].version}`);
                    const zip = yield api_1.downloadZip(lock[item].name, lock[item].version, options.token !== undefined ? options.token : null);
                    const directory = yield unzipper.Open.buffer(zip);
                    const file = directory.files.find((entry) => entry.path.endsWith(api_1.MANIFEST_NAME));
                    // extract zip
                    const prefix = file.path.replace(api_1.MANIFEST_NAME, '');
                    for (const entry of directory.files) {
                        entry.path = entry.path.replace(prefix, '');
                        const file = path.join(process.cwd(), api_1.MODULES_DIR, lock[item].name, entry.path.replace(prefix, ''));
                        if (entry.type === 'Directory') {
                            if (!fs.existsSync(file)) {
                                fs.mkdirSync(file);
                            }
                        }
                        else {
                            entry.stream().pipe(fs.createWriteStream(file));
                        }
                        console.log(file);
                    }
                    manifest = JSON.parse((yield file.buffer()).toString());
                }
                else {
                    manifest = JSON.parse(fs.readFileSync(path.join(process.cwd(), api_1.MODULES_DIR, lock[item].name, api_1.MANIFEST_NAME)).toString());
                }
                // add modules
                if (lock[item].debug) {
                    manifest.modules.forEach((module) => {
                        copybook.push(`      D COPY "${module}" OF "${api_1.MODULES_DIR}/${lock[item].name}".`);
                        fs.appendFileSync(fileLibrary, fs.readFileSync(path.join(process.cwd(), api_1.MODULES_DIR, lock[item].name, module)).toString());
                        fs.appendFileSync(fileLibrary, "\n");
                    });
                }
                else {
                    manifest.modules.forEach((module) => {
                        copybook.push(`       COPY "${module}" OF "${api_1.MODULES_DIR}/${lock[item].name}".`);
                        fs.appendFileSync(fileLibrary, fs.readFileSync(path.join(process.cwd(), api_1.MODULES_DIR, lock[item].name, module)).toString());
                        fs.appendFileSync(fileLibrary, "\n");
                    });
                }
            }
            // add parent modules
            manifestParent['modules'].forEach((module) => {
                copybook.push(`       COPY "${module}".`);
                fs.appendFileSync(fileLibrary, fs.readFileSync(path.join(process.cwd(), module)).toString());
                fs.appendFileSync(fileLibrary, "\n");
            });
            // add EOF
            copybook.push('');
            // save copybook
            fs.writeFileSync(path.join(process.cwd(), api_1.MODULES_DIR, api_1.COPYBOOK_NAME), copybook.join("\n"));
            console.log(`Modules ${api_1.COPYBOOK_NAME} and ${api_1.LIBRARY_NAME} updated.`);
        }
        catch (e) {
            console.log(`An error occurred: ${e}.`);
        }
    });
}
exports.install = install;