jitsu-cli 1.10.4 → 1.11.0

package/compiled/src/lib/compiled-function.js

@@ -1,37 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionFromFilePath = getFunctionFromFilePath;
-const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const rollup_1 = require("rollup");
-const juava_1 = require("juava");
+import fs from "fs";
+import * as esbuild from "esbuild";
+import { assertDefined, assertTrue } from "juava";
 function getSlug(filePath) {
-    return filePath.split("/").pop()?.replace(".ts", "");
+    return filePath.split("/").pop()?.replace(".ts", "").replace(".js", "");
 }
-async function getFunctionFromFilePath(filePath, kind, profileBuilders = []) {
-    if (!fs_1.default.existsSync(filePath)) {
+export async function getFunctionFromFilePath(projectDir, filePath, kind, profileBuilders = []) {
+    if (!fs.existsSync(filePath)) {
         throw new Error(`Cannot load function from file ${filePath}: file doesn't exist`);
     }
-    else if (!fs_1.default.statSync(filePath).isFile()) {
+    else if (!fs.statSync(filePath).isFile()) {
         throw new Error(`Cannot load function from file ${filePath}: path is not a file`);
     }
-    const bundle = await (0, rollup_1.rollup)({
-        input: [filePath],
-        external: ["@jitsu/functions-lib"],
-        logLevel: "silent",
+    const result = await esbuild.transform(fs.readFileSync(filePath, "utf-8"), {
+        loader: filePath.endsWith(".ts") ? "ts" : "js",
+        format: "cjs",
+        platform: "node",
     });
-    const output = await bundle.generate({
-        file: filePath,
-        format: "commonjs",
-    });
-    const exports = {};
-    eval(output.output[0].code);
-    (0, juava_1.assertDefined)(exports.default, `Function from ${filePath} doesn't have default export. Exported symbols: ${Object.keys(exports)}`);
-    (0, juava_1.assertTrue)(typeof exports.default === "function", `Default export from ${filePath} is not a function`);
-    let name = exports.config?.name || exports.config?.slug || getSlug(filePath);
-    let id = exports.config?.id;
+    const code = result.code;
+    const module = { exports: {} };
+    const exports = module.exports;
+    const require = (id) => {
+        return {};
+    };
+    eval(code);
+    const moduleExports = module.exports;
+    assertDefined(moduleExports.default, `Function from ${filePath} doesn't have default export. Exported symbols: ${Object.keys(moduleExports)}`);
+    assertTrue(typeof moduleExports.default === "function", `Default export from ${filePath} is not a function`);
+    let name = moduleExports.config?.name || moduleExports.config?.slug || getSlug(filePath);
+    let id = moduleExports.config?.id;
     if (kind === "profile") {
-        const profileBuilderId = exports.config?.profileBuilderId;
+        const profileBuilderId = moduleExports.config?.profileBuilderId;
         const profileBuilder = profileBuilders.find(pb => pb.id === profileBuilderId);
         if (!profileBuilder) {
             throw new Error(`Cannot find profile builder with id ${profileBuilderId} for profile function ${filePath}. Please setup Profile Builder in UI first.`);
@@ -43,12 +41,12 @@ async function getFunctionFromFilePath(filePath, kind, profileBuilders = []) {
         }
     }
     return {
-        func: exports.default,
+        func: moduleExports.default,
         meta: {
-            slug: exports.config?.slug || getSlug(filePath),
+            slug: moduleExports.config?.slug || getSlug(filePath),
             id: id,
             name: name,
-            description: exports.config?.description,
+            description: moduleExports.config?.description,
         },
     };
 }

package/compiled/src/lib/dotted.js

@@ -0,0 +1,34 @@
+export function parseScalar(raw) {
+    if (raw === "")
+        return "";
+    const trimmed = raw.trim();
+    const first = trimmed[0];
+    const looksLikeJson = first === "{" ||
+        first === "[" ||
+        first === '"' ||
+        trimmed === "true" ||
+        trimmed === "false" ||
+        trimmed === "null" ||
+        /^-?\d/.test(trimmed);
+    if (looksLikeJson) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+        }
+    }
+    return raw;
+}
+export function setDottedPath(target, path, value) {
+    const parts = path.split(".");
+    let node = target;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (node[key] == null || typeof node[key] !== "object" || Array.isArray(node[key])) {
+            node[key] = {};
+        }
+        node = node[key];
+    }
+    node[parts[parts.length - 1]] = value;
+    return target;
+}

package/compiled/src/lib/indent.js

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

package/compiled/src/lib/project-config.js

@@ -0,0 +1,20 @@
+import path from "path";
+import { existsSync, readFileSync } from "fs";
+import { b } from "./chalk-code-highlight";
+export function loadProjectConfig(projectDir, packageJson) {
+    const jitsuJsonPath = path.resolve(projectDir, "jitsu.json");
+    if (existsSync(jitsuJsonPath)) {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(jitsuJsonPath, "utf-8"));
+        }
+        catch (e) {
+            throw new Error(`Failed to parse ${b(jitsuJsonPath)}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return parsed ?? {};
+    }
+    if (packageJson?.jitsu && typeof packageJson.jitsu === "object") {
+        return packageJson.jitsu;
+    }
+    return {};
+}

package/compiled/src/lib/renderer.js

@@ -0,0 +1,33 @@
+import yaml from "js-yaml";
+const renderers = {
+    yaml: {
+        format: "yaml",
+        render(value) {
+            if (value === undefined)
+                return "";
+            return yaml.dump(value, { skipInvalid: true, noRefs: true, sortKeys: false, lineWidth: 120 });
+        },
+    },
+    json: {
+        format: "json",
+        render(value) {
+            return JSON.stringify(value, null, 2) + "\n";
+        },
+    },
+};
+export const SUPPORTED_OUTPUTS = Object.keys(renderers);
+export const DEFAULT_OUTPUT = "yaml";
+export function getRenderer(format) {
+    const key = (format ?? DEFAULT_OUTPUT).toLowerCase();
+    const r = renderers[key];
+    if (!r) {
+        throw new Error(`Unsupported output format '${format}'. Supported: ${SUPPORTED_OUTPUTS.join(", ")}`);
+    }
+    return r;
+}
+export function registerRenderer(r) {
+    renderers[r.format.toLowerCase()] = r;
+}
+export function print(value, format) {
+    process.stdout.write(getRenderer(format).render(value));
+}

package/compiled/src/lib/spec.js

@@ -0,0 +1,11 @@
+import { ApiClient } from "./api-client";
+export async function fetchSpec(auth) {
+    const client = new ApiClient(auth);
+    return client.request({ method: "GET", path: "/api/spec" });
+}
+export function findOperation(spec, path, method) {
+    const item = spec.paths?.[path];
+    if (!item)
+        return undefined;
+    return item[method.toLowerCase()];
+}

package/compiled/src/lib/template.js

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

package/compiled/src/lib/version.js

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

package/compiled/src/templates/functions.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.functionProjectTemplate = exports.packageJsonTemplate = void 0;
-const version_1 = require("../lib/version");
-const juava_1 = require("juava");
-const packageJsonTemplate = ({ packageName, license = "MIT", jitsuVersion = undefined }) => ({
+import { jitsuCliVersion, jitsuCliPackageName } from "../lib/version";
+import { sanitize } from "juava";
+export const packageJsonTemplate = ({ packageName, license = "MIT", jitsuVersion = undefined }) => ({
     name: `${packageName}`,
     version: "0.0.1",
     description: `Jitsu extension - ${packageName}`,
@@ -11,23 +8,22 @@ const packageJsonTemplate = ({ packageName, license = "MIT", jitsuVersion = unde
     keywords: ["jitsu", "jitsu-cli", "function", `jitsu-extension`],
     scripts: {
         clean: "rm -rf ./dist",
-        build: `${version_1.jitsuCliPackageName} build`,
-        test: `${version_1.jitsuCliPackageName} test`,
-        deploy: `${version_1.jitsuCliPackageName} deploy`,
+        build: `${jitsuCliPackageName} build`,
+        test: `${jitsuCliPackageName} test`,
+        deploy: `${jitsuCliPackageName} deploy`,
     },
     devDependencies: {
-        "jitsu-cli": `${jitsuVersion || "^" + version_1.jitsuCliVersion}`,
-        "@jitsu/protocols": `${jitsuVersion || "^" + version_1.jitsuCliVersion}`,
-        "@jitsu/functions-lib": `${jitsuVersion || "^" + version_1.jitsuCliVersion}`,
+        "jitsu-cli": `${jitsuVersion || "^" + jitsuCliVersion}`,
+        "@jitsu/protocols": `${jitsuVersion || "^" + jitsuCliVersion}`,
+        "@jitsu/functions-lib": `${jitsuVersion || "^" + jitsuCliVersion}`,
         "@types/jest": "^29.5.5",
         "ts-jest": "^29.1.1",
     },
     dependencies: {},
 });
-exports.packageJsonTemplate = packageJsonTemplate;
 let functionTest = ({ packageName }) => {
     return `
-test("${(0, juava_1.sanitize)(packageName)} test", () => {
+test("${sanitize(packageName)} test", () => {
   //TODO: implement test
 });
 `;
@@ -55,7 +51,7 @@ export default helloWorldFunction;
 };
 let profileTest = ({ packageName }) => {
     return `
-test("${(0, juava_1.sanitize)(packageName)} test", () => {
+test("${sanitize(packageName)} test", () => {
   //TODO: implement test
 });
 `;
@@ -85,12 +81,12 @@ const profileExample: ProfileFunction = async (events, user, context) => {
 export default profileExample;
 `;
 };
-const functionProjectTemplate = ({ packageName }) => ({
+export const functionProjectTemplate = ({ packageName }) => ({
     [`__tests__/profiles/profile-example.test.ts`]: profileTest,
     [`__tests__/functions/hello.test.ts`]: functionTest,
     [`src/profiles/profile-example.ts`]: profileCode,
     [`src/functions/hello.ts`]: functionCode,
-    "package.json": exports.packageJsonTemplate,
+    "package.json": packageJsonTemplate,
     "tsconfig.json": {
         compilerOptions: {
             rootDir: "./src",
@@ -108,4 +104,3 @@ const functionProjectTemplate = ({ packageName }) => ({
         exclude: ["__tests__", "node_modules", "dist"],
     },
 });
-exports.functionProjectTemplate = functionProjectTemplate;