@methodus/contracts/dist/build.functions.js

This package is part of the Methodus tollbelt. It's purpose is generating contract packages of the server code, to be used by JavaScript browser / server clients.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Builder = void 0;
const path = require("path");
const colors = require("colors");
const rimraf = require("rimraf");
const client_1 = require("./builder-models/client");
const common_1 = require("./builder-models/common");
const server_1 = require("./builder-models/server");
const Console = console;
async function Builder(options, contract) {
    let buildConfiguration;
    const pkg = require(path.join('..', 'package.json'));
    Console.log(colors.blue(`>> methodus ${options.isClient ? 'client' : 'server'} contract builder. v${pkg.version}`));
    let publish = false;
    const buildPath = process.argv[2] ? process.argv[2].toString() : './build.json';
    const filePath = contract || path.resolve(path.join(process.cwd(), buildPath));
    Console.log(colors.green('>> loading build configuration from:'), filePath);
    buildConfiguration = require(filePath);
    options.publish = process.argv[3] === '-p' || publish;
    if (buildConfiguration.protobuf) {
        options.isProtobuf = true;
    }
    const checkList = [];
    await build(buildConfiguration, checkList, options);
    Console.log(checkList.join('\n'));
    Console.log('>> completed build plan, exiting.');
    return true;
}
exports.Builder = Builder;
async function singleBuild(configurationItem, destPath, checkList, options) {
    let sourcePath = process.cwd();
    if (!configurationItem.buildPath) {
        configurationItem.buildPath = '../../';
    }
    if (configurationItem.path) {
        sourcePath = path.resolve(configurationItem.path);
    }
    Console.log(colors.cyan('> source:'), sourcePath);
    //delete the src folder
    rimraf.sync(path.join(destPath, 'src'));
    Console.log(colors.cyan('> target:'), destPath);
    try {
        if (configurationItem !== null) {
            let builder = null;
            if (options.isClient) {
                builder = new client_1.Client(configurationItem, sourcePath, destPath);
            }
            else {
                builder = new server_1.Server(configurationItem, sourcePath, destPath);
            }
            options.source = sourcePath;
            options.target = destPath;
            const targetProject = await common_1.Common.newCommonFlow(configurationItem, '', options);
            const emitResult = await targetProject.project.emit();
            for (const diagnostic of emitResult.getDiagnostics()) {
                console.warn(diagnostic.getMessageText());
            }
            return builder;
        }
    }
    catch (error) {
        checkList.push(`${configurationItem}: error`);
        Console.error(error);
    }
    return null;
}
async function postBuild(destPath, checkList, builder, singleConfiguration, options) {
    if (!process.env.KEEP_SRC) {
        rimraf.sync(path.join(destPath, 'src'));
    }
    if (options.publish) {
        builder.publish(destPath);
    }
    checkList.push(`${singleConfiguration}: ok`);
}
async function build(buildConfiguration, checkList, options) {
    for (const singleConfiguration of Object.keys(buildConfiguration)) {
        const configurationItem = buildConfiguration[singleConfiguration];
        Console.log(colors.green(` > ${singleConfiguration}`));
        const destPath = path.resolve(path.join(configurationItem.buildPath, options.isClient ? configurationItem.contractNameClient : configurationItem.contractNameServer));
        const builder = await singleBuild(configurationItem, destPath, checkList, options);
        try {
            await postBuild(destPath, checkList, builder, singleConfiguration, options);
        }
        catch (error) {
            Console.error(error);
        }
    }
    return true;
}
//# sourceMappingURL=build.functions.js.map