jitsu-cli 1.10.4 → 1.11.0

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

@@ -0,0 +1,148 @@
+import { Command } from "commander";
+import { red } from "../../lib/chalk-code-highlight";
+import { DEFAULT_OUTPUT, SUPPORTED_OUTPUTS } from "../../lib/renderer";
+import { resources, verbsFor } from "./resources";
+import { runCreate, runDelete, runGet, runList, runTest, runUpdate } from "./handlers";
+function withCommonOpts(cmd) {
+    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) {
+    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"));
+}
+function action(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(red(`Error: ${msg}`));
+            process.exit(1);
+        }
+    };
+}
+function buildLeaf(resource, verb) {
+    switch (verb) {
+        case "list": {
+            const cmd = withCommonOpts(new Command("list"))
+                .description(`List ${resource.noun}`)
+                .action(action(async (opts) => 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, opts) => runGet(resource, id, opts)));
+            return cmd;
+        }
+        case "create": {
+            const cmd = withBodyOpts(withCommonOpts(new Command("create")))
+                .description(`Create a ${singular(resource)}`)
+                .action(action(async (opts) => 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, opts) => 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, opts) => 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) => runTest(resource, opts)));
+            return cmd;
+        }
+    }
+}
+function singular(r) {
+    return r.aliases[0] ?? r.noun.replace(/s$/, "");
+}
+export function buildConfigCommand() {
+    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"));
+    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);
+    }
+    const allVerbs = ["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);
+            leaf.name(resource.noun);
+            for (const alias of resource.aliases)
+                leaf.alias(alias);
+            verbCmd.addCommand(leaf);
+        }
+        config.addCommand(verbCmd);
+    }
+    return config;
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}

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

