jitsu-cli 0.0.0

package/lib/lib/command/index.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subcommands = exports.executeCommand = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const version_1 = require("../version");
+function captureCommand(command, args) {
+    let commandParts = command.split(" ");
+    if (commandParts.length > args.length) {
+        return undefined;
+    }
+    for (let i = 0; i < commandParts.length; i++) {
+        if (commandParts[i] !== args[i]) {
+            return undefined;
+        }
+    }
+    return args.slice(commandParts.length);
+}
+function isHelpOption(arg) {
+    return arg === "-help" || arg === "--help" || arg === "help" || arg === "-?" || arg === "--?";
+}
+function isVersionOption(arg) {
+    return arg === "-version" || arg === "--version" || arg === "version" || arg === "-v" || arg === "--?";
+}
+function displayHelp(commands, helpOpts, cmd) {
+    if (helpOpts.customHelp) {
+        console.error(helpOpts.customHelp);
+        return;
+    }
+    if (!cmd) {
+        console.error("");
+        console.error(chalk_1.default.bold(`${helpOpts.binPrefix} <command> ...args — `) + `${helpOpts.description}`);
+        console.error("");
+        console.error("Available commands: ");
+        console.error("");
+        console.error(Object.keys(commands)
+            .map(cmd => {
+            return `  ${helpOpts.binPrefix} ${cmd} <options> - ${commands[cmd].description}`;
+        })
+            .join("\n"));
+        console.error("");
+        console.error(`To get help run ${chalk_1.default.bold(helpOpts.binPrefix + " <command> help")}:`);
+        console.error("");
+        console.error(Object.keys(commands)
+            .map(cmd => {
+            return `  ${helpOpts.binPrefix} ${cmd} help`;
+        })
+            .join("\n"));
+        console.error("");
+    }
+    else {
+        console.error("");
+        let command = commands[cmd];
+        if (!command) {
+            console.error(chalk_1.default.bold.red("Error!") + " Command " + chalk_1.default.bold(cmd) + " not found!");
+        }
+        else {
+            console.error(chalk_1.default.bold(`SYNOPSIS`));
+            console.error("");
+            console.error(chalk_1.default.bold(`  jitsu-cli ${cmd}`) + " - " + command.description);
+            if (command.help) {
+                console.error("");
+                console.error(command.help
+                    .trim()
+                    .split("\n")
+                    .map(ln => `${ln}`)
+                    .join("\n"));
+            }
+            console.error("");
+        }
+    }
+}
+const executeCommand = async (commands, args, helpOpts) => {
+    if (version_1.jitsuCliVersion !== "0.0.0") {
+        const newVersion = await (0, version_1.hasNewerVersion)();
+        if (newVersion) {
+            console.log((0, version_1.getUpgradeMessage)(newVersion, version_1.jitsuCliVersion));
+        }
+    }
+    if (args.length === 0 || isHelpOption(args[0])) {
+        displayHelp(commands, helpOpts);
+        return { success: true };
+    }
+    else if (args.length > 0 && isVersionOption(args[0])) {
+        console.error(`Jitsu CLI v${version_1.jitsuCliVersion}`);
+        return { success: true };
+    }
+    for (const [commandName, cmd] of Object.entries(commands)) {
+        let commandArgs = captureCommand(commandName, [...args]);
+        if (commandArgs) {
+            if (commandArgs.length > 0 && isHelpOption(commandArgs[0])) {
+                displayHelp(commands, helpOpts, commandName);
+                return { success: true };
+            }
+            else {
+                try {
+                    return await cmd.exec(commandArgs);
+                }
+                catch (e) {
+                    return { success: false, message: e?.message || "unknown error", details: e?.stack };
+                }
+            }
+        }
+    }
+    let error = `unknown command '${chalk_1.default.bold(args.join(" "))}'. Run ${chalk_1.default.bold(helpOpts.binPrefix + " help")} to see available options`;
+    return { success: false, message: error };
+};
+exports.executeCommand = executeCommand;
+function subcommands(commands, helpOpts) {
+    return {
+        description: helpOpts.description,
+        exec(args) {
+            return (0, exports.executeCommand)(commands, args, helpOpts);
+        },
+        help: helpOpts.customHelp || `Run ${helpOpts.binPrefix} help to see all available options`,
+    };
+}
+exports.subcommands = subcommands;

