jitsu-cli 1.9.3 → 1.9.4

package/.turbo/turbo-build.log

@@ -1,10 +1,10 @@
-jitsu-cli:build: cache hit, replaying output 12b71f43cc5d747f
+jitsu-cli:build: cache hit, replaying output b750bc04f6e3885e
 jitsu-cli:build: 
-jitsu-cli:build: > jitsu-cli@0.0.0 build /Users/vklmn/dev2/newjitsu/cli/jitsu-cli
+jitsu-cli:build: > jitsu-cli@0.0.0 build /Users/ildarnurislamov/Projects/newjitsu/cli/jitsu-cli
 jitsu-cli:build: > pnpm compile && webpack
 jitsu-cli:build: 
 jitsu-cli:build: 
-jitsu-cli:build: > jitsu-cli@0.0.0 compile /Users/vklmn/dev2/newjitsu/cli/jitsu-cli
+jitsu-cli:build: > jitsu-cli@0.0.0 compile /Users/ildarnurislamov/Projects/newjitsu/cli/jitsu-cli
 jitsu-cli:build: > tsc -p . 
 jitsu-cli:build: 
 jitsu-cli:build: asset main.js 12.4 MiB [emitted] (name: main) 1 related asset
@@ -41,4 +41,4 @@ jitsu-cli:build: cache hit, replaying output 12b71f43cc5d747f
 jitsu-cli:build: 2 warnings have detailed information that is not shown.
 jitsu-cli:build: Use 'stats.errorDetails: true' resp. '--stats-error-details' to show it.
 jitsu-cli:build: 
-jitsu-cli:build: webpack 5.88.2 compiled with 2 warnings in 5084 ms
+jitsu-cli:build: webpack 5.88.2 compiled with 2 warnings in 6330 ms

package/.turbo/turbo-clean.log

@@ -1,5 +1,5 @@
-jitsu-cli:clean: cache hit, replaying output 9b00fa1b0bf2986e
+jitsu-cli:clean: cache hit, replaying output 51795610ff16e83e
 jitsu-cli:clean: 
-jitsu-cli:clean: > jitsu-cli@0.0.0 clean /Users/vklmn/dev2/newjitsu/cli/jitsu-cli
+jitsu-cli:clean: > jitsu-cli@0.0.0 clean /Users/ildarnurislamov/Projects/newjitsu/cli/jitsu-cli
 jitsu-cli:clean: > rm -rf ./dist
 jitsu-cli:clean: 