@@ -1,68 +1,80 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deploy = deploy;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-const os_1 = require("os");
-const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
-const fs_1 = require("fs");
-const shared_1 = require("./shared");
-const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
-const cuid_1 = tslib_1.__importDefault(require("cuid"));
-const chalk_code_highlight_1 = require("../lib/chalk-code-highlight");
-const compiled_function_1 = require("../lib/compiled-function");
+import path from "path";
+import { homedir } from "os";
+import inquirer from "inquirer";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { loadPackageJson } from "./shared";
+import cuid from "cuid";
+import { b, green, red } from "../lib/chalk-code-highlight";
+import { getFunctionFromFilePath } from "../lib/compiled-function";
+import { loadProjectConfig } from "../lib/project-config";
+import { readDefaultWorkspace } from "../lib/auth-file";
 function readLoginFile() {
-    const configFile = `${(0, os_1.homedir)()}/.jitsu/jitsu-cli.json`;
-    if (!(0, fs_1.existsSync)(configFile)) {
-        console.error((0, chalk_code_highlight_1.red)("Please login first with `jitsu-cli login` command or provide --apikey option"));
+    const configFile = `${homedir()}/.jitsu/jitsu-cli.json`;
+    if (!existsSync(configFile)) {
+        console.error(red("Please login first with `jitsu-cli login` command or provide --apikey option"));
         process.exit(1);
     }
-    return JSON.parse((0, fs_1.readFileSync)(configFile, { encoding: "utf-8" }));
+    return JSON.parse(readFileSync(configFile, { encoding: "utf-8" }));
 }
-async function deploy({ dir, workspace, name: names, ...params }) {
-    const { packageJson, projectDir } = await (0, shared_1.loadPackageJson)(dir || process.cwd());
+export async function deploy({ dir, workspace, name: names, ...params }) {
+    const { packageJson, projectDir } = await loadPackageJson(dir || process.cwd());
     const { host, apikey } = params.apikey
         ? { apikey: params.apikey, host: params.host || "https://use.jitsu.com" }
         : readLoginFile();
-    console.log(`Deploying ${(0, chalk_code_highlight_1.b)(packageJson.name)} project.${names && names.length > 0 ? ` (selected functions: ${names.join(",")})` : ""}`);
-    const res = await (0, node_fetch_1.default)(`${host}/api/workspace`, {
+    console.log(`Deploying ${b(packageJson.name)} project.${names && names.length > 0 ? ` (selected functions: ${names.join(",")})` : ""}`);
+    const res = await fetch(`${host}/api/workspace`, {
         method: "GET",
         headers: {
             Authorization: `Bearer ${apikey}`,
         },
     });
     if (!res.ok) {
-        console.error((0, chalk_code_highlight_1.red)(`Cannot get workspace list:\n${(0, chalk_code_highlight_1.b)(await res.text())}`));
+        console.error(red(`Cannot get workspace list:\n${b(await res.text())}`));
         process.exit(1);
     }
     const workspaces = (await res.json());
-    let workspaceId = workspace;
-    if (!workspace) {
-        if (workspaces.length === 0) {
-            console.error(`${(0, chalk_code_highlight_1.red)("No workspaces found")}`);
+    const findWorkspace = (ref) => (ref ? workspaces.find(w => w.id === ref || w.slug === ref) : undefined);
+    const projectConfig = loadProjectConfig(projectDir, packageJson);
+    let workspaceObj;
+    if (workspace) {
+        workspaceObj = findWorkspace(workspace);
+        if (!workspaceObj) {
+            console.error(red(`Workspace '${b(workspace)}' not found (or you don't have access)`));
             process.exit(1);
         }
-        else if (workspaces.length === 1) {
-            workspaceId = workspaces[0].id;
-        }
-        else {
-            workspaceId = (await inquirer_1.default.prompt([
-                {
-                    type: "list",
-                    name: "workspaceId",
-                    message: `Select workspace:`,
-                    choices: workspaces.map(w => ({
-                        name: `${w.name} (${w.id})`,
-                        value: w.id,
-                    })),
-                },
-            ])).workspaceId;
+    }
+    else {
+        const softRef = projectConfig.workspace ?? readDefaultWorkspace();
+        workspaceObj = findWorkspace(softRef);
+        if (!workspaceObj) {
+            if (softRef) {
+                console.warn(`Configured workspace ${b(softRef)} not found or not accessible. Selecting manually.`);
+            }
+            if (workspaces.length === 0) {
+                console.error(`${red("No workspaces found")}`);
+                process.exit(1);
+            }
+            else if (workspaces.length === 1) {
+                workspaceObj = workspaces[0];
+            }
+            else {
+                const workspaceId = (await inquirer.prompt([
+                    {
+                        type: "list",
+                        name: "workspaceId",
+                        message: `Select workspace:`,
+                        choices: workspaces.map(w => ({
+                            name: `${w.name} (${w.id})`,
+                            value: w.id,
+                        })),
+                    },
+                ])).workspaceId;
+                workspaceObj = findWorkspace(workspaceId);
+            }
         }
     }
-    const workspaceObj = workspaces.find(w => w.id === workspaceId);
-    const workspaceName = workspaceObj?.name;
-    if (!workspaceId || !workspaceName) {
-        console.error((0, chalk_code_highlight_1.red)(`Workspace with id ${workspaceId} not found`));
+    if (!workspaceObj?.id || !workspaceObj?.name) {
+        console.error(red(`Workspace not found`));
         process.exit(1);
     }
     await deployFunctions({ ...params, host, apikey, name: names }, projectDir, packageJson, workspaceObj, "function");
@@ -71,11 +83,15 @@ async function deploy({ dir, workspace, name: names, ...params }) {
 async function deployFunctions({ host, apikey, name: names }, projectDir, packageJson, workspace, kind) {
     const selected = names ? names.flatMap(n => n.split(",")).map(n => n.trim()) : undefined;
     const dir = `dist/${kind}s`;
-    const functionsDir = path_1.default.resolve(projectDir, dir);
-    const functionsFiles = (0, fs_1.readdirSync)(functionsDir);
+    const functionsDir = path.resolve(projectDir, dir);
+    if (!existsSync(functionsDir)) {
+        console.warn(`No ${b(dir)} directory found, skipping ${kind}s. Please make sure that you have built the project.`);
+        return;
+    }
+    const functionsFiles = readdirSync(functionsDir);
     if (functionsFiles.length === 0) {
-        console.warn((0, chalk_code_highlight_1.red)(`Can't find function files in ${(0, chalk_code_highlight_1.b)(dir)} directory. Please make sure that you have built the project.`));
-        process.exit(1);
+        console.warn(`No ${kind} files found in ${b(dir)}, skipping. Please make sure that you have built the project.`);
+        return;
     }
     const selectedFiles = [];
     if (selected) {
@@ -85,7 +101,7 @@ async function deployFunctions({ host, apikey, name: names }, projectDir, packag
                 selectedFiles.push(file);
             }
             else {
-                console.error((0, chalk_code_highlight_1.red)(`Can't find function file ${(0, chalk_code_highlight_1.b)(file)} in ${(0, chalk_code_highlight_1.b)(dir)} directory. Please make sure that you have built the project.`));
+                console.error(red(`Can't find function file ${b(file)} in ${b(dir)} directory. Please make sure that you have built the project.`));
                 process.exit(1);
             }
         }
@@ -95,49 +111,80 @@ async function deployFunctions({ host, apikey, name: names }, projectDir, packag
     }
     let profileBuilders = [];
     if (kind == "profile") {
-        const res = await (0, node_fetch_1.default)(`${host}/api/${workspace.id}/config/profile-builder`, {
+        const res = await fetch(`${host}/api/${workspace.id}/config/profile-builder`, {
             method: "GET",
             headers: {
                 Authorization: `Bearer ${apikey}`,
             },
         });
         if (!res.ok) {
-            console.error((0, chalk_code_highlight_1.red)(`Cannot get profile builders list:\n${(0, chalk_code_highlight_1.b)(await res.text())}`));
+            console.error(red(`Cannot get profile builders list:\n${b(await res.text())}`));
             process.exit(1);
         }
         profileBuilders = (await res.json()).profileBuilders;
     }
+    const existingFunctions = await fetchExistingFunctions({ host, apikey, workspaceId: workspace.id });
     for (const file of selectedFiles) {
-        console.log(`${(0, chalk_code_highlight_1.b)(`𝑓`)} Deploying function ${(0, chalk_code_highlight_1.b)(path_1.default.basename(file))} to workspace ${workspace.name} (${host}/${workspace.slug || workspace.id})`);
-        await deployFunction({ host, apikey }, packageJson, workspace, kind, path_1.default.resolve(functionsDir, file), profileBuilders);
+        console.log(`${b(`𝑓`)} Deploying function ${b(path.basename(file))} to workspace ${workspace.name} (${host}/${workspace.slug || workspace.id})`);
+        await deployFunction(projectDir, { host, apikey }, packageJson, workspace, kind, path.resolve(functionsDir, file), profileBuilders, existingFunctions);
+    }
+}
+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 };
 }
-async function deployFunction({ host, apikey }, packageJson, workspace, kind, file, profileBuilders = []) {
-    const code = (0, fs_1.readFileSync)(file, "utf-8");
-    const wrapped = await (0, compiled_function_1.getFunctionFromFilePath)(file, kind, profileBuilders);
+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(projectDir, file, kind, profileBuilders);
     const meta = wrapped.meta;
     if (meta) {
         console.log(`  meta: slug=${meta.slug}, name=${meta.name || "not set"}`);
     }
     else {
-        console.log(`File ${(0, chalk_code_highlight_1.b)(path_1.default.basename(file))} doesn't have function meta information. ${(0, chalk_code_highlight_1.red)("Skipping")}`);
+        console.log(`File ${b(path.basename(file))} doesn't have function meta information. ${red("Skipping")}`);
         return;
     }
     let existingFunctionId;
     if (meta.slug) {
-        const res = await (0, node_fetch_1.default)(`${host}/api/${workspace.id}/config/function`, {
-            headers: {
-                Authorization: `Bearer ${apikey}`,
-            },
-        });
-        if (!res.ok) {
-            console.error((0, chalk_code_highlight_1.red)(`Cannot add function to workspace:\n${(0, chalk_code_highlight_1.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") {
@@ -152,8 +199,8 @@ async function deployFunction({ host, apikey }, packageJson, workspace, kind, fi
         };
     }
     if (!existingFunctionId) {
-        const id = (0, cuid_1.default)();
-        const res = await (0, node_fetch_1.default)(`${host}/api/${workspace.id}/config/function`, {
+        const id = cuid();
+        const res = await fetch(`${host}/api/${workspace.id}/config/function`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${apikey}`,
@@ -172,16 +219,17 @@ async function deployFunction({ host, apikey }, packageJson, workspace, kind, fi
             }),
         });
         if (!res.ok) {
-            console.error((0, chalk_code_highlight_1.red)(`Cannot add function to workspace:\n${(0, chalk_code_highlight_1.b)(await res.text())}`));
+            console.error(red(`Cannot add function to workspace:\n${b(await res.text())}`));
             process.exit(1);
         }
         else {
-            console.log(`Function ${(0, chalk_code_highlight_1.b)(meta.name)} was successfully added to workspace ${workspace.name} with id: ${(0, chalk_code_highlight_1.b)(id)}`);
+            cacheAfterCreate(existingFunctions, id, meta.slug);
+            console.log(`Function ${b(meta.name)} was successfully added to workspace ${workspace.name} with id: ${b(id)}`);
         }
     }
     else {
         const id = existingFunctionId;
-        const res = await (0, node_fetch_1.default)(`${host}/api/${workspace.id}/config/function/${id}`, {
+        const res = await fetch(`${host}/api/${workspace.id}/config/function/${id}`, {
             method: "PUT",
             headers: {
                 Authorization: `Bearer ${apikey}`,
@@ -199,11 +247,12 @@ async function deployFunction({ host, apikey }, packageJson, workspace, kind, fi
             }),
         });
         if (!res.ok) {
-            console.error((0, chalk_code_highlight_1.red)(`⚠ Cannot deploy function ${(0, chalk_code_highlight_1.b)(meta.slug)}(${id}):\n${(0, chalk_code_highlight_1.b)(await res.text())}`));
+            console.error(red(`⚠ Cannot deploy function ${b(meta.slug)}(${id}):\n${b(await res.text())}`));
             process.exit(1);
         }
         else {
-            console.log(`${(0, chalk_code_highlight_1.green)(`✓`)} ${(0, chalk_code_highlight_1.b)(meta.name)} deployed successfully!`);
+            cacheAfterUpdate(existingFunctions, id, meta.slug);
+            console.log(`${green(`✓`)} ${b(meta.name)} deployed successfully!`);
         }
     }
 }

package/compiled/src/commands/init.js

@@ -1,46 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = init;
-const tslib_1 = require("tslib");
-const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const chalk_code_highlight_1 = require("../lib/chalk-code-highlight");
-const fs = tslib_1.__importStar(require("fs"));
-const functions_1 = require("../templates/functions");
-const template_1 = require("../lib/template");
-const version_1 = require("../lib/version");
-async function init(dir, opts) {
+import inquirer from "inquirer";
+import path from "path";
+import { b } from "../lib/chalk-code-highlight";
+import * as fs from "fs";
+import { functionProjectTemplate } from "../templates/functions";
+import { write } from "../lib/template";
+import { jitsuCliVersion } from "../lib/version";
+export async function init(dir, opts) {
     let projectName;
     if (dir) {
-        dir = path_1.default.resolve(dir);
+        dir = path.resolve(dir);
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir);
         }
         else if (fs.readdirSync(dir).length > 0) {
-            const msg = `Directory ${(0, chalk_code_highlight_1.b)(dir)} is not empty, can't create project there`;
+            const msg = `Directory ${b(dir)} is not empty, can't create project there`;
             if (opts?.allowNonEmptyDir) {
-                console.warn(`Directory ${(0, chalk_code_highlight_1.b)(dir)} is not empty. Will create project there, files may be overwritten`);
+                console.warn(`Directory ${b(dir)} is not empty. Will create project there, files may be overwritten`);
             }
             else {
                 console.error(msg);
                 process.exit(1);
             }
         }
-        projectName = path_1.default.basename(dir);
+        projectName = path.basename(dir);
     }
     else {
-        projectName = (await inquirer_1.default.prompt([
+        projectName = (await inquirer.prompt([
             {
                 type: "input",
                 name: "project",
                 message: `Enter project name. It will be used as a package name and directory name:`,
             },
         ])).project;
-        dir = path_1.default.resolve(projectName);
+        dir = path.resolve(projectName);
     }
-    (0, template_1.write)(dir, functions_1.functionProjectTemplate, {
+    write(dir, functionProjectTemplate, {
         packageName: projectName,
-        jitsuVersion: opts?.jitsuVersion || version_1.jitsuCliVersion,
+        jitsuVersion: opts?.jitsuVersion || jitsuCliVersion,
     });
-    console.log(`Project ${(0, chalk_code_highlight_1.b)(projectName)} created!`);
+    console.log(`Project ${b(projectName)} created!`);
 }