package/lib/lib/errors.d.ts

@@ -0,0 +1 @@
+export declare function appendError(msg: string, cause: any): string;

package/lib/lib/errors.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendError = void 0;
+function appendError(msg, cause) {
+    if (cause && cause.message) {
+        return `${msg}: ${cause.message}`;
+    }
+    else if (cause && typeof cause === "string") {
+        return `${msg}: ${cause}`;
+    }
+    else if (cause) {
+        return `${msg}: ${cause.toString()}`;
+    }
+    else {
+        return msg;
+    }
+}
+exports.appendError = appendError;

package/lib/lib/indent.d.ts

@@ -0,0 +1,9 @@
+export declare function removeIndentation(text: string, { trimLines }?: {
+    trimLines?: boolean | undefined;
+}): string;
+export declare function align(text: string, { indent, lnBefore, lnAfter }?: {
+    indent?: number | undefined;
+    lnBefore?: number | undefined;
+    lnAfter?: number | undefined;
+}): string;
+export declare function jsonify(obj: any): any;

package/lib/lib/indent.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonify = exports.align = exports.removeIndentation = void 0;
+function getIndentSize(line) {
+    let idx = 0;
+    for (; line.charAt(idx) === " " && idx < line.length; idx++) { }
+    return idx;
+}
+function removeIndentation(text, { trimLines = true } = {}) {
+    let lines = text.split("\n");
+    if (trimLines) {
+        let start = 0, end = lines.length - 1;
+        for (; lines[start].trim().length == 0 && start <= end; start++) { }
+        for (; lines[end].trim().length == 0 && end >= start; end--) { }
+        lines = lines.slice(start, end + 1);
+    }
+    let commonIndent = Math.min(...lines.filter(ln => ln.trim().length > 0).map(getIndentSize));
+    return lines.map(ln => ln.substring(commonIndent)).join("\n");
+}
+exports.removeIndentation = removeIndentation;
+function align(text, { indent = 0, lnBefore = 0, lnAfter = 0 } = {}) {
+    const cleanText = removeIndentation(text, { trimLines: true });
+    return [
+        ...new Array(lnBefore).fill(""),
+        ...cleanText.split("\n").map(ln => " ".repeat(indent) + ln),
+        ...new Array(lnAfter).fill(""),
+    ].join("\n");
+}
+exports.align = align;
+function jsonify(obj) {
+    if (typeof obj === "string") {
+        try {
+            return JSON.parse(obj);
+        }
+        catch (e) {
+            return obj;
+        }
+    }
+    return obj;
+}
+exports.jsonify = jsonify;

package/lib/lib/log.d.ts

@@ -0,0 +1,8 @@
+export declare type Log = {
+    debug: (msg?: string, ...args: any[]) => void;
+    info: (msg?: string, ...args: any[]) => void;
+    warn: (msg?: string, ...args: any[]) => void;
+    spinInfo: (...args: string[]) => void;
+    error: (...args: string[]) => void;
+};
+export default function getLog(): Log;

package/lib/lib/log.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+function log(delegate, styling, msg, args) {
+    if (!msg) {
+        delegate("");
+        return;
+    }
+    let consoleMsg = chalk_1.default[styling.color](`[${styling.prefix}]`) + " - " + msg;
+    if (args.length > 0) {
+        delegate(consoleMsg, args);
+    }
+    else {
+        delegate(consoleMsg);
+    }
+}
+function getLog() {
+    return {
+        error(msg, ...args) {
+            log(console.error, { prefix: "error", color: "red" }, msg, args);
+        },
+        warn(msg, ...args) {
+            log(console.warn, { prefix: "warn ", color: "yellow" }, msg, args);
+        },
+        spinInfo(args) { },
+        info(msg, ...args) {
+            log(console.info, { prefix: "info ", color: "cyan" }, msg, args);
+        },
+        debug(msg, ...args) {
+            log(console.debug, { prefix: "debug", color: "gray" }, msg, args);
+        },
+    };
+}
+exports.default = getLog;

