jitsu-cli 1.10.4 → 1.11.0

package/package.json

@@ -1,38 +1,37 @@
 {
   "name": "jitsu-cli",
-  "version": "1.10.4",
+  "version": "1.11.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jitsucom/jitsu",
+    "directory": "cli/jitsu-cli"
+  },
   "description": "",
   "author": "Jitsu Dev Team <dev@jitsu.com>",
   "publishConfig": {
     "access": "public"
   },
-  "bin": "./bin/jitsu-cli",
+  "bin": {
+    "jitsu-cli": "./bin/jitsu-cli",
+    "jitsu": "./bin/jitsu"
+  },
   "license": "MIT",
   "private": false,
   "dependencies": {
+    "esbuild": "^0.28.1",
     "figlet": "^1.6.0",
     "jest-cli": "^29.7.0",
     "tslib": "^2.6.3",
     "typescript": "^5.6.3"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.23.2",
-    "@babel/preset-typescript": "^7.23.2",
-    "@rollup/plugin-commonjs": "^28.0.2",
-    "@rollup/plugin-json": "^6.0.0",
-    "@rollup/plugin-node-resolve": "^16.0.0",
-    "@rollup/plugin-terser": "^0.4.3",
-    "@rollup/plugin-typescript": "^11.1.3",
     "@types/chalk": "^2.2.0",
     "@types/commander": "^2.12.2",
     "@types/express": "^4.17.21",
     "@types/inquirer": "^9.0.3",
-    "@types/jest": "^29.5.5",
-    "@types/lodash": "^4.14.198",
+    "@types/lodash": "^4.17.24",
     "@types/node": "^18.15.3",
-    "@types/webpack": "^5.28.5",
-    "@webpack-cli/generators": "^3.0.7",
-    "babel-loader": "^9.1.3",
+    "@vitest/ui": "^4.1.4",
     "chalk": "^5.3.0",
     "commander": "^11.0.0",
     "cross-fetch": "^4.0.0",
@@ -40,26 +39,25 @@
     "etag": "^1.8.1",
     "inquirer": "^9.2.11",
     "jest": "^29.7.0",
+    "js-yaml": "^4.2.0",
+    "@types/js-yaml": "^4.0.9",
     "json5": "^2.2.3",
-    "lodash": "^4.17.21",
-    "node-fetch": "^3.3.2",
-    "node-loader": "^2.0.0",
+    "lodash": "^4.18.1",
     "prismjs": "^1.30.0",
-    "rollup": "^3.29.5",
     "semver": "^7.5.4",
-    "ts-jest": "^29.1.1",
-    "ts-loader": "^9.5.1",
-    "ts-node": "^10.9.2",
-    "webpack": "^5.99.5",
-    "webpack-cli": "^6.0.1",
-    "@jitsu/functions-lib": "1.10.4",
-    "juava": "1.10.4",
-    "@jitsu/protocols": "1.10.4"
+    "tsx": "^4.21.0",
+    "vitest": "^4.1.4",
+    "vite": "^6.4.3",
+    "@jitsu/common-config": "0.0.0",
+    "@jitsu/protocols": "0.0.0",
+    "@jitsu/functions-lib": "0.0.0",
+    "juava": "0.0.0"
   },
   "scripts": {
-    "clean": "rm -rf ./dist",
-    "compile": "tsc -p . ",
-    "build": "pnpm compile && webpack",
+    "clean": "rm -rf ./dist ./compiled",
+    "typecheck": "tsc --noEmit",
+    "build": "tsc && tsx build.mts",
+    "cli": "tsx src/index.ts",
     "run": "pnpm build && node dist/main.js",
     "login": "pnpm build && node dist/main.js login",
     "init child": "pnpm build && node dist/main.js init",

package/src/commands/build.ts

@@ -1,10 +1,6 @@
 import path from "path";
-import { mkdirSync, readdirSync, writeFileSync, existsSync, lstatSync } from "fs";
-import typescript from "@rollup/plugin-typescript";
-import resolve from "@rollup/plugin-node-resolve";
-import commonjs from "@rollup/plugin-commonjs";
-import rollupJson from "@rollup/plugin-json";
-import { ModuleFormat, rollup } from "rollup";
+import { mkdirSync, readdirSync, existsSync, lstatSync } from "fs";
+import * as esbuild from "esbuild";
 import { exec } from "child_process";
 import { loadPackageJson } from "./shared";
 import { b, green, red } from "../lib/chalk-code-highlight";
@@ -89,32 +85,31 @@ async function buildFile(projectDir: string, dir: string, fileName: string) {
   const funcFile = path.resolve(projectDir, "src", path.join(dir, fileName));
   process.chdir(projectDir);
 
-  const rollupPlugins = [
-    typescript(),
-    resolve({ preferBuiltins: false }),
-    commonjs(),
-    rollupJson(),
-    // terser(),
-  ];
+  mkdirSync(path.resolve(projectDir, "dist/" + dir), { recursive: true });
+  const compiledFunctionPath = `dist/${dir}/${fileName.replace(".ts", ".js")}`;
 
-  const bundle = await rollup({
-    input: [funcFile],
-    plugins: rollupPlugins,
+  await esbuild.build({
+    entryPoints: [funcFile],
+    absWorkingDir: projectDir,
+    bundle: true,
+    platform: "neutral",
+    format: "esm",
+    outfile: path.resolve(projectDir, compiledFunctionPath),
     external: ["@jitsu/functions-lib"],
     logLevel: "silent",
+    loader: {
+      ".json": "json",
+    },
+    // Resolve dependencies from the user's project node_modules
+    nodePaths: [path.resolve(projectDir, "node_modules")],
   });
 
-  let format: ModuleFormat = "es";
-  let output = await bundle.generate({
-    dir: projectDir,
-    format: format,
-  });
-
-  mkdirSync(path.resolve(projectDir, "dist/" + dir), { recursive: true });
-  const compiledFunctionPath = `dist/${dir}/${fileName.replace(".ts", ".js")}`;
-  writeFileSync(path.resolve(projectDir, compiledFunctionPath), output.output[0].code);
   //to verify that function is readable
-  const compiledFunction = await getFunctionFromFilePath(path.resolve(projectDir, compiledFunctionPath), "function");
+  const compiledFunction = await getFunctionFromFilePath(
+    projectDir,
+    path.resolve(projectDir, compiledFunctionPath),
+    "function"
+  );
   console.log(
     [`${green(`✓`)} Function ${b(fileName)} compiled successfully`, `  slug = ${b(compiledFunction.meta.slug)}`]
       .filter(Boolean)
@@ -128,7 +123,6 @@ function checkTypescript(projectDir: string): string[] | void {
     console.info(`No ${b("tsconfig.json")} file found in ${b(projectDir)}. Assuming JavaScript project`);
     return;
   }
-  console.log(`Checking TypeScript files in ${b(projectDir)}`);
   let compilerOptions: ts.CompilerOptions = {};
   let filenames: string[] = [];
   const tsconfig = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
@@ -137,6 +131,7 @@ function checkTypescript(projectDir: string): string[] | void {
     typeRoots: [path.resolve(projectDir, "node_modules", "@types")],
     checkJs: true,
     allowJs: true,
+    skipLibCheck: true,
     noEmit: true,
     esModuleInterop: typeof compilerOptions.esModuleInterop !== "undefined" ? compilerOptions.esModuleInterop : true,
     moduleResolution:

package/src/commands/config/handlers.ts

@@ -0,0 +1,339 @@
+import { ApiClient, ApiError } from "../../lib/api-client";
+import { readDefaultWorkspace, resolveAuth } from "../../lib/auth-file";
+import { buildBody } from "../../lib/body-builder";
+import { consumeBodyFields } from "../../lib/body-fields";
+import { print } from "../../lib/renderer";
+import { Resource } from "./resources";
+
+// `/api/{workspaceId}/config/...` endpoints take an ID — passing a slug returns empty
+// silently. Resolve via `/api/workspace/{idOrSlug}` first so `-w canalrcn` works and
+// `-w nonexistent-slug` errors out clearly instead of returning [].
+async function resolveWorkspaceId(client: ApiClient, idOrSlug: string): Promise<string> {
+  // Always go through the resolution endpoint. The server-side slug validator rejects
+  // slugs that collide with any existing workspace id, so an id and a slug can never
+  // map to different workspaces here.
+  try {
+    const ws = await client.request<{ id: string }>({
+      method: "GET",
+      path: `/api/workspace/${encodeURIComponent(idOrSlug)}`,
+    });
+    return ws.id;
+  } catch (e) {
+    if (e instanceof ApiError && e.status === 404) {
+      throw new Error(`Workspace '${idOrSlug}' not found (or you don't have access)`);
+    }
+    throw e;
+  }
+}
+
+// Common shape of leaf-command options (those known to Commander).
+export type LeafOpts = {
+  workspace?: string;
+  output?: string;
+  host?: string;
+  apikey?: string;
+  file?: string;
+  json?: string;
+  cascade?: boolean;
+  strict?: boolean;
+  from?: string;
+  to?: string;
+};
+
+// Combines body sources: -f file, --json inline, and ad-hoc field flags pre-extracted
+// from argv (e.g. --credentials.password=secret, --destinationType=postgres).
+function gatherBody(opts: LeafOpts) {
+  const fields = consumeBodyFields();
+  return buildBody({ file: opts.file, json: opts.json, fields });
+}
+
+function requireWorkspace(opts: LeafOpts): string {
+  if (opts.workspace) return opts.workspace;
+  const fallback = readDefaultWorkspace();
+  if (fallback) return fallback;
+  throw new Error("--workspace / -w is required (or set a default via `jitsu set-default-workspace <id-or-slug>`)");
+}
+
+async function requireResolvedWorkspaceId(opts: LeafOpts, client: ApiClient): Promise<string> {
+  return resolveWorkspaceId(client, requireWorkspace(opts));
+}
+
+// ----------------- list -----------------
+
+export async function runList(resource: Resource, opts: LeafOpts) {
+  const auth = resolveAuth(opts);
+  const client = new ApiClient(auth);
+
+  switch (resource.kind) {
+    case "workspace": {
+      const data = await client.request({ method: "GET", path: "/api/workspace" });
+      print(data, opts.output);
+      return;
+    }
+    case "configObject": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      const data = await client.request<{ objects: unknown[] }>({
+        method: "GET",
+        path: `/api/${encodeURIComponent(ws)}/config/${resource.type}`,
+      });
+      // Server returns { objects: [...] } — print the array directly so YAML/JSON
+      // are list-shaped and easier to pipe into other tools.
+      print(data.objects ?? data, opts.output);
+      return;
+    }
+    case "link": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      const data = await client.request<{ links: unknown[] }>({
+        method: "GET",
+        path: `/api/${encodeURIComponent(ws)}/config/link`,
+      });
+      print(data.links ?? data, opts.output);
+      return;
+    }
+    case "profile-builder": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      const data = await client.request<{ profileBuilders: unknown[] }>({
+        method: "GET",
+        path: `/api/${encodeURIComponent(ws)}/config/profile-builder`,
+      });
+      print(data.profileBuilders ?? data, opts.output);
+      return;
+    }
+  }
+}
+
+// ----------------- get -----------------
+
+export async function runGet(resource: Resource, id: string, opts: LeafOpts) {
+  const auth = resolveAuth(opts);
+  const client = new ApiClient(auth);
+
+  switch (resource.kind) {
+    case "workspace": {
+      // /api/workspace/{idOrSlug} accepts either; no extra resolution needed.
+      const data = await client.request({ method: "GET", path: `/api/workspace/${encodeURIComponent(id)}` });
+      print(data, opts.output);
+      return;
+    }
+    case "configObject": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      const data = await client.request({
+        method: "GET",
+        path: `/api/${encodeURIComponent(ws)}/config/${resource.type}/${encodeURIComponent(id)}`,
+      });
+      print(data, opts.output);
+      return;
+    }
+    default:
+      throw new Error(`get is not supported for ${resource.noun}`);
+  }
+}
+
+// ----------------- create -----------------
+
+export async function runCreate(resource: Resource, opts: LeafOpts) {
+  const auth = resolveAuth(opts);
+  const client = new ApiClient(auth);
+  const body = gatherBody(opts) ?? {};
+
+  switch (resource.kind) {
+    case "workspace": {
+      const data = await client.request({ method: "POST", path: "/api/workspace", body });
+      print(data, opts.output);
+      return;
+    }
+    case "configObject": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      const data = await client.request({
+        method: "POST",
+        path: `/api/${encodeURIComponent(ws)}/config/${resource.type}`,
+        body,
+      });
+      print(data, opts.output);
+      return;
+    }
+    case "link": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      const data = await client.request({
+        method: "POST",
+        path: `/api/${encodeURIComponent(ws)}/config/link`,
+        body,
+      });
+      print(data, opts.output);
+      return;
+    }
+    case "profile-builder": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      const data = await client.request({
+        method: "POST",
+        path: `/api/${encodeURIComponent(ws)}/config/profile-builder`,
+        body,
+      });
+      print(data, opts.output);
+      return;
+    }
+  }
+}
+
+// ----------------- update -----------------
+
+export async function runUpdate(resource: Resource, id: string | undefined, opts: LeafOpts) {
+  const auth = resolveAuth(opts);
+  const client = new ApiClient(auth);
+  const body = gatherBody(opts);
+  if (body === undefined) {
+    throw new Error("update requires at least one of -f, --json, or --field.path=value flags");
+  }
+
+  switch (resource.kind) {
+    case "workspace": {
+      if (!id) throw new Error("workspace id or slug is required");
+      const data = await client.request({
+        method: "PUT",
+        path: `/api/workspace/${encodeURIComponent(id)}`,
+        body,
+      });
+      print(data, opts.output);
+      return;
+    }
+    case "configObject": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      if (!id) throw new Error("id is required");
+      const data = await client.request({
+        method: "PUT",
+        path: `/api/${encodeURIComponent(ws)}/config/${resource.type}/${encodeURIComponent(id)}`,
+        body,
+      });
+      print(data ?? { ok: true }, opts.output);
+      return;
+    }
+    case "link": {
+      // Link upsert — server identifies via id (or fromId+toId) in the body.
+      // If the user passed a positional id, fold it into body.id so it actually reaches the API.
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      const finalBody = mergePositionalId(body, id, "id");
+      const data = await client.request({
+        method: "PUT",
+        path: `/api/${encodeURIComponent(ws)}/config/link`,
+        body: finalBody,
+      });
+      print(data, opts.output);
+      return;
+    }
+    case "profile-builder": {
+      // Upsert keyed off body.profileBuilder.id; without it the API creates a new builder
+      // even though the CLI signature requires <id>. Inject the positional id.
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      if (!id) throw new Error("id is required");
+      const finalBody = mergeNestedPositionalId(body, id, "profileBuilder", "id");
+      const data = await client.request({
+        method: "PUT",
+        path: `/api/${encodeURIComponent(ws)}/config/profile-builder`,
+        body: finalBody,
+      });
+      print(data, opts.output);
+      return;
+    }
+  }
+}
+
+// Set `body[key] = id` when id is given. Throws if body[key] is already set to a different value.
+function mergePositionalId(body: any, id: string | undefined, key: string): any {
+  if (id === undefined) return body;
+  if (body && typeof body === "object" && body[key] !== undefined && body[key] !== id) {
+    throw new Error(`positional id '${id}' conflicts with body.${key} '${body[key]}'`);
+  }
+  return { ...(body && typeof body === "object" ? body : {}), [key]: id };
+}
+
+// Same idea, one level deep: set `body[outer][inner] = id`.
+function mergeNestedPositionalId(body: any, id: string, outer: string, inner: string): any {
+  const base = body && typeof body === "object" ? body : {};
+  const nested = base[outer] && typeof base[outer] === "object" ? base[outer] : {};
+  if (nested[inner] !== undefined && nested[inner] !== id) {
+    throw new Error(`positional id '${id}' conflicts with body.${outer}.${inner} '${nested[inner]}'`);
+  }
+  return { ...base, [outer]: { ...nested, [inner]: id } };
+}
+
+// ----------------- delete -----------------
+
+export async function runDelete(resource: Resource, id: string | undefined, opts: LeafOpts) {
+  const auth = resolveAuth(opts);
+  const client = new ApiClient(auth);
+
+  switch (resource.kind) {
+    case "workspace": {
+      if (!id) throw new Error("workspace id is required");
+      const data = await client.request({
+        method: "DELETE",
+        path: "/api/workspace",
+        body: { workspaceId: id },
+      });
+      print(data, opts.output);
+      return;
+    }
+    case "configObject": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      if (!id) throw new Error("id is required");
+      const query: Record<string, string> = {};
+      if (opts.cascade) query.cascade = "true";
+      if (opts.strict) query.strict = "true";
+      const data = await client.request({
+        method: "DELETE",
+        path: `/api/${encodeURIComponent(ws)}/config/${resource.type}/${encodeURIComponent(id)}`,
+        query,
+      });
+      print(data ?? { ok: true }, opts.output);
+      return;
+    }
+    case "link": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      const query: Record<string, string> = {};
+      if (id) {
+        query.id = id;
+      } else if (opts.from && opts.to) {
+        query.fromId = opts.from;
+        query.toId = opts.to;
+      } else {
+        throw new Error("connection delete requires either <id> or both --from and --to");
+      }
+      const data = await client.request({
+        method: "DELETE",
+        path: `/api/${encodeURIComponent(ws)}/config/link`,
+        query,
+      });
+      print(data ?? { ok: true }, opts.output);
+      return;
+    }
+    case "profile-builder": {
+      const ws = await requireResolvedWorkspaceId(opts, client);
+      if (!id) throw new Error("id is required");
+      const data = await client.request({
+        method: "DELETE",
+        path: `/api/${encodeURIComponent(ws)}/config/profile-builder`,
+        query: { id },
+      });
+      print(data ?? { ok: true }, opts.output);
+      return;
+    }
+  }
+}
+
+// ----------------- test (configObject only) -----------------
+
+export async function runTest(resource: Resource, opts: LeafOpts) {
+  if (resource.kind !== "configObject" || !resource.supportsTest) {
+    throw new Error(`test is not supported for ${resource.noun}`);
+  }
+  const auth = resolveAuth(opts);
+  const client = new ApiClient(auth);
+  const ws = await requireResolvedWorkspaceId(opts, client);
+  const body = gatherBody(opts) ?? {};
+  const data = await client.request({
+    method: "POST",
+    path: `/api/${encodeURIComponent(ws)}/config/${resource.type}/test`,
+    body,
+  });
+  print(data, opts.output);
+}

