jitsu-cli 0.6.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,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const tslib_1 = require("tslib");
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const log_1 = (0, tslib_1.__importDefault)(require("../../lib/log"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+const errors_1 = require("../../lib/errors");
+const rollup_1 = require("rollup");
+const rollup_plugin_typescript2_1 = (0, tslib_1.__importDefault)(require("rollup-plugin-typescript2"));
+const plugin_multi_entry_1 = (0, tslib_1.__importDefault)(require("@rollup/plugin-multi-entry"));
+const plugin_node_resolve_1 = (0, tslib_1.__importDefault)(require("@rollup/plugin-node-resolve"));
+const plugin_commonjs_1 = (0, tslib_1.__importDefault)(require("@rollup/plugin-commonjs"));
+const version_1 = require("../../lib/version");
+const _1 = require("./");
+const JSON5_1 = (0, tslib_1.__importDefault)(require("JSON5"));
+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));
+    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_1.default.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 }), (0, plugin_multi_entry_1.default)(), (0, plugin_node_resolve_1.default)(), (0, plugin_commonjs_1.default)()],
+        });
+        (0, log_1.default)().info("Generating bundle");
+        let output = await bundle.generate({
+            generatedCode: "es2015",
+            format: "cjs",
+        });
+        (0, log_1.default)().info("Validating build");
+        let code = output.output[0].code;
+        code += `\nexports.buildInfo = {sdkVersion: "${version_1.jitsuCliVersion}", sdkPackage: "${version_1.jitsuPackageName}", buildTimestamp: "${new Date().toISOString()}"}`;
+        const exports = (0, _1.loadBuild)(code);
+        if (!exports.destination && !exports.transform) {
+            return {
+                success: false,
+                message: `${chalk_1.default.bold(indexFile)} should export ${chalk_1.default.italic("destination")} or ${chalk_1.default.italic("transform")} symbol. 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(", "),
+            };
+        }
+        fs_1.default.mkdirSync(path_1.default.dirname(fullOutputPath), { recursive: true });
+        fs_1.default.writeFileSync(fullOutputPath, code);
+    }
+    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 = (0, tslib_1.__importDefault)(require("commander"));
+const validate_npm_package_name_1 = (0, tslib_1.__importDefault)(require("validate-npm-package-name"));
+const inquirer_1 = (0, tslib_1.__importDefault)(require("inquirer"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+const log_1 = (0, 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 transform)");
+    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("transform")}   adds a transformation logic`,
+                ].join("\n"),
+                choices: ["destination", "transform"],
+            },
+        ])).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/index.d.ts

@@ -0,0 +1,8 @@
+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">;
+export declare function validateTsConfig(tsConfigPath: string): void;
+export declare function getDistFile(packageJson: any): any;
+export declare function loadBuild(code: string): Partial<JitsuExtensionExport>;

