jitsu-cli 2.14.0-beta.10 → 2.14.0-beta.101

package/src/lib/body-fields.ts

@@ -0,0 +1,61 @@
+// Pre-extracts body field flags from process.argv before Commander parses it.
+//
+// Why: we want users to write `--credentials.password=secret` and `--destinationType=postgres`
+// as ad-hoc body fields, but Commander would reject unknown options. The simplest robust
+// solution is to filter argv: anything matching `--<name>=<value>` whose head segment is NOT
+// a reserved Commander option is captured here, and the rest is left for Commander.
+//
+// Single global stash is fine because the CLI runs one command per process.
+
+// Reserved option names — any `--name=value` whose head is in this set is left for Commander.
+// Everything else becomes a body field (top-level for flat names, nested for dotted ones).
+const RESERVED = new Set([
+  "workspace",
+  "output",
+  "host",
+  "apikey",
+  "file",
+  "json",
+  "cascade",
+  "strict",
+  "from",
+  "to",
+  "help",
+  "version",
+]);
+
+const fields: Record<string, string> = {};
+
+// Activate body-field extraction only for the `config` command group. Otherwise the
+// preprocessor would steal flags from `deploy --type=function --name=foo` etc.
+function shouldExtract(argv: string[]): boolean {
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("-")) continue;
+    return a === "config";
+  }
+  return false;
+}
+
+export function preprocessArgv(argv: string[]): string[] {
+  if (!shouldExtract(argv)) return argv;
+  const out: string[] = [];
+  for (const arg of argv) {
+    const m = /^--([a-zA-Z][\w.-]*)=([\s\S]*)$/.exec(arg);
+    if (m) {
+      const head = m[1].split(".")[0];
+      if (!RESERVED.has(head)) {
+        fields[m[1]] = m[2];
+        continue;
+      }
+    }
+    out.push(arg);
+  }
+  return out;
+}
+
+export function consumeBodyFields(): Record<string, string> {
+  const copy = { ...fields };
+  for (const k of Object.keys(fields)) delete fields[k];
+  return copy;
+}

package/src/lib/compiled-function.ts

@@ -1,7 +1,8 @@
 import { JitsuFunction } from "@jitsu/protocols/functions";
 import fs from "fs";
-import { rollup } from "rollup";
+import * as esbuild from "esbuild";
 import { assertDefined, assertTrue } from "juava";
+import path from "path";
 
 export type CompiledFunction = {
   func: JitsuFunction;
@@ -14,10 +15,11 @@ export type CompiledFunction = {
 };
 
 function getSlug(filePath: string) {
-  return filePath.split("/").pop()?.replace(".ts", "");
+  return filePath.split("/").pop()?.replace(".ts", "").replace(".js", "");
 }
 
 export async function getFunctionFromFilePath(
+  projectDir: string,
   filePath: string,
   kind: "function" | "profile",
   profileBuilders: any[] = []
@@ -28,29 +30,34 @@ export async function getFunctionFromFilePath(
     throw new Error(`Cannot load function from file ${filePath}: path is not a file`);
   }
 
-  const bundle = await rollup({
-    input: [filePath],
-    external: ["@jitsu/functions-lib"],
-    logLevel: "silent",
+  // Transform ESM to CJS without bundling - just convert the module format
+  // This avoids resolving dependencies which may be symlinked
+  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: Record<string, any> = {} as Record<string, any>;
-  eval(output.output[0].code);
+  const code = result.code;
+  const module: { exports: Record<string, any> } = { exports: {} };
+  const exports = module.exports;
+  // Provide require stub for external imports that we mock out
+  const require = (id: string) => {
+    // External dependencies are not needed for config extraction
+    return {};
+  };
+  eval(code);
+  // After eval, module.exports contains the actual exports
+  const moduleExports = module.exports;
   assertDefined(
-    exports.default,
-    `Function from ${filePath} doesn't have default export. Exported symbols: ${Object.keys(exports)}`
+    moduleExports.default,
+    `Function from ${filePath} doesn't have default export. Exported symbols: ${Object.keys(moduleExports)}`
   );
-  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;
+  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(
@@ -67,12 +74,12 @@ export async function getFunctionFromFilePath(
   }
 
   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/src/lib/dotted.ts

@@ -0,0 +1,43 @@
+// Parse a value string from a dotted-path flag.
+// Heuristic: if it parses cleanly as JSON and starts with `[`, `{`, `"`, or is a
+// number/boolean/null literal, take the JSON value. Otherwise treat as a plain string.
+// This lets users pass arrays/objects without quoting hell while keeping bare strings
+// (`--name=foo`) working without quoting them as `"foo"`.
+export function parseScalar(raw: string): unknown {
+  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 {
+      // fall through to string
+    }
+  }
+  return raw;
+}
+
+// Build an object by setting `path` (e.g. "credentials.password") to `value`.
+// Numeric path segments (`a.0.b`) are NOT special — kept as object keys. If you
+// need arrays, pass them as JSON values (e.g. --keys='["a","b"]').
+export function setDottedPath(target: any, path: string, value: unknown): any {
+  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/src/lib/renderer.ts

@@ -0,0 +1,44 @@
+import yaml from "js-yaml";
+
+export interface Renderer {
+  format: string;
+  render(value: unknown): string;
+}
+
+const renderers: Record<string, Renderer> = {
+  yaml: {
+    format: "yaml",
+    render(value) {
+      if (value === undefined) return "";
+      // skipInvalid drops things like undefined/functions silently.
+      // noRefs avoids YAML anchors (`&id001`) which confuse readers and most YAML consumers.
+      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?: string): Renderer {
+  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: Renderer) {
+  renderers[r.format.toLowerCase()] = r;
+}
+
+export function print(value: unknown, format?: string) {
+  process.stdout.write(getRenderer(format).render(value));
+}

package/src/lib/spec.ts

@@ -0,0 +1,32 @@
+import { ApiClient } from "./api-client";
+import { AuthInfo } from "./auth-file";
+
+// Minimal subset of OpenAPI 3 we use. Avoids a runtime dep on openapi-types.
+export type OpenApiSpec = {
+  openapi?: string;
+  info?: { title?: string; version?: string; description?: string };
+  paths?: Record<string, Record<string, OpenApiOperation>>;
+  components?: { schemas?: Record<string, any> };
+};
+export type OpenApiOperation = {
+  summary?: string;
+  description?: string;
+  tags?: string[];
+  parameters?: any[];
+  requestBody?: any;
+  responses?: Record<string, any>;
+};
+
+export async function fetchSpec(auth: AuthInfo): Promise<OpenApiSpec> {
+  // /api/spec is public — no auth required, but reusing the client keeps host handling consistent.
+  const client = new ApiClient(auth);
+  return client.request<OpenApiSpec>({ method: "GET", path: "/api/spec" });
+}
+
+// Resolves the operation that matches a (templated) path + method, e.g.
+//   ("/api/{workspaceId}/config/{type}", "post") → operation node with summary/description.
+export function findOperation(spec: OpenApiSpec, path: string, method: string): OpenApiOperation | undefined {
+  const item = spec.paths?.[path];
+  if (!item) return undefined;
+  return item[method.toLowerCase()];
+}