jitsu-cli 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Jitsu Labs, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# Jitsu CLI
+
+#### Quick start
+
+```
+npx jitsu-cli --help
+```
+
+Submodule of [Jitsu SDK](https://github.com/jitsucom/jitsu-sdk).
+
+[Read more →](https://github.com/jitsucom/jitsu-sdk).

package/bin/jitsu-cli

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../lib/index.js");

package/lib/cli/extension/build.d.ts

@@ -0,0 +1,2 @@
+import { CommandResult } from "../../lib/command/types";
+export declare function build(args: string[]): Promise<CommandResult>;

package/lib/cli/extension/build.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importDefault(require("../../lib/log"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const errors_1 = require("../../lib/errors");
+const rollup_1 = require("rollup");
+const rollup_plugin_typescript2_1 = tslib_1.__importDefault(require("rollup-plugin-typescript2"));
+const plugin_multi_entry_1 = tslib_1.__importDefault(require("@rollup/plugin-multi-entry"));
+const plugin_json_1 = tslib_1.__importDefault(require("@rollup/plugin-json"));
+const plugin_node_resolve_1 = tslib_1.__importDefault(require("@rollup/plugin-node-resolve"));
+const plugin_commonjs_1 = tslib_1.__importDefault(require("@rollup/plugin-commonjs"));
+const version_1 = require("../../lib/version");
+const _1 = require("./");
+const JSON5 = tslib_1.__importStar(require("json5"));
+function fixNodeFetch(code) {
+    return code.replace("throw new TypeError('Expected signal to be an instanceof AbortSignal');", "");
+}
+function insertStreamReaderFacade(targetFile) {
+    return {
+        name: "insert-stream-reader-facade",
+        transform: async (code, id) => {
+            const [path] = id.split("?");
+            if (path === targetFile) {
+                let newCode = [
+                    `import * as srcLib from "@jitsu/jlib/lib/sources-lib";`,
+                    code,
+                    ";",
+                    `export const __$srcLib = srcLib;`,
+                ].join("\n");
+                return { code: newCode };
+            }
+            return null;
+        },
+    };
+}
+async function build(args) {
+    const directory = args?.[0] || "";
+    let projectBase = path_1.default.isAbsolute(directory) ? directory : path_1.default.resolve(process.cwd() + "/" + directory);
+    (0, log_1.default)().info("🔨 Building project in " + chalk_1.default.bold(projectBase) + ` with ${version_1.jitsuPackageName}@${version_1.jitsuCliVersion} `);
+    if (!fs_1.default.existsSync(projectBase)) {
+        throw new Error(`Path ${projectBase} does not exist`);
+    }
+    let packageFile = path_1.default.resolve(projectBase, "package.json");
+    if (!fs_1.default.existsSync(packageFile)) {
+        return { success: false, message: "Can't find package.json in " + projectBase };
+    }
+    let packageJson;
+    try {
+        packageJson = JSON5.parse(fs_1.default.readFileSync(packageFile, "utf8"));
+    }
+    catch (e) {
+        throw new Error((0, errors_1.appendError)(`Failed to parse package.json at ${projectBase}`, e));
+    }
+    let distFile = (0, _1.getDistFile)(packageJson);
+    let fullOutputPath = path_1.default.resolve(projectBase, distFile);
+    (0, log_1.default)().info("📦 Bundle will be written to " + chalk_1.default.bold(fullOutputPath));
+    let tsConfigPath = path_1.default.resolve(projectBase, "tsconfig.json");
+    const typescriptEnabled = fs_1.default.existsSync(tsConfigPath);
+    if (typescriptEnabled) {
+        (0, log_1.default)().info(`Found ${chalk_1.default.bold("tsconfig.json")}, typescript will be enabled`);
+    }
+    else {
+        return {
+            success: false,
+            message: `${chalk_1.default.bold("tsconfig.json")} is not found in the root of the project. Pure JS extensions are not supported yet`,
+        };
+    }
+    (0, _1.validateTsConfig)(tsConfigPath);
+    (0, log_1.default)().info("Building project...");
+    try {
+        let indexFile = path_1.default.resolve(projectBase, "src/index.ts");
+        if (!fs_1.default.existsSync(indexFile)) {
+            return { success: false, message: `Project should have src/index.ts file. Can't find it at ${indexFile}` };
+        }
+        const bundle = await (0, rollup_1.rollup)({
+            input: [indexFile],
+            plugins: [
+                typescriptEnabled && (0, rollup_plugin_typescript2_1.default)({ cwd: projectBase }),
+                insertStreamReaderFacade(indexFile),
+                (0, plugin_multi_entry_1.default)(),
+                (0, plugin_node_resolve_1.default)({ preferBuiltins: false }),
+                (0, plugin_commonjs_1.default)(),
+                (0, plugin_json_1.default)(),
+            ],
+        });
+        let format = "cjs";
+        let output = await bundle.generate({
+            generatedCode: "es5",
+            format: format,
+            exports: "named",
+            banner: `//format=${format}`,
+            outro: [
+                `exports.buildInfo = {sdkVersion: "${version_1.jitsuCliVersion}", sdkPackage: "${version_1.jitsuPackageName}", buildTimestamp: "${new Date().toISOString()}"};`,
+                `exports.streamReader$StdoutFacade = exports.streamReader && __$srcLib.stdoutStreamReader(exports.streamReader);`,
+            ].join("\n"),
+        });
+        let code = fixNodeFetch(output.output[0].code);
+        fs_1.default.mkdirSync(path_1.default.dirname(fullOutputPath), { recursive: true });
+        fs_1.default.writeFileSync(fullOutputPath, code);
+        (0, log_1.default)().info("Validating build");
+        const exports = await (0, _1.loadBuild)(fullOutputPath);
+        if (!exports.destination && !exports.transform && !(exports.streamReader && exports.sourceCatalog)) {
+            return {
+                success: false,
+                message: `${chalk_1.default.bold(indexFile)} should export ${chalk_1.default.italic("destination")}, ${chalk_1.default.italic("transform")} or both ${chalk_1.default.italic("streamReader")} and ${chalk_1.default.italic("sourceCatalog")} symbols. It exports: ` +
+                    Object.keys(exports).join(", "),
+            };
+        }
+        else if (exports.destination && exports.transform) {
+            return {
+                success: false,
+                message: `${chalk_1.default.bold(indexFile)} exports both ${chalk_1.default.italic("destination")} and ${chalk_1.default.italic("transform")} symbol. It should export either of them` + Object.keys(exports).join(", "),
+            };
+        }
+    }
+    catch (e) {
+        if (e.id && e.loc && e.frame) {
+            return {
+                success: false,
+                message: "Build failed: " +
+                    e.message +
+                    `\n\n  See: ${e.loc.file}:${e.loc.line}\n\n` +
+                    `${e.frame
+                        .split("\n")
+                        .map(ln => "  " + chalk_1.default.bgRed(" ") + " " + ln)
+                        .join("\n")}`,
+            };
+        }
+        return { success: false, message: (0, errors_1.appendError)("Build failed", e), details: e?.stack };
+    }
+    return { success: true };
+}
+exports.build = build;

package/lib/cli/extension/create.d.ts

@@ -0,0 +1,2 @@
+import { CommandResult } from "../../lib/command/types";
+export declare function create(args: string[]): Promise<CommandResult>;

package/lib/cli/extension/create.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const tslib_1 = require("tslib");
+const commander_1 = tslib_1.__importDefault(require("commander"));
+const validate_npm_package_name_1 = tslib_1.__importDefault(require("validate-npm-package-name"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const log_1 = tslib_1.__importDefault(require("../../lib/log"));
+const template_1 = require("../../lib/template");
+const template_2 = require("./template");
+async function create(args) {
+    const program = new commander_1.default.Command();
+    program.option("-t, --type <project type>", "project type (destination or source)");
+    program.option("-d, --dir <project_dir>", "project dir");
+    program.option("-n, --name <project_name>", "project name");
+    program.option("-j, --jitsu-version <jitsu_version>", "Jitsu version");
+    program.parse(["dummy", "dummy", ...args]);
+    let cliOpts = program.opts();
+    if (cliOpts.name) {
+        let isValid = (0, validate_npm_package_name_1.default)(cliOpts.name);
+        if (!isValid.validForNewPackages) {
+            return { success: false, message: `Can't use ${cliOpts.name} as package name: ${isValid.errors}` };
+        }
+    }
+    let packageType = cliOpts.type ||
+        (await inquirer_1.default.prompt([
+            {
+                type: "list",
+                name: "package",
+                message: [
+                    `What is the type of extension?`,
+                    ` ${chalk_1.default.bold("destination")} adds a new type of HTTP-based destination to Jitsu`,
+                    ` ${chalk_1.default.bold("source")}   adds a new source extension to Jitsu`,
+                ].join("\n"),
+                choices: ["destination", "source"],
+            },
+        ])).package;
+    let packageName = cliOpts.name ||
+        (await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "package",
+                message: "Please, provide project name:",
+                validate: input => {
+                    let isValid = (0, validate_npm_package_name_1.default)(input);
+                    if (!isValid.validForNewPackages) {
+                        return `Can't use ${input} as package name: ${isValid.errors}`;
+                    }
+                    return true;
+                },
+            },
+        ])).package;
+    let projectDir = cliOpts.dir ||
+        (await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "directory",
+                message: "Project directory:",
+                default: path_1.default.resolve(".", packageName),
+                validate: input => {
+                    let projectBase = path_1.default.resolve(input);
+                    if (fs_1.default.existsSync(projectBase)) {
+                        if (!fs_1.default.lstatSync(projectBase).isDirectory() || fs_1.default.readdirSync(projectBase).length > 0) {
+                            return `${input} should be an non-existent or empty directory`;
+                        }
+                    }
+                    return true;
+                },
+            },
+        ])).directory;
+    projectDir = path_1.default.resolve(projectDir);
+    (0, log_1.default)().info("Creating new jitsu project in " + chalk_1.default.bold(projectDir));
+    if (fs_1.default.existsSync(projectDir)) {
+        if (!fs_1.default.lstatSync(projectDir).isDirectory() || fs_1.default.readdirSync(projectDir).length > 0) {
+            return { success: false, message: `${projectDir} should be an empty directory` };
+        }
+    }
+    else {
+        (0, log_1.default)().info("Project directory doesn't exist, creating it!");
+        fs_1.default.mkdirSync(projectDir, { recursive: true });
+    }
+    (0, template_1.write)(projectDir, template_2.extensionProjectTemplate, {
+        packageName: packageName,
+        jitsuVersion: cliOpts.jitsuVersion,
+        type: packageType,
+    });
+    return { success: true };
+}
+exports.create = create;