package/lib/cli/extension/index.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBuild = exports.getDistFile = exports.validateTsConfig = exports.extensionCommands = exports.help = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const chalk_code_highlight_1 = require("../../lib/chalk-code-highlight");
+const fs = (0, tslib_1.__importStar)(require("fs"));
+const indent_1 = require("../../lib/indent");
+const create_1 = require("./create");
+const build_1 = require("./build");
+const test_1 = require("./test");
+const validate_config_1 = require("./validate-config");
+const template_1 = require("./template");
+const JSON5_1 = (0, tslib_1.__importDefault)(require("JSON5"));
+global.fetch = require("cross-fetch");
+const usage = `
+  · ${chalk_1.default.bold("jitsu-cli extension create")}
+    
+    Create a project for jitsu plugin with placeholder implementation for all components.
+    
+  · ${chalk_1.default.bold("jitsu-cli extension build <directory>")}
+    
+    Build project located in <directory>. If <directory> is not provided current directory is used.
+   
+  · ${chalk_1.default.bold("jitsu-cli extension test  <directory>")}
+    
+    Run tests for project in <directory>/__test__. If <directory> is not provided current directory is used.
+   
+  · ${chalk_1.default.bold("jitsu-cli extension validate-config -f file or -j {json}")}
+   
+    Validates configuration json object. ${chalk_1.default.bold("Note:")} run \`jitsu-cli extension build\` beforehand 
+    
+  · ${chalk_1.default.bold("jitsu-cli extension help")}
+   
+    Show this help 
+`;
+exports.help = `
+
+${chalk_1.default.bold("DESCRIPTION")}
+
+  The command will build jitsu extension and bundle a single JS file that will
+  placed to a location defined in main parameter of package.json (if not set, the bundle
+  will be placed in dist/index.js
+
+  You can (and should!) call \`jitsu-cli extension build\` in package.json. Example: ${chalk_code_highlight_1.chalkCode.json((0, indent_1.align)(JSON.stringify((0, template_1.packageJsonTemplate)({
+    packageName: "test-package",
+    type: "destination",
+}), null, 2), { indent: 4, lnBefore: 2 }))}
+
+  The code should be located in ./src folder. src/index.js (or ts) should be present
+                               
+${chalk_1.default.bold("TYPESCRIPT")}
+
+  Typescript is supported out of the box. Just add tsconfig.json to the root of the project
+
+${chalk_1.default.bold("COMMANDS")} ${(0, indent_1.align)(usage, { indent: 2, lnBefore: 2 })}
+`;
+exports.extensionCommands = {
+    test: {
+        exec: test_1.test,
+        description: "Execute test on extension",
+        help: "Tests should be located in ./__test__ folder and follow *.test.ts pattern",
+    },
+    build: {
+        exec: build_1.build,
+        description: "Builds Jitsu extension",
+        help: "",
+    },
+    create: {
+        exec: create_1.create,
+        description: "Creates an empty project",
+        help: "",
+    },
+    "validate-config": {
+        exec: validate_config_1.validateConfig,
+        description: `Verifies a configuration. ${chalk_1.default.bold("Note:")} run \`jitsu-cli extension build\` first!`,
+        help: "",
+    },
+};
+function validateTsConfig(tsConfigPath) {
+    let tsConfig;
+    try {
+        tsConfig = JSON5_1.default.parse(fs.readFileSync(tsConfigPath, "utf8"));
+    }
+    catch (e) {
+        throw new Error(`${chalk_1.default.bold(tsConfigPath)} - syntax error: ${e.message}`);
+    }
+    if (tsConfig?.compilerOptions?.module !== "ES2020") {
+        throw new Error(`${chalk_1.default.bold(tsConfigPath)} error: compilerOptions.module should be set to ES2020!`);
+    }
+}
+exports.validateTsConfig = validateTsConfig;
+function getDistFile(packageJson) {
+    return packageJson.main || "dist/index.js";
+}
+exports.getDistFile = getDistFile;
+function loadBuild(code) {
+    let f = new Function("exports", code);
+    let exports = {};
+    f(exports);
+    return exports;
+}
+exports.loadBuild = loadBuild;

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

@@ -0,0 +1,27 @@
+import { ProjectTemplate } from "../../lib/template";
+export declare type DestinationTemplateVars = {
+    license?: "MIT" | "Other";
+    packageName: string;
+    type: "destination" | "transform";
+    jitsuVersion?: string;
+};
+export declare const packageJsonTemplate: ({ packageName, type, jitsuVersion }: DestinationTemplateVars) => {
+    name: string;
+    version: string;
+    description: string;
+    main: string;
+    scripts: {
+        build: string;
+        test: string;
+        "validate-config": string;
+    };
+    devDependencies: {
+        "@jitsu/types": string;
+        typescript: string;
+    };
+    dependencies: {
+        "jitsu-cli": string;
+        tslib: string;
+    };
+};
+export declare const extensionProjectTemplate: ProjectTemplate<DestinationTemplateVars>;

