vdev/dist/block.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.specialPathResolve = exports.loadBlock = exports.loadBlocks = exports.loadDockerBlocks = exports.buildBlock = exports.watchBlock = exports.buildBlocksOrBundles = exports.cleanNodeFiles = exports.updateVersions = void 0;
const backlib_1 = require("backlib");
const chokidar = __importStar(require("chokidar"));
const fs = __importStar(require("fs-extra"));
const p_spawn_1 = require("p-spawn");
const Path = __importStar(require("path"));
const processors_1 = require("./processors");
const utils_1 = require("./utils");
const vdev_config_1 = require("./vdev-config");
// --------- /Public Types --------- //
async function updateVersions(config) {
    var _a, _b;
    if (!config) {
        config = await vdev_config_1.loadVdevConfig();
    }
    const versionFiles = (_b = (_a = config.version) === null || _a === void 0 ? void 0 : _a.files) !== null && _b !== void 0 ? _b : null;
    // if we do not have version files, we skip.
    if (versionFiles == null) {
        return;
    }
    const newVersion = config.__version__;
    let firstUpdate = false; // flag that will be set 
    try {
        for (let file of versionFiles) {
            const originalContent = (await fs.readFile(file, 'utf8')).toString();
            const isHTML = file.toLowerCase().endsWith('html');
            let fileAppVersion = getVersion(originalContent, isHTML);
            if (newVersion !== fileAppVersion) {
                // On the first update needed, we start the log section for the version update
                if (!firstUpdate) {
                    console.log(`----- Version Update: Updating '__version__ = ".."' or '?v=..' to ${newVersion} `);
                    firstUpdate = true;
                }
                console.log(`Changing  ${fileAppVersion} -> ${newVersion} in file: ${file}`);
                let newContent = replaceVersion(originalContent, newVersion, isHTML);
                await fs.writeFile(file, newContent, 'utf8');
            }
            else {
                // Note: for now, we do not log when nothing to do.
            }
        }
    }
    catch (ex) {
        throw new Error(`ERROR while doing versioning files - ${ex.message}`);
    }
    // if we have at least one update, we close the log section.
    if (firstUpdate) {
        console.log('----- /Version Update: done');
    }
}
exports.updateVersions = updateVersions;
// FIXME: Needs to look at the "blocks" from the config
async function cleanNodeFiles() {
    const filesToDelete = ['./package-lock.json', './node_blockules'];
    const blocks = await loadBlocks();
    // dirs.unshift('./'); // we do not clean the base dir, as it is easy to do by hand, and then, scripts won't work
    // TODO: probably need to add web-server as well
    for (const block of Object.values(blocks)) {
        const dir = block.dir;
        for (let fName of filesToDelete) {
            const fileToDelete = Path.join(dir, fName);
            if ((await fs.pathExists(fileToDelete))) {
                await backlib_1.saferRemove(fileToDelete);
            }
        }
    }
}
exports.cleanNodeFiles = cleanNodeFiles;
/**
 *
 * @param names List of block name or block/bundle names
 */
async function buildBlocksOrBundles(names) {
    if (names.length === 0) {
        const blocks = await loadBlocks();
        for (let block of Object.values(blocks)) {
            await _buildBlock(block);
        }
    }
    else {
        for (let name of names) {
            const blockAndBundle = name.split('/');
            // if only .length === 1 then blockAndBundle[1] which is fine
            await buildBlock(blockAndBundle[0], { onlyBundleName: blockAndBundle[1] });
        }
    }
}
exports.buildBlocksOrBundles = buildBlocksOrBundles;
// TODO: needs to add support for any block rule watch
// TODO: needs to add support for only one bundle watch
async function watchBlock(blockName) {
    var _a;
    const blocks = await loadBlocks();
    const block = blocks[blockName];
    const webBundles = (block) ? block.webBundles : null;
    if (webBundles == null) {
        throw new Error(`Block ${blockName} not found or does not have a '.webBundles'. As of now, can only watch webBundles`);
    }
    for (let bundle of webBundles) {
        await initWebBundle(block, bundle);
        // The rollup have a watch block, so we use it
        if (bundle.type === 'js' || bundle.type === 'ts') {
            if (bundle.watch) {
                console.log(`WARNING - Ignoring '.watch' property for bundle ${bundle.name} for .js/.ts processing
				as rollup watches dependencies. (advice: remove this .watch property for clarity)`);
            }
            await _buildBlock(block, bundle, { watch: true });
        }
        // Otherwise, we just watch the entries or the watch, and rebuild everything
        else {
            await _buildBlock(block, bundle);
            const toWatch = (_a = bundle.watch) !== null && _a !== void 0 ? _a : bundle.entries;
            let watcher = chokidar.watch(toWatch, { persistent: true });
            // TODO: Needs to use a call reducer
            watcher.on('change', async function (filePath, stats) {
                if (filePath.endsWith(`.${bundle.type}`)) {
                    await _buildBlock(block, bundle);
                }
            });
        }
    }
}
exports.watchBlock = watchBlock;
const blockBuilt = new Set();
/**
 * Build a and block and eventually a bundle
 * @param blockName
 * @param opts
 */
