zcatalyst-cli 1.20.2 → 1.22.0

package/lib/fn-utils/lib/java/compile.js

@@ -0,0 +1,222 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printCompilationLog = exports.compileTarget = exports.warningMessages = void 0;
+const path_1 = require("path");
+const constants_1 = require("../../../util_modules/constants");
+const ensure_java_userconfig_1 = require("./ensure-java-userconfig");
+const fs_1 = require("../../../util_modules/fs");
+const config_1 = require("../../../util_modules/config");
+const option_1 = require("../../../util_modules/option");
+const index_1 = require("../../../util_modules/logger/index");
+const shell_1 = require("../../../util_modules/shell");
+const ansi_colors_1 = require("ansi-colors");
+const logger_1 = require("../../../util_modules/logger");
+const _1 = require(".");
+const userConfig_1 = __importDefault(require("../../../userConfig"));
+exports.warningMessages = [
+    'warning: [options] bootstrap class path not set in conjunction with -source 8',
+    'warning: [options] system modules path not set in conjunction with -source 11'
+];
+function compileTarget(target) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        const targetSource = target.source;
+        const outputFolder = (0, path_1.join)(targetSource, constants_1.FOLDERNAME.output);
+        const integ = target.integ_config;
+        const entries = [(0, path_1.join)(targetSource, ((_a = target.index) === null || _a === void 0 ? void 0 : _a.replace(/\./g, path_1.sep)) + '.java')];
+        if (integ && integ.length > 0) {
+            integ.forEach((integConf) => {
+                const handlers = integConf.handlers;
+                handlers &&
+                    Object.keys(handlers).forEach((handler) => {
+                        entries.push((0, path_1.join)(targetSource, handlers[handler].replace(/\./g, path_1.sep) + '.java'));
+                    });
+            });
+        }
+        yield fs_1.ASYNC.ensureDir(outputFolder);
+        yield fs_1.ASYNC.emptyDir(outputFolder);
+        const ignore = config_1.functionsConfig.ignore(targetSource);
+        const allFiles = yield fs_1.ASYNC.walk(targetSource, {
+            filter: { exclude: ['**/.output', ...ignore], excludeDir: true }
+        });
+        const cleanUpFiles = allFiles.map((file) => file.path);
+        while (allFiles.length > 0) {
+            const limit = allFiles.length < 20 ? allFiles.length : 20;
+            yield Promise.all(allFiles.splice(0, limit).map((file) => {
+                const targetPth = file.path.includes(path_1.sep + 'lib' + path_1.sep)
+                    ? file.path.replace(targetSource + path_1.sep + 'lib', '')
+                    : file.path.replace(targetSource, '');
+                return fs_1.ASYNC.copyFile(file.path, (0, path_1.join)(outputFolder, targetPth));
+            }));
+        }
+        const targetVersion = (0, ensure_java_userconfig_1.getTargetVersion)(target.stack);
+        const spawnCommand = (0, ensure_java_userconfig_1.getJavaSpawnCommand)('javac', (_b = target.additionalInfo) === null || _b === void 0 ? void 0 : _b.binPath);
+        yield Promise.all(entries.map((file) => compileJavaFiles(file, spawnCommand, targetVersion, targetSource, outputFolder)
+            .then((result) => {
+            const [_stdout, stderr, code] = result;
+            if (code === null || code >= 1) {
+                const error = [];
+                error === null || error === void 0 ? void 0 : error.push(stderr);
+                target.valid = false;
+                target.failure_reason = 'there was a Java compilation error';
+                if (!target.additionalInfo) {
+                    return;
+                }
+                target.additionalInfo.compilerOut.error = error;
+            }
+            else if (stderr) {
+                if (!target.additionalInfo) {
+                    return;
+                }
+                target.additionalInfo.compilerOut.warning = [stderr];
+            }
+        })
+            .catch((error) => {
+            target.valid = false;
+            target.failure_reason = error.message;
+        })));
+        const currentCommand = (0, option_1.getCurrentCommand)();
+        switch (currentCommand) {
+            case 'pull':
+            case 'init':
+                yield cleanUp(cleanUpFiles);
+                break;
+            case 'deploy':
+                const classPath = (0, path_1.join)(outputFolder, constants_1.FILENAME.functions.java_classpath);
+                if (yield fs_1.ASYNC.fileExists(classPath)) {
+                    const classPathFile = yield fs_1.ASYNC.readFile(classPath);
+                    if (classPathFile) {
+                        yield fs_1.ASYNC.writeFile(classPath, classPathFile.replace(/lib[\\|\/]/g, ''));
+                    }
+                }
+                break;
+        }
+    });
+}
+exports.compileTarget = compileTarget;
+function compileJavaFiles(file, spawnCommand, targetVersion, targetSource, outputFolder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, index_1.message)('Compiling ' + file);
+        return new Promise((resolve, reject) => {
+            var _a, _b;
+            const child = (0, shell_1.spawn)(spawnCommand, [
+                '-target',
+                targetVersion,
+                '-source',
+                targetVersion,
+                '-cp',
+                '*' + _1.classPathSep + '.',
+                '-g',
+                '-Xprefer:source',
+                userConfig_1.default.get('javac.disable_warnings') === 'true' ? '-Xlint:none' : '-Xlint',
+                file.replace(targetSource, outputFolder)
+            ], {
+                cwd: outputFolder,
+                stdio: 'pipe'
+            }).RAW();
+            let stdout = '';
+            let stderr = '';
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                stdout += data.toString();
+            });
+            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+                const err = data.toString();
+                let newErr = '';
+                exports.warningMessages.forEach((element) => {
+                    if (err.includes(element)) {
+                        newErr += err.replace(element, '');
+                    }
+                });
+                if (!newErr) {
+                    newErr += err;
+                }
+                stderr += newErr;
+            });
+            child.on('error', (error) => {
+                reject(error);
+            });
+            child.on('close', (code) => {
+                resolve([stdout, stderr, code]);
+            });
+        });
+    });
+}
+function cleanUp(files) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const promiseArr = [];
+        const deleteArr = [];
+        const hashes = {};
+        files.forEach((file, idx) => {
+            if (file.endsWith('.java')) {
+                const hash = hashes[file];
+                if (hash === undefined) {
+                    hashes[file] = { found: true, acc: [] };
+                }
+                else {
+                    hash.found = true;
+                    deleteArr.push(...hash.acc);
+                }
+            }
+            else if (file.endsWith('.class')) {
+                const javaFile = file.replace(new RegExp('(\\$+[0-9]+)?\\.class$', 'g'), '.java');
+                const hashValue = hashes[javaFile];
+                if (hashValue === undefined) {
+                    hashes[javaFile] = { found: false, acc: [file] };
+                }
+                else if (hashValue.found === true) {
+                    files.splice(idx, 1);
+                    promiseArr.push(fs_1.ASYNC.deleteFile(file));
+                }
+                else if (hashValue.found === false) {
+                    hashValue.acc.push(file);
+                }
+            }
+        });
+        return Promise.all([...deleteArr.map((file) => fs_1.ASYNC.deleteFile(file)), ...promiseArr]);
+    });
+}
+function printCompilationLog(javaFns) {
+    const isJavaFnLog = javaFns === null || javaFns === void 0 ? void 0 : javaFns.some((target) => {
+        var _a, _b, _c, _d, _e, _f;
+        return ((_c = (_b = (_a = target.additionalInfo) === null || _a === void 0 ? void 0 : _a.compilerOut) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.length) ||
+            ((_f = (_e = (_d = target.additionalInfo) === null || _d === void 0 ? void 0 : _d.compilerOut) === null || _e === void 0 ? void 0 : _e.warning) === null || _f === void 0 ? void 0 : _f.length);
+    });
+    if (isJavaFnLog) {
+        index_1.local.info();
+        index_1.local.info((0, ansi_colors_1.italic)('Java Compilation logs: '));
+        javaFns === null || javaFns === void 0 ? void 0 : javaFns.forEach((target) => {
+            var _a, _b, _c, _d;
+            const error = (_b = (_a = target.additionalInfo) === null || _a === void 0 ? void 0 : _a.compilerOut) === null || _b === void 0 ? void 0 : _b.error;
+            if (error && error.length > 0) {
+                index_1.local.info();
+                index_1.local.info(`${(0, ansi_colors_1.red)(logger_1.CHAR.error)} Error while compiling the function[${target.name}]`);
+                index_1.local.info();
+            }
+            error === null || error === void 0 ? void 0 : error.forEach((error) => {
+                index_1.local.info(error);
+            });
+            const warning = (_d = (_c = target.additionalInfo) === null || _c === void 0 ? void 0 : _c.compilerOut) === null || _d === void 0 ? void 0 : _d.warning;
+            if (warning && warning.length > 0) {
+                index_1.local.info();
+                index_1.local.warn(`${(0, ansi_colors_1.yellow)(logger_1.CHAR.warning)} Warning while compiling the function[${target.name}]`);
+                index_1.local.info();
+            }
+            warning === null || warning === void 0 ? void 0 : warning.forEach((warn) => {
+                index_1.local.warn(warn);
+            });
+        });
+    }
+}
+exports.printCompilationLog = printCompilationLog;

package/lib/fn-utils/lib/java/ensure-java-userconfig.d.ts

@@ -0,0 +1,22 @@
+export declare const stackVsVersions: {
+    java8: {
+        version: string;
+        target: string;
+        label: string;
+    };
+    java11: {
+        version: string;
+        target: string;
+        label: string;
+    };
+    java17: {
+        version: string;
+        target: string;
+        label: string;
+    };
+};
+type javaProcess = 'java' | 'javac';
+export declare function ensureJava(stack: string): Promise<string | void>;
+export declare function getJavaSpawnCommand(process: javaProcess, binPath?: string): string;
+export declare function getTargetVersion(stack: string): string;
+export {};

package/lib/fn-utils/lib/java/ensure-java-userconfig.js

@@ -0,0 +1,264 @@
+'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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTargetVersion = exports.getJavaSpawnCommand = exports.ensureJava = exports.stackVsVersions = void 0;
+const semver_1 = require("semver");
+const error_1 = __importDefault(require("../../../error"));
+const runtime_store_1 = __importDefault(require("../../../runtime-store"));
+const userConfig_1 = __importDefault(require("../../../userConfig"));
+const shell_1 = require("../../../util_modules/shell");
+const path_1 = require("path");
+const ansi_colors_1 = require("ansi-colors");
+const index_1 = require("../../../util_modules/logger/index");
+const env_1 = require("../../../util_modules/env");
+const jdk_utils_1 = require("jdk-utils");
+exports.stackVsVersions = {
+    java8: {
+        version: '1.8.x',
+        target: '1.8',
+        label: 'Java 8'
+    },
+    java11: {
+        version: '11.x',
+        target: '11',
+        label: 'Java 11'
+    },
+    java17: {
+        version: '17.x',
+        target: '17',
+        label: 'Java 17'
+    }
+};
+class JavaRuntimes {
+    constructor(runtimes) {
+        this.runtimes = {};
+        runtimes.forEach((runT) => {
+            var _a;
+            const major = (_a = runT.version) === null || _a === void 0 ? void 0 : _a.major;
+            if (!major) {
+                return;
+            }
+            if (!this.runtimes[major]) {
+                this.runtimes[major] = [];
+            }
+            this.runtimes[major].push(runT);
+        });
+    }
+    static init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new JavaRuntimes(yield (0, jdk_utils_1.findRuntimes)({ checkJavac: true, withVersion: true, withTags: true }));
+        });
+    }
+    get(version) {
+        version = version.replace('java', '');
+        return this.runtimes[version];
+    }
+    getBinPath(version) {
+        var _a, _b;
+        version = version.replace('java', '');
+        const home = (_b = (_a = this.runtimes[version]) === null || _a === void 0 ? void 0 : _a.at(0)) === null || _b === void 0 ? void 0 : _b.homedir;
+        if (!home) {
+            return;
+        }
+        return (0, path_1.join)(home, 'bin');
+    }
+}
+function ensureJava(stack) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const configKey = `${stack}.bin`;
+        const binPath = env_1.isVsCode
+            ? runtime_store_1.default.get(`executables.${configKey}`)
+            : userConfig_1.default.get(configKey);
+        if (!binPath) {
+            const javaRuntimes = yield JavaRuntimes.init();
+            const runtimeArr = javaRuntimes.get(stack);
+            if (runtimeArr && runtimeArr.length > 1) {
+                if (env_1.isVsCode) {
+                    (0, index_1.info)();
+                    (0, index_1.labeled)(stack, `Found more than one java runtime for java major version ${stack.replace('java', '')} in the below paths`).WARN();
+                    runtimeArr === null || runtimeArr === void 0 ? void 0 : runtimeArr.forEach((rn) => {
+                        (0, index_1.labeled)(stack, '  * ' + rn.homedir).WARN();
+                    });
+                    (0, index_1.info)();
+                    (0, index_1.labeled)(stack, `Please specify the required java runtime for stack ${stack} using the "zcatalyst.${configKey}" config`).WARN();
+                    (0, index_1.info)();
+                    return;
+                }
+                const rnWithJavac = runtimeArr.find((rn) => rn.hasJavac);
+                throw new error_1.default('Found more than one java version for stack : ' + stack, {
+                    exit: 1,
+                    errorId: 'JAVA_CONFIG_MORE_RN',
+                    arg: [
+                        stack.replace('java', ''),
+                        runtimeArr.map((rn) => '* ' + rn.homedir).join('\n'),
+                        (0, ansi_colors_1.bold)('catalyst config:set'),
+                        (0, ansi_colors_1.bold)(`catalyst config:set ${configKey}=${(rnWithJavac && (0, ansi_colors_1.underline)((0, path_1.join)(rnWithJavac.homedir, 'bin'))) ||
+                            '<java_bin_folder_path>'}`)
+                    ]
+                });
+            }
+            const runtime = runtimeArr === null || runtimeArr === void 0 ? void 0 : runtimeArr.at(0);
+            if (!runtime) {
+                if (env_1.isVsCode) {
+                    (0, index_1.labeled)(stack, 'Unable to detect the java version for stack: ' + stack).ERROR();
+                    (0, index_1.labeled)(stack, `Please install the required JDK version and configure it using the "zcatalyst.${configKey}" settings`).ERROR();
+                    (0, index_1.info)();
+                }
+                throw new error_1.default('Unable to detect the java version for stack: ' + stack, {
+                    errorId: 'JAVA_CONFIG-1',
+                    exit: 1,
+                    arg: [stack]
+                });
+            }
+            if (!runtime.hasJavac) {
+                if (env_1.isVsCode) {
+                    (0, index_1.labeled)(stack, 'Unable to detect the javac executable for stack: ' + stack).ERROR();
+                    (0, index_1.labeled)(stack, 'Please install the required JDK version and configure it using the ' + env_1.isVsCode
+                        ? ` "catalyst config:set ${configKey}=<java_bin_dir_path>" command`
+                        : `zcatalyst.${configKey} settings`).ERROR();
+                    (0, index_1.info)();
+                }
+                throw new error_1.default('Unable to detect javac executable for stack: ' + stack, {
+                    errorId: 'JAVA_CONFIG_JAVAC',
+                    exit: 1,
+                    arg: [stack]
+                });
+            }
+            return (0, path_1.join)(runtime.homedir, 'bin');
+        }
+        if (binPath === 'java') {
+            const runtime = (yield JavaRuntimes.init()).get(stack);
+            const wJavac = runtime === null || runtime === void 0 ? void 0 : runtime.find((rn) => rn.hasJavac);
+            throw new error_1.default('Cannot specify the java command in config', {
+                exit: 1,
+                errorId: 'JAVA_CONFIG_2',
+                arg: [
+                    (0, ansi_colors_1.bold)(configKey),
+                    ansi_colors_1.bold.red(binPath),
+                    (0, ansi_colors_1.bold)('catalyst config:set'),
+                    (0, ansi_colors_1.bold)('catalyst config:set ' +
+                        configKey +
+                        '=' +
+                        (wJavac ? (0, ansi_colors_1.underline)((0, path_1.join)(wJavac.homedir, 'bin')) : '<java_bin_dir_path>'))
+                ]
+            });
+        }
+        try {
+            const foundStack = yield findJavaVersion(binPath);
+            if (!foundStack || !(foundStack in exports.stackVsVersions)) {
+                if (env_1.isVsCode) {
+                    (0, index_1.labeled)(stack, `The required Java runtime version for ${stack} was not found in the supplied setting zcatalyst.${configKey}=${(0, ansi_colors_1.underline)(binPath)}`).ERROR();
+                    (0, index_1.labeled)(stack, `Please install the required java version and configure it using the zcatalyst.${configKey} settings`).ERROR();
+                    (0, index_1.info)();
+                    return;
+                }
+                throw new error_1.default('Unable to find the required java version from bin path: ' + binPath, {
+                    exit: 1,
+                    errorId: 'JAVA_CONFIG-1A',
+                    arg: [(0, ansi_colors_1.bold)(configKey), (0, ansi_colors_1.underline)((0, path_1.join)(binPath, (0, ansi_colors_1.red)('java'))), stack, 'java']
+                });
+            }
+            if (foundStack !== stack) {
+                if (env_1.isVsCode) {
+                    (0, index_1.labeled)(stack, `The version of java executable found in the bin path from the config ${stack}.bin does not match with the required stack`).ERROR();
+                    (0, index_1.labeled)(stack, `Please specify a valid bin path for the stack ${stack} in the settings "zcatalyst.${configKey}"`).ERROR();
+                    (0, index_1.info)();
+                    return;
+                }
+                throw new error_1.default('Bin path version mismatch', {
+                    exit: 1,
+                    errorId: 'JAVA_CONFIG_V_MISS',
+                    arg: [(0, ansi_colors_1.bold)(configKey), (0, ansi_colors_1.bold)(stack)]
+                });
+            }
+        }
+        catch (er) {
+            const error = error_1.default.getErrorInstance(er, { skipHelp: true });
+            if (error.original instanceof Error &&
+                'code' in error.original &&
+                ((_a = error.original) === null || _a === void 0 ? void 0 : _a.code) === 'ENOENT') {
+                throw new error_1.default('Unable to find the java executable in your machine', {
+                    exit: 1,
+                    errorId: 'JAVA_CONFIG-1A',
+                    original: error,
+                    arg: [(0, ansi_colors_1.bold)(`${stack}.bin`), (0, ansi_colors_1.underline)((0, path_1.join)(binPath, (0, ansi_colors_1.red)('java'))), stack, 'java']
+                });
+            }
+            throw error;
+        }
+        try {
+            yield findJavaCVersion(binPath);
+        }
+        catch (er) {
+            const error = error_1.default.getErrorInstance(er, { skipHelp: true });
+            if (error.original instanceof Error &&
+                'code' in error.original &&
+                error.original.code === 'ENOENT') {
+                throw new error_1.default(`Unable to check the javac version using the given binary path: ${binPath}`, {
+                    exit: 1,
+                    errorId: 'JAVA_CONFIG-1A',
+                    arg: [
+                        (0, ansi_colors_1.bold)(`${stack}.bin`),
+                        (0, ansi_colors_1.underline)((0, path_1.join)(binPath, (0, ansi_colors_1.red)('javac'))),
+                        stack,
+                        'javac'
+                    ]
+                });
+            }
+            throw error;
+        }
+        return binPath ? binPath : '';
+    });
+}
+exports.ensureJava = ensureJava;
+function findJavaVersion(bin) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const javaVersionOut = yield (0, shell_1.spawn)(getJavaSpawnCommand('java', bin), ['-version'], {
+            stdio: 'pipe'
+        }).ASYNC();
+        const version = (_a = (javaVersionOut.stdout || javaVersionOut.stderr).match(/"([0-9._]+)"/)) === null || _a === void 0 ? void 0 : _a.at(1);
+        if (!version) {
+            throw new error_1.default('Unable to detect the version for the java executable from path: ' + bin, {
+                exit: 2
+            });
+        }
+        const coercedVersion = (0, semver_1.coerce)(version);
+        if (!coercedVersion) {
+            return;
+        }
+        return Object.keys(exports.stackVsVersions).find((stack) => (0, semver_1.satisfies)(coercedVersion, exports.stackVsVersions[stack].version));
+    });
+}
+function findJavaCVersion(bin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const javaCVersionOut = yield (0, shell_1.spawn)(getJavaSpawnCommand('javac', bin), ['-version'], {
+            stdio: 'pipe'
+        }).ASYNC();
+        const javaCVersion = (0, semver_1.valid)((0, semver_1.coerce)((javaCVersionOut.stdout || javaCVersionOut.stderr).split(' ')[1]));
+        if (!javaCVersion) {
+            throw new error_1.default('Unable to detect the version for the javac executable from path: ' + bin, { exit: 2 });
+        }
+        return javaCVersion;
+    });
+}
+function getJavaSpawnCommand(process, binPath) {
+    return binPath ? (0, path_1.join)(binPath, process) : process;
+}
+exports.getJavaSpawnCommand = getJavaSpawnCommand;
+function getTargetVersion(stack) {
+    return exports.stackVsVersions[stack].target;
+}
+exports.getTargetVersion = getTargetVersion;

package/lib/fn-utils/lib/java/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+import { TEMPLATE } from '../../../util_modules/constants/index.js';
+import { IFnTarget, JavaFn } from '../common.js';
+export { FN_TYPE } from '../../../util_modules/constants/index.js';
+export declare const classPathSep: string;
+export declare function isValidClassName(name: string): boolean;
+export declare function ensureJavaInvoker(pth: string, invoker: string, target: IFnTarget<JavaFn>): boolean;
+export declare function projectFileValidation(pth: string, target: IFnTarget): Promise<void>;
+export declare function extractAllData(child: ChildProcess, name: 'stderr' | 'stdout'): Promise<string>;
+export declare function validate(targets: Array<IFnTarget<JavaFn>>): Promise<void>;
+export declare function getTemplatePath(fnType: keyof typeof TEMPLATE.functions.java, add?: string): string;
+export * from './classpath';
+export * from './compile';
+export * from './ensure-java-userconfig.js';
+export * from './keywords';