package/lib/cli/extension/template.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extensionProjectTemplate = exports.packageJsonTemplate = void 0;
+const version_1 = require("../../lib/version");
+const packageJsonTemplate = ({ packageName, type, jitsuVersion = undefined }) => ({
+    name: `${packageName}`,
+    version: "0.0.1",
+    description: `Jitsu ${type} - ${packageName}`,
+    main: `dist/${packageName}.js`,
+    scripts: {
+        build: "jitsu-cli extension build",
+        test: "jitsu-cli extension test",
+        "validate-config": "jitsu-cli extension validate-config",
+    },
+    devDependencies: {
+        "@jitsu/types": `${jitsuVersion || "^" + version_1.jitsuCliVersion}`,
+        typescript: "^4.5.2",
+    },
+    dependencies: {
+        "jitsu-cli": `${jitsuVersion || "^" + version_1.jitsuCliVersion}`,
+        tslib: "^2.3.1",
+    },
+});
+exports.packageJsonTemplate = packageJsonTemplate;
+let destinationTest = ({ type = "destination" }) => {
+    if (type !== "destination") {
+        return undefined;
+    }
+    return `
+    import { JitsuDestinationContext } from "@jitsu/types/extension"
+    import { testDestination } from "jitsu-cli/lib/tests"
+    import { destination } from "../src"
+
+    testDestination({
+      name: "basic",
+      context: {
+        destinationId: "test",
+        destinationType: "mydest",
+        config: {}
+      },
+      destination: destination,
+      event: {
+        event_type: 'test',
+        a: 1
+      },
+      expectedResult: {
+        method: "POST",
+        url: "https://test.com",
+        body: { a: 2 },
+      },
+    })
+`;
+};
+let destinationCode = () => {
+    return `
+    import { DestinationFunction, DestinationMessage, JitsuDestinationContext, ConfigValidator} from "@jitsu/types/extension";
+    import { DefaultJitsuEvent } from "@jitsu/types/event";
+    
+    export type DestinationConfig = {
+      exampleParam: string
+    }  
+    
+    export const validator: ConfigValidator<DestinationConfig> = async (config: DestinationConfig) => {
+      if (config.exampleParam !== 'valid-config') {
+        return \`Invalid config: exampleParam expected to be 'valid-config', but actual value is: \${config.exampleParam}\`;
+      }
+      return true;
+    }
+
+    export const destination: DestinationFunction = (event: DefaultJitsuEvent, dstContext: JitsuDestinationContext<DestinationConfig>) => {
+      return { url: "https://test.com", method: "POST", body: { a: (event.a || 0) + 1 } };
+    };
+`;
+};
+let transformCode = () => {
+    return `
+    import {Destination, DestinationMessage, JitsuDestinationContext} from "@jitsu/types/destination";
+    import {DefaultJitsuEvent} from "@jitsu/types/event";
+    
+    //duplicate events 
+    const transform: TransformationFunction = (event: DefaultJitsuEvent) => {
+      return [event, {...event, eventn_ctx_event_id: event.eventn_ctx_event_id + "_2"}] 
+    }
+
+    export default jitsuAdapter;
+`;
+};
+let descriptor = {};
+descriptor["destination"] = (vars) => `
+  import {ExtensionDescriptor} from "@jitsu/types/extension";
+  import {destination, validator, DestinationConfig} from "./destination";
+
+  const descriptor: ExtensionDescriptor = {
+    id: "${vars.packageName}",
+    displayName: "${vars.packageName}",
+    icon: "",
+    description: "Jitsu destination - ${vars.packageName} (generated by 'jitsu-cli extension create')",
+    configurationParameters: [
+      {id: "exampleParam", type: "string", required: true, displayName: "Example param", documentation: "Documentation"}
+    ],
+  };
+
+  export { descriptor, destination, validator };
+`;
+descriptor["transform"] = (vars) => `
+  import {DestinationAdapter, DestinationDescriptor} from "@jitsu/types/destination";
+  import jitsuAdapter from "./adapter";
+
+  const adapter: DestinationAdapter = jitsuAdapter
+
+  const descriptor: DestinationDescriptor = {
+    type: "${vars.packageName}",
+    displayName: "${vars.packageName}",
+    icon: "",
+    description: "Jitsu ${vars.type} - ${vars.packageName} (generated by 'jitsu-cli extension create)'",
+    configurationParameters: [
+      //put configuration here
+    ]
+  }
+
+  export {descriptor, adapter}
+`;
+exports.extensionProjectTemplate = {
+    "__test__/destination.test.ts": destinationTest,
+    "src/destination.ts": vars => vars.type == "destination" && destinationCode(),
+    "src/transform.ts": vars => vars.type == "transform" && transformCode(),
+    "src/index.ts": vars => descriptor[vars.type](vars),
+    "package.json": exports.packageJsonTemplate,
+    "tsconfig.json": {
+        compilerOptions: {
+            module: "ES2020",
+            target: "ES2021",
+            moduleResolution: "Node",
+            esModuleInterop: true,
+            outDir: "./dist",
+            rootDir: "./",
+        },
+        include: ["./src", "__test__"],
+    },
+};

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

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