package/src/commands/config/index.ts

@@ -0,0 +1,171 @@
+import { Command } from "commander";
+import { red } from "../../lib/chalk-code-highlight";
+import { DEFAULT_OUTPUT, SUPPORTED_OUTPUTS } from "../../lib/renderer";
+import { resources, Resource, Verb, verbsFor } from "./resources";
+import { LeafOpts, runCreate, runDelete, runGet, runList, runTest, runUpdate } from "./handlers";
+
+// Decorate a Command with the common options every leaf shares.
+function withCommonOpts(cmd: Command): Command {
+  return cmd
+    .option("-w, --workspace <id-or-slug>", "Target workspace id or slug")
+    .option("-o, --output <format>", `Output format: ${SUPPORTED_OUTPUTS.join(", ")}`, DEFAULT_OUTPUT)
+    .option("-h, --host <host>", "Jitsu host (overrides ~/.jitsu/jitsu-cli.json)")
+    .option("-k, --apikey <api-key>", "API key in form keyId:secret (overrides ~/.jitsu/jitsu-cli.json)");
+}
+
+function withBodyOpts(cmd: Command): Command {
+  return cmd
+    .option("-f, --file <path>", "Read body from yaml or json file (use `-` for stdin)")
+    .option("--json <json>", "Inline JSON body")
+    .addHelpText(
+      "after",
+      [
+        "",
+        "Body fields can also be set ad-hoc via --<path>=<value> flags.",
+        "Examples:",
+        "  --name=my-destination",
+        "  --destinationType=postgres",
+        "  --credentials.host=db.example.com",
+        "  --credentials.password=secret",
+        '  --credentials.keys=\'["a","b"]\'',
+        'Values starting with [, {, " or matching number/boolean/null are parsed as JSON;',
+        "everything else is a plain string. -f, --json, and --field flags merge in that order.",
+      ].join("\n")
+    );
+}
+
+// Wrap an async handler so any thrown error prints a red message and sets exit 1.
+function action<T extends any[]>(fn: (...args: T) => Promise<void> | void) {
+  return async (...args: T) => {
+    try {
+      await fn(...args);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.error(red(`Error: ${msg}`));
+      process.exit(1);
+    }
+  };
+}
+
+// Builds a leaf command for a (resource, verb) pair. The same builder is used in both
+// orderings (`config <noun> <verb>` and `config <verb> <noun>`) so the surface stays
+// consistent; only the parent.
+function buildLeaf(resource: Resource, verb: Verb): Command {
+  switch (verb) {
+    case "list": {
+      const cmd = withCommonOpts(new Command("list"))
+        .description(`List ${resource.noun}`)
+        .action(action(async (opts: LeafOpts) => runList(resource, opts)));
+      return cmd;
+    }
+    case "get": {
+      const idLabel = resource.kind === "workspace" ? "<id-or-slug>" : "<id>";
+      const cmd = withCommonOpts(new Command("get"))
+        .description(`Get a single ${singular(resource)} by id`)
+        .argument(idLabel, `Identifier of the ${singular(resource)}`)
+        .action(action(async (id: string, opts: LeafOpts) => runGet(resource, id, opts)));
+      return cmd;
+    }
+    case "create": {
+      const cmd = withBodyOpts(withCommonOpts(new Command("create")))
+        .description(`Create a ${singular(resource)}`)
+        .action(action(async (opts: LeafOpts) => runCreate(resource, opts)));
+      return cmd;
+    }
+    case "update": {
+      const idLabel = resource.kind === "link" ? "[id]" : "<id>";
+      const idDesc =
+        resource.kind === "link"
+          ? `Link id (optional — connections are upserts identified by fromId+toId)`
+          : `Identifier of the ${singular(resource)}`;
+      const cmd = withBodyOpts(withCommonOpts(new Command("update")))
+        .description(`Update a ${singular(resource)} (deep-merge into existing)`)
+        .argument(idLabel, idDesc)
+        .action(action(async (id: string | undefined, opts: LeafOpts) => runUpdate(resource, id, opts)));
+      return cmd;
+    }
+    case "delete": {
+      const idLabel = resource.kind === "link" ? "[id]" : "<id>";
+      let cmd = withCommonOpts(new Command("delete"))
+        .alias("rm")
+        .description(`Delete a ${singular(resource)}`)
+        .argument(idLabel, `Identifier of the ${singular(resource)}`);
+      if (resource.kind === "configObject") {
+        cmd = cmd
+          .option("--cascade", "Also delete linked connections that reference this object")
+          .option("--strict", "Refuse to delete if linked connections exist");
+      }
+      if (resource.kind === "link") {
+        cmd = cmd
+          .option("--from <streamOrServiceId>", "Source id (use with --to instead of <id>)")
+          .option("--to <destinationId>", "Destination id (use with --from instead of <id>)");
+      }
+      cmd = cmd.action(action(async (id: string | undefined, opts: LeafOpts) => runDelete(resource, id, opts)));
+      return cmd;
+    }
+    case "test": {
+      const cmd = withBodyOpts(withCommonOpts(new Command("test")))
+        .description(`Test connectivity for a ${singular(resource)} configuration`)
+        .action(action(async (opts: LeafOpts) => runTest(resource, opts)));
+      return cmd;
+    }
+  }
+}
+
+function singular(r: Resource): string {
+  return r.aliases[0] ?? r.noun.replace(/s$/, "");
+}
+
+export function buildConfigCommand(): Command {
+  const config = new Command("config")
+    .description("Manage workspace configuration objects (destinations, streams, connections, ...)")
+    .addHelpText(
+      "after",
+      [
+        "",
+        "Two equivalent invocation styles are supported:",
+        "  jitsu config <noun> <verb> [args]    e.g. jitsu config destinations list -w ws",
+        "  jitsu config <verb> <noun> [args]    e.g. jitsu config list destinations -w ws",
+        "",
+        "Resources:",
+        ...resources.map(r => `  ${r.noun.padEnd(20)} ${r.description}`),
+      ].join("\n")
+    );
+
+  // Tree A: noun-first. `config <noun> <verb>`
+  for (const resource of resources) {
+    const nounCmd = new Command(resource.noun).description(resource.description);
+    for (const alias of resource.aliases) nounCmd.alias(alias);
+    for (const verb of verbsFor(resource.kind)) {
+      nounCmd.addCommand(buildLeaf(resource, verb));
+    }
+    if (resource.supportsTest) {
+      nounCmd.addCommand(buildLeaf(resource, "test"));
+    }
+    config.addCommand(nounCmd);
+  }
+
+  // Tree B: verb-first. `config <verb> <noun>`
+  const allVerbs: Verb[] = ["list", "get", "create", "update", "delete", "test"];
+  for (const verb of allVerbs) {
+    const verbCmd = new Command(verb).description(
+      `${capitalize(verb)} a configuration object (alias for the noun-first form)`
+    );
+    for (const resource of resources) {
+      const applicable = verbsFor(resource.kind).includes(verb) || (verb === "test" && resource.supportsTest);
+      if (!applicable) continue;
+      const leaf = buildLeaf(resource, verb);
+      // Override the leaf's name from the verb to the noun for this tree.
+      leaf.name(resource.noun);
+      for (const alias of resource.aliases) leaf.alias(alias);
+      verbCmd.addCommand(leaf);
+    }
+    config.addCommand(verbCmd);
+  }
+
+  return config;
+}
+
+function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}