jitsu-cli 1.10.4 → 1.11.0

package/src/lib/auth-file.ts

@@ -0,0 +1,83 @@
+import * as fs from "fs";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+
+export type AuthInfo = { host: string; apikey: string };
+
+export type AuthFile = {
+  host?: string;
+  apikey?: string;
+  defaultWorkspace?: string;
+};
+
+const DEFAULT_HOST = "https://use.jitsu.com";
+
+export function authFilePath(): string {
+  return `${homedir()}/.jitsu/jitsu-cli.json`;
+}
+
+export function readAuthFile(): AuthFile | undefined {
+  const path = authFilePath();
+  if (!fs.existsSync(path)) return undefined;
+  return JSON.parse(readFileSync(path, { encoding: "utf-8" }));
+}
+
+// Merge `patch` into the existing auth file, creating the file (and parent dir)
+// if necessary. Setting a field to `undefined` removes it.
+export function updateAuthFile(patch: Partial<AuthFile>): AuthFile {
+  const path = authFilePath();
+  const existing = readAuthFile() ?? {};
+  const next: AuthFile = { ...existing };
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === undefined) delete (next as any)[k];
+    else (next as any)[k] = v;
+  }
+  mkdirSync(`${homedir()}/.jitsu`, { recursive: true });
+  writeFileSync(path, JSON.stringify(next, null, 2));
+  return next;
+}
+
+export function readDefaultWorkspace(): string | undefined {
+  return readAuthFile()?.defaultWorkspace;
+}
+
+// Resolve host + apikey for an authenticated CLI command. Order of precedence:
+//   1. --host / --apikey flags
+//   2. ~/.jitsu/jitsu-cli.json
+//   3. JITSU_HOST / JITSU_APIKEY env vars
+//   4. https://use.jitsu.com (host only)
+export function resolveAuth(opts: { host?: string; apikey?: string }): AuthInfo {
+  let host = opts.host;
+  let apikey = opts.apikey;
+
+  if (!host || !apikey) {
+    const file = readAuthFile();
+    if (file) {
+      if (!host) host = file.host;
+      if (!apikey) apikey = file.apikey;
+    }
+  }
+
+  if (!host) host = process.env.JITSU_HOST;
+  if (!apikey) apikey = process.env.JITSU_APIKEY;
+  if (!host) host = DEFAULT_HOST;
+
+  if (!apikey) {
+    throw new Error("Not authenticated. Run `jitsu login`, set JITSU_APIKEY, or pass --apikey <key>.");
+  }
+
+  return { host: normalizeHost(host), apikey };
+}
+
+export function normalizeHost(host: string): string {
+  let url = host;
+  if (!url.startsWith("http")) {
+    if (url.startsWith("localhost") || /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/.test(url)) {
+      url = "http://" + url;
+    } else {
+      url = "https://" + url;
+    }
+  }
+  if (url.endsWith("/")) url = url.slice(0, -1);
+  return url;
+}