async function buildBlock(blockName, opts) {
    const blockByName = await loadBlocks();
    const block = blockByName[blockName];
    if (blockBuilt.has(block.name)) {
        console.log(`------ Block ${block.name} already built - SKIP\n`);
        return;
    }
    if (!block) {
        throw new Error(`No block found for blockeName ${blockName}.`);
    }
    let bundle;
    const onlyBundleName = opts === null || opts === void 0 ? void 0 : opts.onlyBundleName;
    if (onlyBundleName && block.webBundles) {
        bundle = block.webBundles.find((b) => (b.name == onlyBundleName));
        if (!bundle) {
            throw new Error(`No webBundle ${onlyBundleName} found in block ${block.name}`);
        }
        await initWebBundle(block, bundle);
    }
    await _buildBlock(block, bundle, opts);
    blockBuilt.add(block.name);
}
exports.buildBlock = buildBlock;
async function _buildBlock(block, bundle, opts) {
    const hasPomXml = await fs.pathExists(Path.join(block.dir, 'pom.xml'));
    const hasPackageJson = await fs.pathExists(Path.join(block.dir, 'package.json'));
    const hasTsConfig = await fs.pathExists(Path.join(block.dir, 'tsconfig.json'));
    const hasWebBundles = (block.webBundles) ? true : false;
    // Note: if we have a bundleName, then, just the bundle log will be enough.
    const start = utils_1.now();
    if (!bundle) {
        console.log(`------ Building Block ${block.name} ${block.dir}`);
    }
    // no matter what, if we have a pckageJson, we make sure we do a npm install
    if (hasPackageJson) {
        await npmInstall(block);
    }
    // if we have a webBundles, we build it
    if (hasWebBundles) {
        // TODO: need to allow to give a bundle name to just build it
        await buildWebBundles(block, bundle, opts);
    }
    // run tsc (with clean dist/ folder),  if it is not a webBundle (assume rollup will take care of the ts when webBundles)
    if (!hasWebBundles && hasTsConfig) {
        await buildTsSrc(block);
    }
    if (hasPomXml) {
        await runMvn(block, opts ? opts.full : false);
    }
    if (!bundle) {
        await utils_1.printLog(`------ Building Block ${block.name} DONE`, start);
        console.log();
    }
}
async function npmInstall(block) {
    await p_spawn_1.spawn('npm', ['install'], { cwd: block.dir });
}
async function buildTsSrc(block) {
    const distDirNeedsDelete = false;
    const distDir = Path.join(block.dir, '/dist/');
    const distDirExist = await fs.pathExists(distDir);
    // if we have distDirExist, check that it define as compileOptions.outDir in 
    if (distDirExist) {
        const tsconfigObj = await utils_1.readJsonFileWithComments(Path.join(block.dir, 'tsconfig.json'));
        let outDir = tsconfigObj.compilerOptions.outDir;
        outDir = (outDir) ? Path.join(block.dir, outDir, '/') : null; // add a ending '/' to normalize all of the dir path with ending / (join will remove duplicate)
        if (outDir === distDir) {
            console.log(`tsc prep - deleting tsc distDir ${distDir}`);
            await backlib_1.saferRemove(distDir);
        }
        else {
            console.log(`tss prep - skipping tsc distDir ${distDir} because does not match tsconfig.json compilerOptions.outDir ${outDir}`);
        }
    }
    // Assume there is a typescript installed in the root project
    await p_spawn_1.spawn('./node_modules/.bin/tsc', ['-p', block.dir]);
}
async function runMvn(block, full) {
    const args = ['clean', 'package'];
    if (!full) {
        args.push('-Dmaven.test.skip=true');
    }
    var start = utils_1.now();
    await p_spawn_1.spawn('mvn', args, {
        toConsole: false,
        cwd: block.dir,
        onStderr: function (data) {
            process.stdout.write(data);
        }
    });
    await utils_1.printLog(`maven build ${full ? 'with test' : ''}`, start);
}
// bundlers by type (which is file extension without '.')
const bundlers = {
    ts: buildTsBundler,
    pcss: buildPcssBundler,
    tmpl: buildTmplBundler,
    html: buildTmplBundler,
    js: buildJsBundler
};
async function buildWebBundles(block, onlyBundle, opts) {
    let webBundles;
    if (onlyBundle) {
        // the onlyBundle is already initialized
        webBundles = [onlyBundle];
    }
    else {
        webBundles = block.webBundles;
        // we need to initialize the webBundles
        for (let bundle of webBundles) {
            await initWebBundle(block, bundle);
        }
    }
    for (let bundle of webBundles) {
        await ensureDist(bundle);
        var start = utils_1.now();
        await bundlers[bundle.type](block, bundle, opts);
        if (opts === null || opts === void 0 ? void 0 : opts.watch) {
            await utils_1.printLog(`Starting watch mode for ${block.name}/${bundle.name} (${bundle.dist})`, start);
        }
        else {
            await utils_1.printLog(`Building bundle ${block.name}/${bundle.name}`, start, bundle.dist);
        }
    }
}
const rollupOptionsDefaults = {
    ts: {
        watch: false,
        ts: true,
        tsconfig: './tsconfig.json'
    },
    js: {
        watch: false,
        ts: false
    }
};
/**
 * Initialize all of the bundle properties accordingly.
 * This allow the bundlers and other logic to not have to worry about default values and path resolution.
 */