package/lib/lib/template.d.ts

@@ -0,0 +1,5 @@
+export declare type TemplateVars = Record<string, any>;
+export declare type TemplateFunction<T> = (vars: T) => any;
+export declare type FileTemplate<T> = TemplateFunction<T> | string | any;
+export declare type ProjectTemplate<T extends TemplateVars = TemplateVars> = Record<string, FileTemplate<T>>;
+export declare function write(dir: string, template: ProjectTemplate, vars: TemplateVars): void;

package/lib/lib/template.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.write = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs = tslib_1.__importStar(require("fs"));
+const indent_1 = require("./indent");
+function toTemplateFunction(template) {
+    if (template === null || template === undefined) {
+        return () => undefined;
+    }
+    else if (typeof template === "function") {
+        return template;
+    }
+    else {
+        return () => template;
+    }
+}
+function write(dir, template, vars) {
+    Object.entries(template).forEach(([fileName, template]) => {
+        let filePath = path_1.default.resolve(dir, fileName);
+        let fileDir = path_1.default.dirname(filePath);
+        if (!fs.existsSync(fileDir)) {
+            fs.mkdirSync(fileDir, { recursive: true });
+        }
+        let content = toTemplateFunction(template)(vars);
+        if (typeof content === "object") {
+            content = JSON.stringify(content, null, 2);
+        }
+        if (content) {
+            let data = (0, indent_1.removeIndentation)(content);
+            fs.writeFileSync(filePath, data);
+        }
+    });
+}
+exports.write = write;

package/lib/lib/validation.d.ts

@@ -0,0 +1,2 @@
+import { ConfigValidator } from "@jitsu/types/extension";
+export declare function validateConfiguration<Config>(config: Config, validator: ConfigValidator): Promise<string | undefined>;

package/lib/lib/validation.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfiguration = void 0;
+async function validateConfiguration(config, validator) {
+    let validationResult;
+    try {
+        validationResult = await validator(config);
+    }
+    catch (e) {
+        return e?.message || "Unknown exception";
+    }
+    if (validationResult === true) {
+        return undefined;
+    }
+    if (typeof validationResult === "string") {
+        return validationResult;
+    }
+    if (typeof validationResult === "object" && !validationResult.ok) {
+        return validationResult.message ?? "Unknown error";
+    }
+    return undefined;
+}
+exports.validateConfiguration = validateConfiguration;

package/lib/lib/version.d.ts

@@ -0,0 +1,5 @@
+export declare const jitsuCliVersion: string;
+export declare const jitsuPackageName: string;
+export declare function getUpgradeMessage(newVersion: string, oldVersion: string): string;
+export declare function box(msg: string): string;
+export declare function hasNewerVersion(): Promise<string | undefined>;