package/src/lib/body-builder.ts

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+import yaml from "js-yaml";
+import { parseScalar, setDottedPath } from "./dotted";
+
+export type BodySources = {
+  // Path to a yaml/json file. `-` means stdin.
+  file?: string;
+  // Inline JSON string (full body or partial).
+  json?: string;
+  // Already-parsed dotted-path fields, e.g. { "credentials.password": "secret" }.
+  fields?: Record<string, string>;
+};
+
+// Builds a single request body by merging (deep) sources in this order:
+//   1. -f / --file
+//   2. --json
+//   3. dotted-path flags
+// Later sources override earlier ones at the leaf level. Arrays are replaced, not concatenated.
+// Returns undefined if no source is provided.
+export function buildBody(sources: BodySources): unknown {
+  const layers: any[] = [];
+  if (sources.file) layers.push(loadFile(sources.file));
+  if (sources.json) layers.push(parseInlineJson(sources.json));
+  if (sources.fields && Object.keys(sources.fields).length > 0) {
+    const obj: any = {};
+    for (const [path, raw] of Object.entries(sources.fields)) {
+      setDottedPath(obj, path, parseScalar(raw));
+    }
+    layers.push(obj);
+  }
+  if (layers.length === 0) return undefined;
+  return layers.reduce((acc, layer) => deepMerge(acc, layer), {});
+}
+
+function loadFile(path: string): unknown {
+  const text = path === "-" ? fs.readFileSync(0, "utf-8") : fs.readFileSync(path, "utf-8");
+  // js-yaml's safeLoad handles JSON too (JSON is valid YAML). But trim first — empty file is null.
+  const parsed = yaml.load(text);
+  if (parsed === null || parsed === undefined) {
+    throw new Error(`File ${path} parsed as empty`);
+  }
+  return parsed;
+}
+
+function parseInlineJson(s: string): unknown {
+  try {
+    return JSON.parse(s);
+  } catch (e) {
+    throw new Error(`--json value is not valid JSON: ${(e as Error).message}`);
+  }
+}
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+function deepMerge(target: any, source: any): any {
+  if (!isPlainObject(target) || !isPlainObject(source)) return source;
+  const out: any = { ...target };
+  for (const [k, v] of Object.entries(source)) {
+    if (isPlainObject(v) && isPlainObject(out[k])) {
+      out[k] = deepMerge(out[k], v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}

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/project-config.ts

@@ -0,0 +1,32 @@
+import path from "path";
+import { existsSync, readFileSync } from "fs";
+import { b } from "./chalk-code-highlight";
+
+// Per-project Jitsu configuration, committed alongside the project so a deploy
+// doesn't need machine-global state or CLI flags. Vercel-style (jitsu.json).
+export type ProjectConfig = {
+  // Workspace id or slug to deploy to. Overridden by the -w/--workspace flag.
+  workspace?: string;
+};
+
+// Reads per-project config. Precedence:
+//   1. jitsu.json at the project root
+//   2. "jitsu" key in package.json
+// Returns {} when neither is present. `packageJson` is passed in to avoid a
+// second read of a file the caller already parsed.
+export function loadProjectConfig(projectDir: string, packageJson?: any): ProjectConfig {
+  const jitsuJsonPath = path.resolve(projectDir, "jitsu.json");
+  if (existsSync(jitsuJsonPath)) {
+    let parsed: any;
+    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 as ProjectConfig;
+  }
+  return {};
+}

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()];
+}

package/tsconfig.json

@@ -1,26 +1,9 @@
 {
+  "extends": "@jitsu/common-config/tsconfig.json",
   "compilerOptions": {
     "outDir": "./compiled",
-    "rootDir": ".",
-    "noImplicitAny": false,
-    "allowSyntheticDefaultImports": true,
-    "importHelpers": true,
-    "removeComments": true,
-    "target": "ES2021",
-    "module": "commonjs",
-    "lib": [
-      "dom","esnext"
-    ],
-    "allowJs": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "skipLibCheck": true
+    "rootDir": "."
   },
-  "exclude": [
-    "node_modules"
-  ],
   "include": [
     "src/**/*"
   ]

package/.turbo/turbo-build.log

@@ -1,28 +0,0 @@
-jitsu-cli:build: cache hit, replaying output dcca113b76fcc4b6
-jitsu-cli:build: 
-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/ildarnurislamov/Projects/newjitsu/cli/jitsu-cli
-jitsu-cli:build: > tsc -p . 
-jitsu-cli:build: 
-jitsu-cli:build: asset main.js 3.45 MiB [emitted] (name: main) 1 related asset
-jitsu-cli:build: asset 233.js 130 KiB [emitted] (id hint: vendors) 1 related asset
-jitsu-cli:build: asset 445e7f36f8a19c2bf682.js 37.3 KiB [emitted] [immutable] [from: ../../node_modules/.pnpm/@rollup+plugin-typescript@11.1.6_rollup@3.29.5_tslib@2.8.0_typescript@5.6.3/node_modules/@rollup/plugin-typescript/dist/es/index.js] (auxiliary name: main)
-jitsu-cli:build: asset 140.js 10 KiB [emitted] 1 related asset
-jitsu-cli:build: orphan modules 574 KiB [orphan] 100 modules
-jitsu-cli:build: runtime modules 3.62 KiB 10 modules
-jitsu-cli:build: cacheable modules 2.84 MiB (javascript) 37.3 KiB (asset)
-jitsu-cli:build:   javascript modules 2.49 MiB 428 modules
-jitsu-cli:build:   json modules 363 KiB
-jitsu-cli:build:     modules by path ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/ 86.7 KiB
-jitsu-cli:build:       ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tab...(truncated) 8.78 KiB [built] [code generated]
-jitsu-cli:build:       + 7 modules
-jitsu-cli:build:     + 4 modules
-jitsu-cli:build:   ../../node_modules/.pnpm/@rollup+plugin-typescript@11.1.6_rollup@3.29.5_tslib@2....(truncated) 37.3 KiB (asset) 42 bytes (javascript) [built] [code generated]
-jitsu-cli:build: optional modules 84 bytes [optional]
-jitsu-cli:build:   external "worker_threads" 42 bytes [optional] [built] [code generated]
-jitsu-cli:build:   external "node:stream/web" 42 bytes [optional] [built] [code generated]
-jitsu-cli:build: + 26 modules
-jitsu-cli:build: webpack 5.99.5 compiled successfully in 4904 ms

package/.turbo/turbo-clean.log

@@ -1,5 +0,0 @@
-jitsu-cli:clean: cache hit, replaying output fc669d593044a2dc
-jitsu-cli:clean: 
-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/babel.config.cjs

@@ -1,4 +0,0 @@
-module.exports = {
-  presets: ["@babel/preset-env", "@babel/preset-typescript"],
-  plugins: [],
-};