async function initWebBundle(block, bundle) {
    bundle.type = Path.extname(utils_1.asNames(bundle.entries)[0]).substring(1);
    // for now, just take the block.dir
    bundle.dir = specialPathResolve('', block.dir, bundle.dir);
    // Make the entries relative to the Block
    bundle.entries = utils_1.asNames(bundle.entries).map((f) => specialPathResolve('', bundle.dir, f));
    // If bundle.watch, same as entries above
    if (bundle.watch) {
        // Make the watch relative to the Block
        bundle.watch = utils_1.asNames(bundle.watch).map((f) => specialPathResolve('', bundle.dir, f));
    }
    // resolve the dist
    bundle.dist = specialPathResolve('', block.baseDistDir, bundle.dist);
    // --------- rollupOptions initialization --------- //
    if (bundle.type === 'ts' || bundle.type === 'js') {
        // get the base default options for this type
        const rollupOptionsDefault = rollupOptionsDefaults[bundle.type];
        // override default it if bundle has one
        const rollupOptions = (bundle.rollupOptions) ? { ...rollupOptionsDefault, ...bundle.rollupOptions }
            : { ...rollupOptionsDefault };
        // resolve tsconfig
        if (rollupOptions.tsconfig) {
            rollupOptions.tsconfig = specialPathResolve('', bundle.dir, rollupOptions.tsconfig);
        }
        // set the new optoins back.
        bundle.rollupOptions = rollupOptions;
    }
    // --------- /rollupOptions initialization --------- //
}
// --------- /Private WebBundle Utils --------- //
// --------- Private Bundlers --------- //
async function buildTsBundler(block, bundle, opts) {
    // TODO: need to re-enable watch
    try {
        if (opts && opts.watch) {
            bundle.rollupOptions.watch = true;
        }
        // resolve all of the entries (with glob)
        const allEntries = await resolveGlobs(bundle.entries);
        await processors_1.rollupFiles(allEntries, bundle.dist, bundle.rollupOptions);
    }
    catch (ex) {
        // TODO: need to move exception ahndle to the caller
        console.log("BUILD ERROR - something when wrong on rollup\n\t", ex);
        console.log("Empty string was save to the app bundle");
        console.log("Trying saving again...");
        return;
    }
}
async function buildPcssBundler(block, bundle, opts) {
    const allEntries = await resolveGlobs(bundle.entries);
    await processors_1.pcssFiles(allEntries, bundle.dist);
}
async function buildTmplBundler(block, bundle, opts) {
    const allEntries = await resolveGlobs(bundle.entries);
    await processors_1.tmplFiles(allEntries, bundle.dist);
}
async function buildJsBundler(block, bundle, opts) {
    if (opts && opts.watch) {
        bundle.rollupOptions.watch = true;
    }
    const allEntries = await resolveGlobs(bundle.entries);
    await processors_1.rollupFiles(allEntries, bundle.dist, bundle.rollupOptions);
}
// --------- /Private Bundlers --------- //
// --------- Public Loaders --------- //
async function loadDockerBlocks() {
    const blocks = await loadBlocks();
    const dockerBlocks = {};
    for (let block of Object.values(blocks)) {
        const hasDockerfile = await fs.pathExists(Path.join(block.dir, 'Dockerfile'));
        if (hasDockerfile) {
            dockerBlocks[block.name] = block;
        }
    }
    return dockerBlocks;
}
exports.loadDockerBlocks = loadDockerBlocks;
async function loadBlocks() {
    const rawConfig = await vdev_config_1.loadVdevConfig();
    const rawBlocks = rawConfig.blocks;
    const base = {
        system: rawConfig.system,
        __version__: rawConfig.__version__,
        imageTag: rawConfig.imageTag
    };
    // build the services map from the raw services list
    const blockByName = rawBlocks.map((item) => {
        let block;
        let name;
        // initialize the object
        if (typeof item === 'string') {
            block = {
                name: item
            };
        }
        else {
            if (!item.name) {
                throw new Error(`the build config file vdev.yaml has a block without '.name'`);
            }
            // we do a shallow clone			
            block = { ...item };
        }
        //// add the system/version (they should not been set in the block anyway)
        if (block.system != null || block.__version__ != null) {
            throw new Error(`.system or .__version__ cannot be set at the block level (but found in ${block.name})`);
        }
        Object.assign(block, base);
        // if the block does not have a dir, then, build it with the parent one
        if (!block.dir) {
            block.dir = Path.join(rawConfig.baseBlockDir, `${block.name}/`);
        }
        return block;
    }).reduce((map, block) => {
        map[block.name] = block;
        return map;
    }, {});
    return blockByName;
}
exports.loadBlocks = loadBlocks;
async function loadBlock(name) {
    const blocks = await loadBlocks();
    const block = blocks[name];
    if (!block) {
        throw new Error(`Block ${name} not found`);
    }
    return block;
}
exports.loadBlock = loadBlock;
// --------- /Public Loaders --------- //
// --------- Private Utils --------- //
/** Since 0.11.18 each string glob is sorted within their match, but if globs is an array, the order of each result glob result is preserved. */
async function resolveGlobs(globs) {
    if (typeof globs === 'string') {
        return backlib_1.glob(globs);
    }
    else {
        const lists = [];
        for (const globStr of globs) {
            const list = await backlib_1.glob(globStr);
            lists.push(list);
        }
        return lists.flat();
    }
}
//#region    ---------- version Utils ---------- 
/** Return the first version found. For html, looks for the `src|href=....?v=___` and for other files the version = ... */
function getVersion(content, isHtml = false) {
    // look for the href or src ?v=...
    if (isHtml) {
        const rgx = /<.*(href|src).*?v=(.*?)(\"|\&)/gm;
        const r = rgx.exec(content);
        if (r != null && r.length > 2) {
            return r[2];
        }
        else {
            return null;
        }
    }
    // look for the version = ...
    else {
        var rx = new RegExp('__version__' + '\\s*[=:]\\s*[\'"](.*)[\'"]', 'i');
        var match = content.match(rx);
        return (match) ? match[1] : null;
    }
}
function replaceVersion(content, value, isHtml = false) {
    if (isHtml) {
        const rgxRep = /(<.*(href|src).*?v=).*?(\"|\&.*)/g;
        // $2 not is not used because it is included as part of $1
        return content.replace(rgxRep, '$1' + value + '$3');
    }
    else {
        var rx = new RegExp('(.*' + '__version__' + '\\s*[=:]\\s*["\']).*([\'"].*)', 'i');
        content = content.replace(rx, '$1' + value + '$2');
        return content;
    }
}
//#endregion ---------- /version Utils ---------- 
async function ensureDist(bundle) {
    const distDir = Path.dirname(bundle.dist);
    await fs.ensureDir(distDir);
}
/**
 * Special resolve that
 *   - if finalPath null, then, return dir.
 *   - resolve any path to dir if it starts with './' or '../',
 *   - absolute path if it starts with '/'
 *   - baseDir if the path does not start with either '/' or './'
 * @param baseDir
 * @param dir
 * @param finalPath dir or file path
 */
function specialPathResolve(baseDir, dir, finalPath) {
    if (finalPath == null) {
        return dir;
    }
    if (finalPath.startsWith('/')) {
        return finalPath;
    }
    if (finalPath.startsWith('./') || finalPath.startsWith('../')) {
        return Path.join(dir, finalPath);
    }
    return Path.join(baseDir, finalPath);
}
exports.specialPathResolve = specialPathResolve;
// --------- /Private Utils --------- //