package/lib/cli/extension/exec.d.ts

@@ -0,0 +1,3 @@
+import { CommandResult } from "../../lib/command/types";
+export declare function execSourceExtension(args: string[]): Promise<CommandResult>;
+export declare function execDestinationExtension(args: string[]): Promise<CommandResult>;

package/lib/cli/extension/exec.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execDestinationExtension = exports.execSourceExtension = void 0;
+const tslib_1 = require("tslib");
+const commander_1 = tslib_1.__importDefault(require("commander"));
+const log_1 = tslib_1.__importDefault(require("../../lib/log"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const JSON5 = tslib_1.__importStar(require("json5"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const index_1 = require("./index");
+const indent_1 = require("../../lib/indent");
+const chalk_code_highlight_1 = require("../../lib/chalk-code-highlight");
+const errors_1 = require("../../lib/errors");
+const validation_1 = require("../../lib/validation");
+const build_1 = require("./build");
+const sources_lib_1 = require("@jitsu/jlib/lib/sources-lib");
+function getJson(json, file) {
+    if (json) {
+        return JSON5.parse(json);
+    }
+    else {
+        if (!fs_1.default.existsSync(file)) {
+            throw new Error(`File ${file} does not exist!`);
+        }
+        return JSON5.parse(fs_1.default.readFileSync(file, "utf-8"));
+    }
+}
+function ellipsis(str, opts = { maxLen: 80 }) {
+    const maxLen = opts?.maxLen || 80;
+    return str.length < maxLen ? str : str.substring(0, maxLen - 3) + "...";
+}
+function toArray(obj) {
+    if (!(typeof obj === "object" && Array.isArray(obj))) {
+        return [obj];
+    }
+    else {
+        return obj;
+    }
+}
+async function loadExtension(directory) {
+    let projectBase = path_1.default.isAbsolute(directory) ? directory : path_1.default.resolve(process.cwd() + "/" + directory);
+    let packageFile = path_1.default.resolve(projectBase, "package.json");
+    if (!fs_1.default.existsSync(packageFile)) {
+        throw new Error("Can't find package.json in " + projectBase);
+    }
+    let distFile = path_1.default.resolve(projectBase, (0, index_1.getDistFile)(JSON5.parse(fs_1.default.readFileSync(packageFile, "utf-8"))));
+    (0, log_1.default)().info("⌛️ Loading extension (don't forget to build it before running exec!). Source: " + chalk_1.default.bold(distFile));
+    if (!fs_1.default.existsSync(path_1.default.resolve(projectBase, distFile))) {
+        throw new Error(`Can't find dist file ${chalk_1.default.bold(distFile)}. Does this dir contains jitsu extension? Have you run yarn build? `);
+    }
+    let extension = await (0, index_1.loadBuild)(distFile);
+    return { extension, distFile, projectBase };
+}
+async function execSourceExtension(args) {
+    const program = new commander_1.default.Command();
+    program.option("-c, --config <config_file_or_json>", "Configuration file path or inline extension configuration JSON");
+    program.option("-d, --dir <project_dir>", "project dir");
+    program.option("-s, --stream-config <json>", "Stream configuration as an object.");
+    program.option("-t, --state <file>", "Saved state object to file");
+    program.parse(["dummy", "dummy", ...args]);
+    let cliOpts = program.opts();
+    let directory = cliOpts.dir || ".";
+    await (0, build_1.build)([directory]);
+    const { extension } = await loadExtension(directory);
+    if (!extension.streamReader) {
+        return { success: false, message: `Extension doesn't export ${chalk_1.default.bold("streamReader")} symbol` };
+    }
+    if (!extension.sourceCatalog) {
+        return { success: false, message: `Extension doesn't export ${chalk_1.default.bold("sourceCatalog")} symbol` };
+    }
+    let configObject;
+    try {
+        configObject = (0, index_1.getConfigJson)(cliOpts.config);
+    }
+    catch (e) {
+        return {
+            success: false,
+            message: `Can't parse config JSON: '${cliOpts.config}' ${e.message})`,
+        };
+    }
+    const stateFile = path_1.default.resolve(cliOpts.state || `./src-${extension?.descriptor?.id || ""}-state.json`);
+    const stateFilePresent = fs_1.default.existsSync(stateFile);
+    if (stateFilePresent) {
+        (0, log_1.default)().info(`Loading state from ${chalk_1.default.bold(path_1.default.isAbsolute(stateFile))}`);
+    }
+    else {
+        (0, log_1.default)().info(`State file is missing, starting with empty state ${chalk_1.default.bold(stateFile)}`);
+    }
+    const stateObject = stateFilePresent ? JSON5.parse(fs_1.default.readFileSync(stateFile, "utf-8")) : {};
+    if (!extension.validator) {
+        (0, log_1.default)().info("⚠️ Extension doesn't support connection validation");
+    }
+    else {
+        (0, log_1.default)().info("⌛️ Validating connection parameters...");
+        let validationError = await (0, validation_1.validateConfiguration)(configObject, extension.validator);
+        if (validationError) {
+            return {
+                success: false,
+                message: `Configuration validation failed: ${validationError}`,
+            };
+        }
+        (0, log_1.default)().info("🙌️ Configuration is valid!");
+    }
+    (0, log_1.default)().info("🏃 Getting available streams...");
+    let streams = await extension.sourceCatalog(configObject);
+    streams.forEach(stream => {
+        let paramsDocs = (stream.params ?? []).map(param => `${param.id} - ${param.displayName}`).join(", ");
+        (0, log_1.default)().info(`🌊 Stream: ${chalk_1.default.bold(stream.type)}. Parameters: ${paramsDocs.length > 0 ? paramsDocs : "none"}`);
+    });
+    let stream;
+    let streamConfigObject = cliOpts.streamConfig && JSON5.parse(cliOpts.streamConfig);
+    let mode = streamConfigObject?.mode;
+    if (streams.length > 1) {
+        if (!streamConfigObject) {
+            return {
+                success: false,
+                message: `The connector exports more than one (${streams.length}) streams. Please specify stream name and config as -s {stream: 'name', ...}`,
+            };
+        }
+        if (!streamConfigObject?.name) {
+            return {
+                success: false,
+                message: `Connector defines multiple streams (${streams.map(s => s.type)}). Specify stream name as as: -s {name: 'name', ...}`,
+            };
+        }
+        stream = streams.find(stream => stream.type === streamConfigObject?.name);
+        if (!stream) {
+            return { success: false, message: `Stream with ${streamConfigObject?.name} is not found` };
+        }
+    }
+    else {
+        stream = streams[0];
+    }
+    const modes = stream.supportedModes;
+    if (!mode && modes.length > 1) {
+        return {
+            success: false,
+            message: `Stream ${stream.type} supports multiple modes (${modes.join(", ")}). Please specify mode as -s {mode: '${modes[0]}', ...}`,
+        };
+    }
+    if (mode && !modes.includes(mode)) {
+        return {
+            success: false,
+            message: `Stream ${stream.type} doesn't support mode ${mode}. Supported modes: ${modes.join(", ")}`,
+        };
+    }
+    const effectiveMode = mode || modes[0];
+    const resultTable = newTable();
+    const sink = (0, sources_lib_1.makeStreamSink)({
+        msg(msg) {
+            if (msg.type === "record") {
+                (0, log_1.default)().info("[" + msg.type + "] " + (msg.message ? JSON.stringify(msg.message) : ""));
+                add(resultTable, msg.message);
+            }
+            else if (msg.type === "log") {
+                (0, log_1.default)()[msg.message?.["level"].toLowerCase()]?.("[" + msg.type + "] " + msg.message?.["message"]);
+            }
+            else if (msg.type === "state") {
+                (0, log_1.default)().info("[" + msg.type + "] " + (msg.message ? JSON.stringify(msg.message) : ""));
+                (0, log_1.default)().info(`💾 State was modified. Saving to: ${chalk_1.default.bold(path_1.default.isAbsolute(stateFile))}`);
+                fs_1.default.writeFileSync(stateFile, JSON.stringify(msg.message, null, 2));
+            }
+            else {
+                (0, log_1.default)().info("[" + msg.type + "] " + (msg.message ? JSON.stringify(msg.message) : ""));
+            }
+        },
+    }, effectiveMode);
+    let streamConfiguration = { parameters: streamConfigObject };
+    if (mode) {
+        streamConfiguration.mode = mode;
+    }
+    await extension.streamReader(configObject, stream.type, streamConfiguration, sink, {
+        state: (0, sources_lib_1.stateService)(stateObject, sink),
+    });
+    (0, log_1.default)().info("🏁 Result data:");
+    console.log(JSON.stringify(resultTable.rows, null, 2));
+    console.log("Special column types: \n" +
+        Object.entries(resultTable.columns)
+            .filter(([colName, colValue]) => colValue.types.length > 0)
+            .map(([colName, colValue]) => `\t${colName}: ${colValue.types}`)
+            .join("\n"));
+    return { success: true };
+}
+exports.execSourceExtension = execSourceExtension;
+function newTable() {
+    return { rows: [], columns: {} };
+}
+function add(t, rec) {
+    const newRow = {};
+    for (const [key, val] of Object.entries(rec)) {
+        if (key.indexOf("__sql_type") !== 0) {
+            if (t.columns[key] === undefined) {
+                t.columns[key] = { types: [] };
+                t.rows.forEach(row => (row[key] = undefined));
+            }
+            newRow[key] = Array.isArray(val) ? JSON.stringify(val) : val;
+        }
+        else {
+            const columnName = key.substring("__sql_type_".length);
+            if (t.columns[columnName] === undefined) {
+                t.columns[columnName] = { types: [] };
+            }
+            let uniqueTypes = new Set(t.columns[columnName].types);
+            uniqueTypes.add(val);
+            t.columns[columnName].types = [...uniqueTypes];
+        }
+    }
+    Object.keys(t.columns).forEach(col => {
+        if (newRow[col] === undefined) {
+            newRow[col] = undefined;
+        }
+    });
+    t.rows.push(newRow);
+}
+async function execDestinationExtension(args) {
+    const program = new commander_1.default.Command();
+    program.option("-f, --file <file path>", "Path to file with jitsu events. Could be either on object, or array of objects");
+    program.option("-c, --config <config_file_or_json>", "Configuration file path or inline extension configuration JSON");
+    program.option("-j, --json <event json>", "Events JSON for processing (alternative to -f). Could be one object, or array of objects");
+    program.option("-d, --dir <project_dir>", "project dir");
+    program.option("-v, --skip-validation", "To skip config validation");
+    program.parse(["dummy", "dummy", ...args]);
+    let cliOpts = program.opts();
+    let directory = cliOpts.dir || ".";
+    if (!cliOpts.json && !cliOpts.file) {
+        return { success: false, message: "Please specify -j or -f" };
+    }
+    if (cliOpts.json && cliOpts.file) {
+        return { success: false, message: "Both options -f and -j are provided. You should use either, not both" };
+    }
+    if (!cliOpts.config) {
+        return { success: false, message: "Please define config object -c json_file_path or -c '{json_object:}'" };
+    }
+    let config;
+    try {
+        config = (0, index_1.getConfigJson)(cliOpts.config);
+    }
+    catch (e) {
+        return {
+            success: false,
+            message: `Can't parse config JSON: '${cliOpts.config}' ${e.message})`,
+        };
+    }
+    const { extension, projectBase } = await loadExtension(directory);
+    (0, log_1.default)().info("🛂 Executing tests destination on " + chalk_1.default.bold(projectBase));
+    let events = toArray(getJson(cliOpts.json, cliOpts.file));
+    if (!extension.destination) {
+        return { success: false, message: "Extension doesn't export destination function" };
+    }
+    if (!cliOpts.skipValidation && extension.validator) {
+        (0, log_1.default)().info(`Validating configuration:${chalk_code_highlight_1.chalkCode.json((0, indent_1.align)(JSON.stringify(config, null, 2), { indent: 4, lnBefore: 1, lnAfter: 1 }))}`);
+        let configError = await (0, validation_1.validateConfiguration)(config, extension.validator);
+        if (configError) {
+            return { success: false, message: "Config is not valid: " + configError };
+        }
+        (0, log_1.default)().info("✅ Configuration is valid!");
+    }
+    else {
+        (0, log_1.default)().info("💡 Config validation will be skipped " +
+            (cliOpts.skipValidation ? " as per requested by -v flag" : ": extension does not have an exported validator"));
+    }
+    (0, log_1.default)().info("🏃 Running destination plugin on " + events.length + " events");
+    for (const ev of events) {
+        try {
+            let messages = await extension.destination(ev, {
+                destinationId: "test",
+                destinationType: "test",
+                config: config,
+            });
+            if (!messages) {
+                (0, log_1.default)().info("⚽ Event is skipped: " + ellipsis(JSON.stringify(ev)));
+                continue;
+            }
+            const messagesArray = Array.isArray(messages) ? messages : [messages];
+            (0, log_1.default)().info(`✅ Event emitted ${messagesArray.length} messages. Event JSON: ` + chalk_1.default.italic(ellipsis(JSON.stringify(ev))));
+            messagesArray.forEach(msg => {
+                (0, log_1.default)().info(`    ${chalk_1.default.bold(msg.method)} ${msg.url}`);
+                if (msg.headers && Object.entries(msg).length > 0) {
+                    Object.entries(msg.headers).forEach(([h, v]) => {
+                        (0, log_1.default)().info(`     ${chalk_1.default.bold(h)}: ${v}`);
+                    });
+                }
+                if (msg.body) {
+                    (0, log_1.default)().info("    Body:\n" + chalk_code_highlight_1.chalkCode.json((0, indent_1.align)(JSON.stringify((0, indent_1.jsonify)(msg.body), null, 2), { indent: 8 })));
+                }
+            });
+        }
+        catch (e) {
+            (0, log_1.default)().info(chalk_1.default.red((0, errors_1.appendError)("❌ Failed to process event", e) +
+                (0, indent_1.align)(JSON.stringify(ev, null, 2), { lnBefore: 1, lnAfter: 1, indent: 0 })));
+        }
+    }
+    return { success: true };
+}
+exports.execDestinationExtension = execDestinationExtension;

package/lib/cli/extension/index.d.ts

@@ -0,0 +1,9 @@
+import { CommandRegistry } from "../../lib/command/types";
+import { JitsuExtensionExport } from "@jitsu/types/extension";
+import { Partial } from "rollup-plugin-typescript2/dist/partial";
+export declare const help: string;
+export declare const extensionCommands: CommandRegistry<"test" | "build" | "create" | "validate-config" | "exec" | "exec-src">;
+export declare function validateTsConfig(tsConfigPath: string): void;
+export declare function getDistFile(packageJson: any): any;
+export declare function getConfigJson(jsonOrFile: string): any;
+export declare function loadBuild(file: string): Promise<Partial<JitsuExtensionExport>>;