jitsu-cli 2.14.0-beta.8 → 2.14.0-beta.93

package/compiled/src/commands/config/resources.js

@@ -0,0 +1,88 @@
+export const resources = [
+    {
+        noun: "workspaces",
+        aliases: ["workspace"],
+        kind: "workspace",
+        description: "Workspaces accessible to the current user",
+    },
+    {
+        noun: "destinations",
+        aliases: ["destination", "dest"],
+        kind: "configObject",
+        type: "destination",
+        supportsTest: true,
+        description: "Destinations (warehouses, databases, services receiving events)",
+    },
+    {
+        noun: "streams",
+        aliases: ["stream"],
+        kind: "configObject",
+        type: "stream",
+        supportsTest: true,
+        description: "Event streams (formerly known as sources)",
+    },
+    {
+        noun: "functions",
+        aliases: ["function", "fn"],
+        kind: "configObject",
+        type: "function",
+        description: "User-defined functions (UDFs). For dev workflow see `jitsu deploy`.",
+    },
+    {
+        noun: "services",
+        aliases: ["service"],
+        kind: "configObject",
+        type: "service",
+        supportsTest: true,
+        description: "External connector services (Airbyte protocol)",
+    },
+    {
+        noun: "domains",
+        aliases: ["domain"],
+        kind: "configObject",
+        type: "domain",
+        description: "Custom ingestion domains",
+    },
+    {
+        noun: "misc",
+        aliases: [],
+        kind: "configObject",
+        type: "misc",
+        description: "Miscellaneous configuration entities (free-form)",
+    },
+    {
+        noun: "notifications",
+        aliases: ["notification"],
+        kind: "configObject",
+        type: "notification",
+        description: "Alert channels (email/Slack)",
+    },
+    {
+        noun: "connections",
+        aliases: ["connection", "link", "links"],
+        kind: "link",
+        description: "Connections between streams/services and destinations",
+    },
+    {
+        noun: "profile-builders",
+        aliases: ["profile-builder"],
+        kind: "profile-builder",
+        description: "Profile builders (identity stitching)",
+    },
+];
+export function verbsFor(kind) {
+    switch (kind) {
+        case "configObject":
+            return ["list", "get", "create", "update", "delete"];
+        case "workspace":
+            return ["list", "get", "create", "update", "delete"];
+        case "link":
+            return ["list", "create", "update", "delete"];
+        case "profile-builder":
+            return ["list", "create", "update", "delete"];
+    }
+}
+export function findResource(name) {
+    const lower = name.toLowerCase();
+    return resources.find(r => r.noun === lower || r.aliases.includes(lower));
+}

package/compiled/src/commands/default-workspace.js