package/lib/cli/extension/test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = void 0;
+const tslib_1 = require("tslib");
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const log_1 = (0, tslib_1.__importDefault)(require("../../lib/log"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+const jest_cli_1 = require("jest-cli");
+const _1 = require("./");
+async function test(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("🛂 Running tests for " + chalk_1.default.bold(projectBase));
+    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);
+    let jestArgs = ["--passWithNoTests", "--projects", projectBase];
+    if (typescriptEnabled) {
+        jestArgs.push("--preset", "ts-jest");
+    }
+    await (0, jest_cli_1.run)(jestArgs);
+    return { success: true };
+}
+exports.test = test;

package/lib/cli/extension/validate-config.d.ts

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

package/lib/cli/extension/validate-config.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = void 0;
+const tslib_1 = require("tslib");
+const commander_1 = (0, tslib_1.__importDefault)(require("commander"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
+const JSON5_1 = (0, tslib_1.__importDefault)(require("JSON5"));
+const log_1 = (0, tslib_1.__importDefault)(require("../../lib/log"));
+const index_1 = require("./index");
+async function validateConfig(args) {
+    const program = new commander_1.default.Command();
+    program.option("-d, --dir <project_dir>", "Project directory");
+    program.option("-f, --file <config_file>", "Configuration file");
+    program.option("-j, --json <config_json>", "Inline extension configuration JSON");
+    program.argument("[project_dir]");
+    program.parse(["dummy", "dummy", ...args]);
+    const opts = program.opts();
+    if (!opts.json && !opts.file) {
+        return {
+            success: false,
+            message: 'Please define config object either with -j "{embedded json}", or with -f json_file',
+        };
+    }
+    let configObj;
+    if (opts.json) {
+        try {
+            configObj = JSON5_1.default.parse(opts.json);
+        }
+        catch (e) {
+            return { success: false, message: `Malformed json (-j): ${e.message}` };
+        }
+    }
+    else {
+        if (!fs_1.default.existsSync(opts.file)) {
+            return { success: false, message: `${opts.file} (-f) doesn't exist!` };
+        }
+        try {
+            configObj = JSON5_1.default.parse(fs_1.default.readFileSync(opts.file, "utf8"));
+        }
+        catch (e) {
+            return { success: false, message: `Malformed json in file ${opts.file} (-f): ${e.message}` };
+        }
+    }
+    let projectDir = opts.dir || ".";
+    (0, log_1.default)().info("Project dir: " + projectDir);
+    let packageFile = path_1.default.resolve(projectDir, "package.json");
+    if (!fs_1.default.existsSync(packageFile)) {
+        return { success: false, message: `Can't find package file ${packageFile}` };
+    }
+    let packageObj = JSON5_1.default.parse(fs_1.default.readFileSync(packageFile, "utf8"));
+    let distFile = path_1.default.resolve(projectDir, (0, index_1.getDistFile)(packageObj));
+    (0, log_1.default)().info("Dist file: " + distFile);
+    if (!fs_1.default.existsSync(distFile)) {
+        return { success: false, message: `Can't find dist file (${distFile}). Forgot to run jitsu-cli extension build ?` };
+    }
+    (0, log_1.default)().info("🤔 Loading build from " + chalk_1.default.bold(distFile));
+    let build = (0, index_1.loadBuild)(fs_1.default.readFileSync(distFile, "utf8"));
+    (0, log_1.default)().info("👍 Module loaded!");
+    if (!build.validator) {
+        return { success: false, message: "Build doesn't export validator symbol" };
+    }
+    (0, log_1.default)().info("🤔 Validating configuration " +
+        (opts.file ? `from file ${path_1.default.resolve(projectDir, opts.file)}` : JSON.stringify(configObj)));
+    let validationResult = await build.validator(configObj);
+    if (typeof validationResult === "boolean" && !validationResult) {
+        return { success: false, message: "❌ Config is not valid, an exact reason isn't specified by validator" };
+    }
+    else if (typeof validationResult === "string") {
+        return { success: false, message: "❌ Config is not valid: " + validationResult };
+    }
+    else if (typeof validationResult === "object" && !validationResult.ok) {
+        return { success: false, message: "❌ Config is not valid: " + validationResult.message };
+    }
+    (0, log_1.default)().info("✅ Config is valid. Hooray!");
+    return { success: true };
+}
+exports.validateConfig = validateConfig;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const run_1 = require("./run");
+const log_1 = (0, tslib_1.__importDefault)(require("./lib/log"));
+(async function () {
+    (0, log_1.default)().info("Args: " + process.argv);
+    const args = [...process.argv.slice(2)];
+    process.exit(await (0, run_1.run)(args));
+})();

package/lib/lib/chalk-code-highlight.d.ts

@@ -0,0 +1,14 @@
+import { Grammar } from "prismjs";
+export declare type ColorScheme = Record<string, string | null>;
+export declare const defaultColorScheme: {
+    punctuation: string;
+    operator: string;
+    string: string;
+    keyword: string;
+    "function-variable": null;
+};
+export declare function chalkCode(code: string, lang: Grammar, colorScheme?: ColorScheme): string;
+export declare namespace chalkCode {
+    var typescript: (code: string | TemplateStringsArray, colorScheme?: ColorScheme) => string;
+    var json: (code: string | TemplateStringsArray, colorScheme?: ColorScheme) => string;
+}

package/lib/lib/chalk-code-highlight.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chalkCode = exports.defaultColorScheme = void 0;
+const tslib_1 = require("tslib");
+const prismjs_1 = (0, tslib_1.__importDefault)(require("prismjs"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+exports.defaultColorScheme = {
+    punctuation: "#999",
+    operator: "#9a6e3a",
+    string: "#9a6e3a",
+    keyword: "b#07a",
+    "function-variable": null,
+};
+function chalkString(expr, str) {
+    if (expr.startsWith("b")) {
+        return chalk_1.default.bold(chalkString(expr.substring(1), str));
+    }
+    else {
+        return chalk_1.default.hex(expr)(str);
+    }
+}
+function chalkCode(code, lang, colorScheme = exports.defaultColorScheme) {
+    return prismjs_1.default.tokenize(code, prismjs_1.default.languages.javascript)
+        .map(element => {
+        if (typeof element === "string") {
+            return element;
+        }
+        else {
+            let highlight = colorScheme[element.type];
+            return highlight ? chalkString(highlight, element.content.toString()) : `${element.content}`;
+        }
+    })
+        .join("");
+}
+exports.chalkCode = chalkCode;
+chalkCode.typescript = (code, colorScheme = exports.defaultColorScheme) => {
+    return chalkCode(typeof code === "string" ? code : code.join("\n"), prismjs_1.default.languages.typescript, colorScheme);
+};
+chalkCode.json = (code, colorScheme = exports.defaultColorScheme) => {
+    return chalkCode(typeof code === "string" ? code : code.join("\n"), prismjs_1.default.languages.json, colorScheme);
+};

package/lib/lib/command/index.d.ts

@@ -0,0 +1,3 @@
+import { Command, CommandRegistry, CommandResult, HelpOptions } from "./types";
+export declare const executeCommand: (commands: CommandRegistry, args: string[], helpOpts: HelpOptions) => Promise<CommandResult>;
+export declare function subcommands(commands: CommandRegistry, helpOpts: HelpOptions): Command;

package/lib/lib/command/index.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subcommands = exports.executeCommand = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = (0, 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) => {
+    let newVersion = await (0, version_1.hasNewerVersion)();
+    if (newVersion) {
+        console.log((0, version_1.getUpgradeMessage)(newVersion));
+    }
+    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,8 @@
+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;

package/lib/lib/indent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;

package/lib/lib/log.d.ts

@@ -0,0 +1,7 @@
+export declare type Log = {
+    debug: (msg?: string, ...args: any[]) => void;
+    info: (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,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = (0, 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);
+        },
+        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 posix_1 = (0, tslib_1.__importDefault)(require("path/posix"));
+const fs = (0, 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 = posix_1.default.resolve(dir, fileName);
+        let fileDir = posix_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/version.d.ts

@@ -0,0 +1,5 @@
+export declare const jitsuCliVersion: string;
+export declare const jitsuPackageName: string;
+export declare function getUpgradeMessage(newVersion: 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 = (0, tslib_1.__importDefault)(require("../../package.json"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const log_1 = (0, tslib_1.__importDefault)(require("./log"));
+const preload_1 = (0, 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) {
+    return box(`🚀 New version of Jitsu CLI is available: ${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,69 @@
+{
+    "name": "jitsu-cli",
+    "version": "0.6.0",
+    "publishConfig": {
+        "access": "public"
+    },
+    "description": " CLI interface of Jitsu (👉 https://jitsu.com),",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/jitsucom/jitsu-sdk",
+        "directory": "packages/jitsu-cli"
+    },
+    "bugs": {
+        "url": "https://github.com/jitsucom/jitsu/issues"
+    },
+    "license": "MIT",
+    "bin": {
+        "jitsu-cli": "./bin/jitsu-cli"
+    },
+    "files": [
+        "lib",
+        "bin"
+    ],
+    "scripts": {
+        "build": "yarn clean:some && tsc -p . && mv ./lib/src/* ./lib/ && rmdir ./lib/src/",
+        "global": "yarn install -g",
+        "clean:some": "rm -rf ./lib",
+        "start": "ts-node src/index.ts",
+        "test": "jest --verbose ./__tests__"
+    },
+    "devDependencies": {
+        "@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",
+        "lerna": "^4.0.0",
+        "ts-node": "^10.4.0"
+    },
+    "dependencies": {
+        "@rollup/plugin-commonjs": "^21.0.1",
+        "@rollup/plugin-multi-entry": "^4.1.0",
+        "@rollup/plugin-node-resolve": "^13.0.6",
+        "@types/prismjs": "^1.16.6",
+        "chalk": "^4.1.2",
+        "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"
+    },
+    "gitHead": "4a5222ce49da3cb6be58648c78b1111b39764fe1"
+}

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 = (0, tslib_1.__importDefault)(require("chalk"));
+const command_1 = require("./lib/command");
+const extension_1 = require("./cli/extension");
+const log_1 = (0, 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,69 @@
+{
+  "name": "jitsu-cli",
+  "version": "0.6.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": " CLI interface of Jitsu (👉 https://jitsu.com),",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jitsucom/jitsu-sdk",
+    "directory": "packages/jitsu-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/jitsucom/jitsu/issues"
+  },
+  "license": "MIT",
+  "bin": {
+    "jitsu-cli": "./bin/jitsu-cli"
+  },
+  "files": [
+    "lib",
+    "bin"
+  ],
+  "scripts": {
+    "build": "yarn clean:some && tsc -p . && mv ./lib/src/* ./lib/ && rmdir ./lib/src/",
+    "global": "yarn install -g",
+    "clean:some": "rm -rf ./lib",
+    "start": "ts-node src/index.ts",
+    "test": "jest --verbose ./__tests__"
+  },
+  "devDependencies": {
+    "@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",
+    "lerna": "^4.0.0",
+    "ts-node": "^10.4.0"
+  },
+  "dependencies": {
+    "@rollup/plugin-commonjs": "^21.0.1",
+    "@rollup/plugin-multi-entry": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.6",
+    "@types/prismjs": "^1.16.6",
+    "chalk": "^4.1.2",
+    "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"
+  },
+  "gitHead": "82fbe5d15fbd1308e6c571961f9d4f8cb3644591"
+}