package/lib/lib/version.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNewerVersion = exports.box = exports.getUpgradeMessage = exports.jitsuPackageName = exports.jitsuCliVersion = void 0;
+const tslib_1 = require("tslib");
+const package_json_1 = tslib_1.__importDefault(require("../../package.json"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("./log"));
+const preload_1 = tslib_1.__importDefault(require("semver/preload"));
+const fetch = require("cross-fetch");
+exports.jitsuCliVersion = package_json_1.default.version;
+exports.jitsuPackageName = package_json_1.default.name;
+let newVersion = undefined;
+function getUpgradeMessage(newVersion, oldVersion) {
+    return box(`🚀 New version of Jitsu CLI is available: ${oldVersion} → ${chalk_1.default.green(newVersion)} \n   Run ${chalk_1.default.bold("npm install -g " + exports.jitsuPackageName)} or ${chalk_1.default.bold("yarn global install " + exports.jitsuPackageName)}`);
+}
+exports.getUpgradeMessage = getUpgradeMessage;
+function padRight(str, minLen, symbol = " ") {
+    return str.length >= minLen ? str : str + symbol.repeat(minLen - str.length);
+}
+function box(msg) {
+    let lines = msg.split("\n");
+    return ["──".repeat(80), ...lines.map(ln => ` ${ln}`), "──".repeat(80)].join("\n");
+}
+exports.box = box;
+async function hasNewerVersion() {
+    try {
+        let json = (await (await fetch(`https://registry.npmjs.org/-/package/${exports.jitsuPackageName}/dist-tags`)).json());
+        let latestVersion = json.latest;
+        return preload_1.default.gt(latestVersion, exports.jitsuCliVersion) ? latestVersion : undefined;
+    }
+    catch (e) {
+        (0, log_1.default)().debug(`Failed to fetch latest version of ${exports.jitsuPackageName}: ${e?.message}`);
+    }
+}
+exports.hasNewerVersion = hasNewerVersion;

package/lib/package.json

@@ -0,0 +1,73 @@
+{
+    "name": "jitsu-cli",
+    "version": "0.0.0",
+    "publishConfig": {
+        "access": "public"
+    },
+    "description": " CLI interface of Jitsu (👉 https://jitsu.com),",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/jitsucom/jitsu-sdk",
+        "directory": "core/jitsu-cli"
+    },
+    "bugs": {
+        "url": "https://github.com/jitsucom/jitsu/issues"
+    },
+    "license": "MIT",
+    "bin": {
+        "jitsu-cli": "./bin/jitsu-cli"
+    },
+    "files": [
+        "lib",
+        "bin"
+    ],
+    "scripts": {
+        "build": "tsc -p . && mv ./lib/src/* ./lib/ && rmdir ./lib/src/",
+        "clean": "rm -rf ./lib",
+        "start": "ts-node src/index.ts",
+        "cli": "node lib/index.js",
+        "test": "jest --verbose ./__tests__"
+    },
+    "devDependencies": {
+        "@jitsu/types": "workspace:*",
+        "@babel/preset-env": "^7.16.4",
+        "@babel/preset-typescript": "^7.16.0",
+        "@types/commander": "^2.12.2",
+        "@types/inquirer": "^8.1.3",
+        "@types/jest": "^27.0.3",
+        "@types/jest-cli": "^24.3.0",
+        "@types/validate-npm-package-name": "^3.0.3",
+        "child_process": "^1.0.2",
+        "ts-node": "^10.4.0"
+    },
+    "dependencies": {
+        "@jitsu/jlib": "workspace:*",
+        "@jitsu/node-bridge": "workspace:*",
+        "@rollup/plugin-commonjs": "^22.0.0-14",
+        "@rollup/plugin-inject": "^4.0.4",
+        "@rollup/plugin-json": "^4.1.0",
+        "@rollup/plugin-multi-entry": "^4.1.0",
+        "@rollup/plugin-node-resolve": "^13.0.6",
+        "@types/prismjs": "^1.16.6",
+        "chalk": "^4.1.2",
+        "cli-table": "latest",
+        "commander": "^8.3.0",
+        "cross-fetch": "^3.1.4",
+        "inquirer": "^8.2.0",
+        "jest": "^27.3.1",
+        "jest-cli": "^27.3.1",
+        "json5": "^2.2.0",
+        "node-fetch": "^3.1.0",
+        "ora": "^6.0.1",
+        "prismjs": "^1.25.0",
+        "rollup": "^2.60.0",
+        "rollup-plugin-typescript2": "^0.31.0",
+        "semver": "^7.3.5",
+        "terminal-link": "^3.0.0",
+        "ts-jest": "^27.0.7",
+        "ts-node": "^10.4.0",
+        "tslib": "^2.3.1",
+        "typescript": "^4.5.2",
+        "validate-npm-package-name": "^3.0.0"
+    }
+}

package/lib/run.d.ts

@@ -0,0 +1 @@
+export declare function run(args: string[]): Promise<number>;