package/compiled/src/commands/template.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extensionProjectTemplate = exports.packageJsonTemplate = void 0;
+const version_1 = require("../lib/version");
+const index_1 = require("../index");
+const packageJsonTemplate = ({ packageName, type, jitsuVersion = undefined }) => {
+    const res = {
+        name: `${packageName}`,
+        version: "0.0.1",
+        description: `Jitsu ${type} - ${packageName}`,
+        keywords: ["jitsu", "extension", `jitsu-${type}-extension`],
+        main: `dist/${packageName}.js`,
+        scripts: {
+            clean: "rm -rf ./dist",
+            build: `${index_1.binName} extension build`,
+            test: `${index_1.binName} extension test`,
+            execute: `${index_1.binName} extension exec`,
+        },
+        devDependencies: {
+            "@jitsu/types": `${jitsuVersion || "^" + version_1.jitsuCliVersion}`,
+            "@jitsu/jlib": `${jitsuVersion || "^" + version_1.jitsuCliVersion}`,
+            "ts-jest": "^27.0.7",
+            [index_1.binName]: `${jitsuVersion || "^" + version_1.jitsuCliVersion}`,
+            tslib: "^2.3.1",
+            typescript: "^4.5.2",
+        },
+        dependencies: {},
+    };
+    if (type === "destination" || type === "source") {
+        res.scripts["validate-config"] = `${index_1.binName} extension validate-config`;
+    }
+    return res;
+};
+exports.packageJsonTemplate = packageJsonTemplate;
+let destinationTest = ({ type = "destination" }) => {
+    if (type !== "destination") {
+        return undefined;
+    }
+    return `
+    import { JitsuDestinationContext } from "@jitsu/types/extension"
+    import { testDestination } from "${index_1.binName}/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 sourceCode = () => {
+    return `
+    import { SourceCatalog, StateService, StreamReader, StreamSink, StreamConfiguration } from "@jitsu/types/sources";
+    import { ConfigValidationResult, ExtensionDescriptor } from "@jitsu/types/extension";
+    
+    export interface SourceConfig {
+      user_id: string
+      my_source_param: string;
+    }
+    
+    export interface StreamConfig {
+      my_stream_param: string;
+    }
+    
+    async function validator(config: SourceConfig): Promise<ConfigValidationResult> {
+      //TODO: Check that provided config data allows to connect to third party API 
+      console.log("validator is not yet implemented");
+      return true;
+    }
+    
+    const descriptor: ExtensionDescriptor<SourceConfig> = {
+      id: "my_source",
+      displayName: "Source Example",
+      description:
+        "Example source that produces row with run number and source/stream configuration.",
+      configurationParameters: [
+        {
+          displayName: "User ID",
+          id: "user_id",
+          type: "string",
+          required: true,
+          documentation: "User Id",
+        },
+        {
+          displayName: "Example Parameter",
+          id: "my_source_param",
+          required: true,
+          type: "string",
+          documentation: \`
+            <div>
+                Example Parameter
+            </div>
+            \`,
+        }
+      ],
+    };
+    
+    const sourceCatalog: SourceCatalog<SourceConfig, StreamConfig> = async config => {
+      return [
+        {
+          type: "my_source_runs",
+          supportedModes: ["incremental"],
+          params: [
+            {
+              id: "my_stream_param",
+              displayName: "Stream Parameter",
+              type: "string",
+              documentation: \`
+                <div>
+                  Stream Parameter example.
+                </div>
+              \`,
+              required: true,
+            },
+          ]
+        }
+      ];
+    };
+    
+    const streamReader: StreamReader<SourceConfig, StreamConfig> = async (
+      sourceConfig: SourceConfig,
+      streamType: string,
+      streamConfiguration: StreamConfiguration<StreamConfig>,
+      streamSink: StreamSink,
+      services: { state: StateService }
+    ) => {
+        //Example of saved state usage. Read previous run number:
+        let runNumber = services.state.get("run_number") || 0;
+        runNumber++ 
+        streamSink.log("INFO", "Run number: " + runNumber);
+        streamSink.addRecord({
+            $id: runNumber,
+            $recordTimestamp: new Date(),
+            type: streamType,
+            ...sourceConfig,
+            ...streamConfiguration.parameters
+        });
+        //Save last run number to state
+        services.state.set("run_number", runNumber);
+    };
+    
+    export { streamReader, sourceCatalog, descriptor, validator };
+`;
+};
+let transformCode = () => {
+    return `
+    import {TransformationFunction} from "@jitsu/types/extension";
+    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 transform;
+`;
+};
+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 \`${index_1.binName} extension create\`)",
+    configurationParameters: [
+      {id: "exampleParam", type: "string", required: true, displayName: "Example param", documentation: "Documentation"}
+    ],
+  };
+
+  export { descriptor, destination, validator };
+`;
+descriptor["transform"] = (vars) => `
+  import {ExtensionDescriptor} from "@jitsu/types/extension";
+  import transform from "./transform";
+  
+  const descriptor: ExtensionDescriptor = {
+    id: "${vars.packageName}",
+    displayName: "${vars.packageName}",
+    icon: "",
+    description: "Jitsu ${vars.type} - ${vars.packageName} (generated by \`${index_1.binName} extension create)\`"
+  }
+
+  export {descriptor, transform}
+`;
+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 => (vars.type == "source" ? sourceCode() : 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/compiled/src/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/compiled/src/lib/log.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+function log0(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) {
+            log0(console.error, { prefix: "error", color: "red" }, msg, args);
+        },
+        warn(msg, ...args) {
+            log0(console.warn, { prefix: "warn ", color: "yellow" }, msg, args);
+        },
+        spinInfo(args) { },
+        info(msg, ...args) {
+            log0(console.info, { prefix: "info ", color: "cyan" }, msg, args);
+        },
+        debug(msg, ...args) {
+            log0(console.debug, { prefix: "debug", color: "gray" }, msg, args);
+        },
+    };
+}
+const log = getLog();
+exports.default = log;

package/compiled/src/public.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryError = void 0;
+const core_functions_1 = require("@jitsu/core-functions");
+class RetryError extends Error {
+    constructor(message, options) {
+        super(message);
+        this.name = options?.drop ? `${core_functions_1.DropRetryErrorName}` : `${core_functions_1.RetryErrorName}`;
+    }
+}
+exports.RetryError = RetryError;

package/dist/main.js

@@ -726,21 +726,23 @@ function getLog(_opts) {
   var level = opts.level,
     _opts$component = opts.component,
     component = _opts$component === void 0 ? getComponent() : _opts$component;
+  var minSeverity = levelSeverities[level || globalLogLevel || "info"];
   return {
     atDebug: function atDebug() {
-      var minSeverity = levelSeverities[level || globalLogLevel || "info"];
       return minSeverity <= levelSeverities.debug ? logMessageBuilder(component, "debug") : noopLogMessageBuilder;
     },
+    inDebug: function inDebug(cb) {
+      if (minSeverity <= levelSeverities.debug) {
+        cb(logMessageBuilder(component, "debug"));
+      }
+    },
     atError: function atError() {
-      var minSeverity = levelSeverities[level || globalLogLevel || "info"];
       return minSeverity <= levelSeverities.error ? logMessageBuilder(component, "error") : noopLogMessageBuilder;
     },
     atInfo: function atInfo() {
-      var minSeverity = levelSeverities[level || globalLogLevel || "info"];
       return minSeverity <= levelSeverities.info ? logMessageBuilder(component, "info") : noopLogMessageBuilder;
     },
     atWarn: function atWarn() {
-      var minSeverity = levelSeverities[level || globalLogLevel || "info"];
       return minSeverity <= levelSeverities.warn ? logMessageBuilder(component, "warn") : noopLogMessageBuilder;
     },
     at: function at(level) {
@@ -1215,7 +1217,6 @@ function getSingleton(globalName, factory) {
     };
     return result;
   } else if (cachedValue && !cachedValue.success) {
-    cachedValue.debounceCleanup();
     throw newError("".concat(globalName, " failed during initialization: ").concat(getErrorMessage(cachedValue.error)), cachedValue.error);
   }
   log.atDebug().log("Creating ".concat(globalName, " connection..."));