@@ -0,0 +1,39 @@
+import { ApiClient, ApiError } from "../lib/api-client";
+import { authFilePath, readAuthFile, resolveAuth, updateAuthFile } from "../lib/auth-file";
+import { red } from "../lib/chalk-code-highlight";
+export async function setDefaultWorkspace(idOrSlug, opts) {
+    try {
+        const auth = resolveAuth(opts);
+        const client = new ApiClient(auth);
+        let workspace;
+        try {
+            workspace = await client.request({
+                method: "GET",
+                path: `/api/workspace/${encodeURIComponent(idOrSlug)}`,
+            });
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 404) {
+                throw new Error(`Workspace '${idOrSlug}' not found (or you don't have access)`);
+            }
+            throw e;
+        }
+        updateAuthFile({ defaultWorkspace: workspace.id });
+        const label = workspace.slug ? `${workspace.slug} (${workspace.id})` : workspace.id;
+        console.log(`Default workspace set to ${label}.`);
+        console.log(`Saved to ${authFilePath()}.`);
+    }
+    catch (e) {
+        console.error(red(`Error: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+    }
+}
+export async function unsetDefaultWorkspace() {
+    const file = readAuthFile();
+    if (!file?.defaultWorkspace) {
+        console.log("No default workspace is set.");
+        return;
+    }
+    updateAuthFile({ defaultWorkspace: undefined });
+    console.log("Default workspace unset.");
+}

package/compiled/src/commands/deploy.js

@@ -3,7 +3,6 @@ import { homedir } from "os";
 import inquirer from "inquirer";
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { loadPackageJson } from "./shared";
-import fetch from "node-fetch";
 import cuid from "cuid";
 import { b, green, red } from "../lib/chalk-code-highlight";
 import { getFunctionFromFilePath } from "../lib/compiled-function";
@@ -103,14 +102,56 @@ async function deployFunctions({ host, apikey, name: names }, projectDir, packag
         }
         profileBuilders = (await res.json()).profileBuilders;
     }
+    const existingFunctions = await fetchExistingFunctions({ host, apikey, workspaceId: workspace.id });
     for (const file of selectedFiles) {
         console.log(`${b(`𝑓`)} Deploying function ${b(path.basename(file))} to workspace ${workspace.name} (${host}/${workspace.slug || workspace.id})`);
-        await deployFunction({ host, apikey }, packageJson, workspace, kind, path.resolve(functionsDir, file), profileBuilders);
+        await deployFunction(projectDir, { host, apikey }, packageJson, workspace, kind, path.resolve(functionsDir, file), profileBuilders, existingFunctions);
     }
 }
-async function deployFunction({ host, apikey }, packageJson, workspace, kind, file, profileBuilders = []) {
+async function fetchExistingFunctions({ host, apikey, workspaceId, }) {
+    const res = await fetch(`${host}/api/${workspaceId}/config/function`, {
+        headers: { Authorization: `Bearer ${apikey}` },
+    });
+    if (!res.ok) {
+        console.error(red(`Cannot list existing functions:\n${b(await res.text())}`));
+        process.exit(1);
+    }
+    const { objects } = (await res.json());
+    const bySlug = new Map();
+    const byId = new Map();
+    for (const f of objects) {
+        const entry = { id: f.id, slug: f.slug };
+        byId.set(f.id, entry);
+        if (f.slug)
+            bySlug.set(f.slug, entry);
+    }
+    return { bySlug, byId };
+}
+function cacheAfterCreate(cache, id, slug) {
+    const entry = { id, slug };
+    cache.byId.set(id, entry);
+    if (slug)
+        cache.bySlug.set(slug, entry);
+}
+function cacheAfterUpdate(cache, id, newSlug) {
+    const entry = cache.byId.get(id);
+    if (!entry) {
+        cacheAfterCreate(cache, id, newSlug);
+        return;
+    }
+    if (entry.slug && entry.slug !== newSlug) {
+        cache.bySlug.delete(entry.slug);
+    }
+    entry.slug = newSlug;
+    if (newSlug)
+        cache.bySlug.set(newSlug, entry);
+}
+async function deployFunction(projectDir, { host, apikey }, packageJson, workspace, kind, file, profileBuilders = [], existingFunctions = {
+    bySlug: new Map(),
+    byId: new Map(),
+}) {
     const code = readFileSync(file, "utf-8");
-    const wrapped = await getFunctionFromFilePath(file, kind, profileBuilders);
+    const wrapped = await getFunctionFromFilePath(projectDir, file, kind, profileBuilders);
     const meta = wrapped.meta;
     if (meta) {
         console.log(`  meta: slug=${meta.slug}, name=${meta.name || "not set"}`);
@@ -121,19 +162,8 @@ async function deployFunction({ host, apikey }, packageJson, workspace, kind, fi
     }
     let existingFunctionId;
     if (meta.slug) {
-        const res = await fetch(`${host}/api/${workspace.id}/config/function`, {
-            headers: {
-                Authorization: `Bearer ${apikey}`,
-            },
-        });
-        if (!res.ok) {
-            console.error(red(`Cannot add function to workspace:\n${b(await res.text())}`));
-            process.exit(1);
-        }
-        else {
-            const existing = (await res.json());
-            existingFunctionId = existing.objects.find(f => f.slug === meta.slug || f.id === meta.id)?.id;
-        }
+        existingFunctionId =
+            existingFunctions.bySlug.get(meta.slug)?.id ?? (meta.id ? existingFunctions.byId.get(meta.id)?.id : undefined);
     }
     let functionPayload = {};
     if (kind === "profile") {
@@ -172,6 +202,7 @@ async function deployFunction({ host, apikey }, packageJson, workspace, kind, fi
             process.exit(1);
         }
         else {
+            cacheAfterCreate(existingFunctions, id, meta.slug);
             console.log(`Function ${b(meta.name)} was successfully added to workspace ${workspace.name} with id: ${b(id)}`);
         }
     }
@@ -199,6 +230,7 @@ async function deployFunction({ host, apikey }, packageJson, workspace, kind, fi
             process.exit(1);
         }
         else {
+            cacheAfterUpdate(existingFunctions, id, meta.slug);
             console.log(`${green(`✓`)} ${b(meta.name)} deployed successfully!`);
         }
     }

package/compiled/src/commands/spec.js

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { red } from "../lib/chalk-code-highlight";
+import { normalizeHost, readAuthFile, resolveAuth } from "../lib/auth-file";
+import { fetchSpec } from "../lib/spec";
+import { DEFAULT_OUTPUT, SUPPORTED_OUTPUTS, print } from "../lib/renderer";
+export function buildSpecCommand() {
+    return new Command("spec")
+        .description("Print the live OpenAPI spec served at /api/spec")
+        .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 (overrides ~/.jitsu/jitsu-cli.json)")
+        .action(async (opts) => {
+        try {
+            const auth = (() => {
+                try {
+                    return resolveAuth(opts);
+                }
+                catch {
+                    const host = opts.host ?? readAuthFile()?.host ?? "https://use.jitsu.com";
+                    return { host: normalizeHost(host), apikey: "anonymous" };
+                }
+            })();
+            const spec = await fetchSpec(auth);
+            print(spec, opts.output);
+        }
+        catch (e) {
+            console.error(red(`Error: ${e instanceof Error ? e.message : String(e)}`));
+            process.exit(1);
+        }
+    });
+}

package/compiled/src/index.js

@@ -7,9 +7,17 @@ import { build } from "./commands/build";
 import { test } from "./commands/test";
 import { jitsuCliVersion, jitsuCliPackageName } from "./lib/version";
 import { whoami } from "./commands/whoami";
-console.log(figlet.textSync("Jitsu CLI", { horizontalLayout: "full" }));
+import { buildConfigCommand } from "./commands/config";
+import { buildSpecCommand } from "./commands/spec";
+import { setDefaultWorkspace, unsetDefaultWorkspace } from "./commands/default-workspace";
+import { preprocessArgv } from "./lib/body-fields";
+process.argv = preprocessArgv(process.argv);
+const isPipedStdout = !process.stdout.isTTY;
+if (!isPipedStdout) {
+    process.stderr.write(figlet.textSync("Jitsu CLI", { horizontalLayout: "full" }) + "\n");
+}
 const p = new Command();
-p.name(jitsuCliPackageName).description("CLI command to create, test and deploy extensions for Jitsu Next");
+p.name(jitsuCliPackageName).description("Jitsu CLI — manage workspaces, configuration objects, and extensions");
 p.command("init")
     .description("Initialize a new Jitsu extension project")
     .arguments("[dir]")
@@ -45,6 +53,17 @@ p.command("deploy")
     .option("-t, --type <type>", "entity type to deploy", "function")
     .option("-n, --name <name...>", "limit deploy to provided entities only. (Optional)")
     .action(deploy);
+p.command("set-default-workspace")
+    .description("Save a default workspace to ~/.jitsu/jitsu-cli.json. Subsequent `jitsu config` commands use it when -w is omitted.")
+    .argument("<id-or-slug>", "Workspace id or slug")
+    .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)")
+    .action(setDefaultWorkspace);
+p.command("unset-default-workspace")
+    .description("Remove the saved default workspace from ~/.jitsu/jitsu-cli.json")
+    .action(unsetDefaultWorkspace);
+p.addCommand(buildConfigCommand());
+p.addCommand(buildSpecCommand());
 p.version(jitsuCliPackageName + " " + jitsuCliVersion, "-v, --version");
 p.helpOption("--help", "display help for command");
 p.parse();

package/compiled/src/lib/api-client.js

@@ -0,0 +1,52 @@
+export class ApiError extends Error {
+    constructor(status, message, payload) {
+        super(message);
+        this.status = status;
+        this.payload = payload;
+    }
+}
+export class ApiClient {
+    constructor(auth) {
+        this.auth = auth;
+    }
+    url(path, query) {
+        const base = this.auth.host;
+        const p = path.startsWith("/") ? path : `/${path}`;
+        if (!query)
+            return `${base}${p}`;
+        const qs = Object.entries(query)
+            .filter(([, v]) => v !== undefined && v !== null && v !== "")
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+            .join("&");
+        return qs ? `${base}${p}?${qs}` : `${base}${p}`;
+    }
+    async request(req) {
+        const method = req.method ?? "GET";
+        const headers = {
+            Accept: "application/json",
+            Authorization: `Bearer ${this.auth.apikey}`,
+        };
+        let body;
+        if (req.body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            body = JSON.stringify(req.body);
+        }
+        const res = await fetch(this.url(req.path, req.query), { method, headers, body });
+        const text = await res.text();
+        let parsed = text;
+        if (text && res.headers.get("content-type")?.includes("application/json")) {
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+            }
+        }
+        if (!res.ok) {
+            const msg = (parsed && typeof parsed === "object" && "message" in parsed
+                ? String(parsed.message)
+                : undefined) ?? `HTTP ${res.status} ${method} ${req.path}`;
+            throw new ApiError(res.status, msg, parsed);
+        }
+        return parsed;
+    }
+}

package/compiled/src/lib/auth-file.js

@@ -0,0 +1,67 @@
+import * as fs from "fs";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+const DEFAULT_HOST = "https://use.jitsu.com";
+export function authFilePath() {
+    return `${homedir()}/.jitsu/jitsu-cli.json`;
+}
+export function readAuthFile() {
+    const path = authFilePath();
+    if (!fs.existsSync(path))
+        return undefined;
+    return JSON.parse(readFileSync(path, { encoding: "utf-8" }));
+}
+export function updateAuthFile(patch) {
+    const path = authFilePath();
+    const existing = readAuthFile() ?? {};
+    const next = { ...existing };
+    for (const [k, v] of Object.entries(patch)) {
+        if (v === undefined)
+            delete next[k];
+        else
+            next[k] = v;
+    }
+    mkdirSync(`${homedir()}/.jitsu`, { recursive: true });
+    writeFileSync(path, JSON.stringify(next, null, 2));
+    return next;
+}
+export function readDefaultWorkspace() {
+    return readAuthFile()?.defaultWorkspace;
+}
+export function resolveAuth(opts) {
+    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) {
+    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/compiled/src/lib/body-builder.js

@@ -0,0 +1,53 @@
+import * as fs from "fs";
+import yaml from "js-yaml";
+import { parseScalar, setDottedPath } from "./dotted";
+export function buildBody(sources) {
+    const layers = [];
+    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 = {};
+        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) {
+    const text = path === "-" ? fs.readFileSync(0, "utf-8") : fs.readFileSync(path, "utf-8");
+    const parsed = yaml.load(text);
+    if (parsed === null || parsed === undefined) {
+        throw new Error(`File ${path} parsed as empty`);
+    }
+    return parsed;
+}
+function parseInlineJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch (e) {
+        throw new Error(`--json value is not valid JSON: ${e.message}`);
+    }
+}
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMerge(target, source) {
+    if (!isPlainObject(target) || !isPlainObject(source))
+        return source;
+    const out = { ...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/compiled/src/lib/body-fields.js

@@ -0,0 +1,47 @@
+const RESERVED = new Set([
+    "workspace",
+    "output",
+    "host",
+    "apikey",
+    "file",
+    "json",
+    "cascade",
+    "strict",
+    "from",
+    "to",
+    "help",
+    "version",
+]);
+const fields = {};
+function shouldExtract(argv) {
+    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) {
+    if (!shouldExtract(argv))
+        return argv;
+    const out = [];
+    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() {
+    const copy = { ...fields };
+    for (const k of Object.keys(fields))
+        delete fields[k];
+    return copy;
+}

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

@@ -1,33 +1,35 @@
 import fs from "fs";
-import { rollup } from "rollup";
+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", "");
 }
-export async function getFunctionFromFilePath(filePath, kind, profileBuilders = []) {
+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.statSync(filePath).isFile()) {
         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",
+    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);
-    assertDefined(exports.default, `Function from ${filePath} doesn't have default export. Exported symbols: ${Object.keys(exports)}`);
-    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.`);
@@ -39,12 +41,12 @@ export 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/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()];
+}