package/lib/run.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const command_1 = require("./lib/command");
+const extension_1 = require("./cli/extension");
+const log_1 = tslib_1.__importDefault(require("./lib/log"));
+const version_1 = require("./lib/version");
+const commands = {
+    extension: (0, command_1.subcommands)(extension_1.extensionCommands, {
+        description: "Commands for building Jitsu extension",
+        binPrefix: "jitsu-cli extension",
+        customHelp: extension_1.help,
+    }),
+};
+function exitWithError(error, details) {
+    console.error(`${chalk_1.default.bold.red("Error!")} - ${error}`);
+    if (details) {
+        console.error(details);
+    }
+    return 1;
+}
+async function run(args) {
+    let result = await (0, command_1.executeCommand)(commands, args, {
+        description: "CLI interface of " + chalk_1.default.bold("Jitsu") + `(👉 https://jitsu.com), version ${version_1.jitsuCliVersion}`,
+        binPrefix: "jitsu-cli",
+    });
+    if (result.success) {
+        (0, log_1.default)().info("✨ Done");
+        return 0;
+    }
+    else {
+        return exitWithError(result.message, result.details);
+    }
+}
+exports.run = run;

package/lib/tests.d.ts

@@ -0,0 +1,2 @@
+import { DestinationTestParams } from "@jitsu/types/tests";
+export declare function testDestination({ name, context, destination, event, expectedResult }: DestinationTestParams): void;

package/lib/tests.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testDestination = void 0;
+function testDestination({ name, context, destination, event, expectedResult }) {
+    test(name, () => {
+        const result = destination(event, context);
+        expect(result).toEqual(expectedResult);
+    });
+}
+exports.testDestination = testDestination;

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "jitsu-cli",
+  "version": "0.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": " CLI interface of Jitsu (👉 https://jitsu.com),",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jitsucom/jitsu-sdk",
+    "directory": "core/jitsu-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/jitsucom/jitsu/issues"
+  },
+  "license": "MIT",
+  "bin": {
+    "jitsu-cli": "./bin/jitsu-cli"
+  },
+  "files": [
+    "lib",
+    "bin"
+  ],
+  "devDependencies": {
+    "@jitsu/types": "0.0.0",
+    "@babel/preset-env": "^7.16.4",
+    "@babel/preset-typescript": "^7.16.0",
+    "@types/commander": "^2.12.2",
+    "@types/inquirer": "^8.1.3",
+    "@types/jest": "^27.0.3",
+    "@types/jest-cli": "^24.3.0",
+    "@types/validate-npm-package-name": "^3.0.3",
+    "child_process": "^1.0.2",
+    "ts-node": "^10.4.0"
+  },
+  "dependencies": {
+    "@jitsu/jlib": "0.0.0",
+    "@jitsu/node-bridge": "0.0.0",
+    "@rollup/plugin-commonjs": "^22.0.0-14",
+    "@rollup/plugin-inject": "^4.0.4",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-multi-entry": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.6",
+    "@types/prismjs": "^1.16.6",
+    "chalk": "^4.1.2",
+    "cli-table": "latest",
+    "commander": "^8.3.0",
+    "cross-fetch": "^3.1.4",
+    "inquirer": "^8.2.0",
+    "jest": "^27.3.1",
+    "jest-cli": "^27.3.1",
+    "json5": "^2.2.0",
+    "node-fetch": "^3.1.0",
+    "ora": "^6.0.1",
+    "prismjs": "^1.25.0",
+    "rollup": "^2.60.0",
+    "rollup-plugin-typescript2": "^0.31.0",
+    "semver": "^7.3.5",
+    "terminal-link": "^3.0.0",
+    "ts-jest": "^27.0.7",
+    "ts-node": "^10.4.0",
+    "tslib": "^2.3.1",
+    "typescript": "^4.5.2",
+    "validate-npm-package-name": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p . && mv ./lib/src/* ./lib/ && rmdir ./lib/src/",
+    "clean": "rm -rf ./lib",
+    "start": "ts-node src/index.ts",
+    "cli": "node lib/index.js",
+    "test": "jest --verbose ./__tests__"
+  }
+}