windmill-cli 1.518.1 → 1.518.3

package/esm/src/types.js

@@ -0,0 +1,223 @@
+// deno-lint-ignore-file no-explicit-any
+import * as dntShim from "../_dnt.shims.js";
+import { Diff, SEP, colors, log, path, yamlParseContent, yamlStringify, } from "../deps.js";
+import { pushApp } from "./commands/app/apps.js";
+import { pushFolder } from "./commands/folder/folder.js";
+import { pushFlow } from "./commands/flow/flow.js";
+import { pushResource } from "./commands/resource/resource.js";
+import { pushResourceType } from "./commands/resource-type/resource-type.js";
+import { pushVariable } from "./commands/variable/variable.js";
+import { yamlOptions } from "./commands/sync/sync.js";
+import { showDiffs } from "./core/conf.js";
+import { deepEqual, isFileResource } from "./utils/utils.js";
+import { pushSchedule } from "./commands/schedule/schedule.js";
+import { pushWorkspaceUser } from "./commands/user/user.js";
+import { pushGroup } from "./commands/user/user.js";
+import { pushWorkspaceSettings, pushWorkspaceKey } from "./core/settings.js";
+import { pushTrigger } from "./commands/trigger/trigger.js";
+export function isSuperset(subset, superset) {
+    return Object.keys(subset).every((key) => {
+        const eq = deepEqual(subset[key], superset[key]);
+        if (!eq && showDiffs) {
+            const sub = subset[key];
+            const supers = superset[key];
+            if (!supers) {
+                log.info(`Key ${key} not found in remote`);
+            }
+            else {
+                log.info(`Found diff for ${key}:`);
+                showDiff(yamlStringify(sub, yamlOptions), yamlStringify(supers, yamlOptions));
+            }
+        }
+        return eq;
+    });
+}
+export function showDiff(local, remote) {
+    let finalString = "";
+    if (local?.length > 20000 || remote?.length > 20000) {
+        log.info("Diff too large to display");
+        return;
+    }
+    for (const part of Diff.diffLines(local ?? "", remote ?? "")) {
+        if (part.removed) {
+            // print red if removed without newline
+            finalString += `\x1b[31m${part.value}\x1b[0m`;
+        }
+        else if (part.added) {
+            // print green if added
+            finalString += `\x1b[32m${part.value}\x1b[0m`;
+        }
+        else {
+            let lines = part.value.split("\n");
+            if (lines.length > 4) {
+                lines = lines.slice(0, 2);
+                lines.push("...");
+                lines = lines.concat(part.value.split("\n").slice(-2));
+            }
+            // print white if unchanged
+            finalString += `\x1b[37m${lines.join("\n")}\x1b[0m`;
+        }
+    }
+    log.info(finalString);
+}
+export function showConflict(path, local, remote) {
+    log.info(colors.yellow(`- ${path}`));
+    showDiff(local, remote);
+    log.info("\x1b[31mlocal\x1b[31m - \x1b[32mremote\x1b[32m");
+    log.info("\n");
+}
+export async function pushObj(workspace, p, befObj, newObj, plainSecrets, alreadySynced, message) {
+    const typeEnding = getTypeStrFromPath(p);
+    if (typeEnding === "app") {
+        const appName = p.split(".app" + SEP)[0];
+        await pushApp(workspace, appName, appName + ".app", message);
+    }
+    else if (typeEnding === "folder") {
+        await pushFolder(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "variable") {
+        await pushVariable(workspace, p, befObj, newObj, plainSecrets);
+    }
+    else if (typeEnding === "flow") {
+        const flowName = p.split(".flow" + SEP)[0];
+        await pushFlow(workspace, flowName, flowName + ".flow", message);
+    }
+    else if (typeEnding === "resource") {
+        if (!alreadySynced.includes(p)) {
+            alreadySynced.push(p);
+            await pushResource(workspace, p, befObj, newObj);
+        }
+    }
+    else if (typeEnding === "resource-type") {
+        await pushResourceType(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "schedule") {
+        await pushSchedule(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "http_trigger") {
+        await pushTrigger("http", workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "websocket_trigger") {
+        await pushTrigger("websocket", workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "kafka_trigger") {
+        await pushTrigger("kafka", workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "nats_trigger") {
+        await pushTrigger("nats", workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "postgres_trigger") {
+        await pushTrigger("postgres", workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "mqtt_trigger") {
+        await pushTrigger("mqtt", workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "sqs_trigger") {
+        await pushTrigger("sqs", workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "gcp_trigger") {
+        await pushTrigger("gcp", workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "user") {
+        await pushWorkspaceUser(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "group") {
+        await pushGroup(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "settings") {
+        await pushWorkspaceSettings(workspace, p, befObj, newObj);
+    }
+    else if (typeEnding === "encryption_key") {
+        await pushWorkspaceKey(workspace, p, befObj, newObj);
+    }
+    else {
+        throw new Error(`The item ${p} has an unrecognized type ending ${typeEnding}`);
+    }
+}
+export function parseFromPath(p, content) {
+    return p.endsWith(".yaml")
+        ? yamlParseContent(p, content)
+        : p.endsWith(".json")
+            ? JSON.parse(content)
+            : content;
+}
+export function parseFromFile(p) {
+    if (p.endsWith(".json")) {
+        return JSON.parse(dntShim.Deno.readTextFileSync(p));
+    }
+    else if (p.endsWith(".yaml") || p.endsWith(".yml")) {
+        return yamlParseContent(p, dntShim.Deno.readTextFileSync(p));
+    }
+    else {
+        throw new Error("Could not read file " + p);
+    }
+}
+export function getTypeStrFromPath(p) {
+    if (p.includes(".flow" + SEP)) {
+        return "flow";
+    }
+    if (p.includes(".app" + SEP)) {
+        return "app";
+    }
+    const parsed = path.parse(p);
+    if (parsed.ext == ".go" ||
+        parsed.ext == ".ts" ||
+        parsed.ext == ".sh" ||
+        parsed.ext == ".py" ||
+        parsed.ext == ".sql" ||
+        parsed.ext == ".gql" ||
+        parsed.ext == ".ps1" ||
+        parsed.ext == ".js" ||
+        parsed.ext == ".php" ||
+        parsed.ext == ".rs" ||
+        parsed.ext == ".cs" ||
+        parsed.ext == ".nu" ||
+        parsed.ext == ".java" ||
+        // for related places search: ADD_NEW_LANG
+        (parsed.ext == ".yml" && parsed.name.split(".").pop() == "playbook")) {
+        return "script";
+    }
+    if (parsed.name === "folder.meta") {
+        return "folder";
+    }
+    const typeEnding = parsed.name.split(".").at(-1);
+    if (typeEnding === "script" ||
+        typeEnding === "variable" ||
+        typeEnding === "resource" ||
+        typeEnding === "resource-type" ||
+        typeEnding === "app" ||
+        typeEnding === "schedule" ||
+        typeEnding === "http_trigger" ||
+        typeEnding === "websocket_trigger" ||
+        typeEnding === "kafka_trigger" ||
+        typeEnding === "nats_trigger" ||
+        typeEnding === "postgres_trigger" ||
+        typeEnding === "mqtt_trigger" ||
+        typeEnding === "sqs_trigger" ||
+        typeEnding === "gcp_trigger" ||
+        typeEnding === "user" ||
+        typeEnding === "group" ||
+        typeEnding === "settings" ||
+        typeEnding === "encryption_key") {
+        return typeEnding;
+    }
+    else {
+        if (isFileResource(p)) {
+            return "resource";
+        }
+        throw new Error("Could not infer type of path " + JSON.stringify(parsed));
+    }
+}
+export function removeType(str, type) {
+    if (!str.endsWith("." + type + ".yaml") &&
+        !str.endsWith("." + type + ".json")) {
+        throw new Error(str + " does not end with ." + type + ".(yaml|json)");
+    }
+    return str.slice(0, str.length - type.length - 6);
+}
+export function removePathPrefix(str, prefix) {
+    if (!str.startsWith(prefix + "/")) {
+        throw new Error(str + " does not start with " + prefix);
+    }
+    return str.slice(prefix.length + 1);
+}

package/esm/src/utils/codebase.js

@@ -0,0 +1,24 @@
+import { log } from "../../deps.js";
+import { digestDir } from "./utils.js";
+export function listSyncCodebases(options) {
+    const res = [];
+    const nb_codebase = options?.codebases?.length ?? 0;
+    if (nb_codebase > 0) {
+        log.info(`Found ${nb_codebase} codebases: ${options?.codebases?.map((c) => c.relative_path).join(", ")}`);
+    }
+    for (const codebase of options?.codebases ?? []) {
+        let _digest = undefined;
+        const getDigest = async () => {
+            if (_digest == undefined) {
+                _digest = await digestDir(codebase.relative_path, JSON.stringify(codebase));
+                if (Array.isArray(codebase.assets) && codebase.assets.length > 0) {
+                    _digest += ".tar";
+                }
+                log.info(`Codebase ${codebase.relative_path}, digest: ${_digest}`);
+            }
+            return _digest;
+        };
+        res.push({ ...codebase, getDigest });
+    }
+    return res;
+}

package/esm/src/utils/git.js

@@ -0,0 +1,29 @@
+import { log } from "../../deps.js";
+import { execSync } from "node:child_process";
+export function getCurrentGitBranch() {
+    try {
+        const result = execSync("git rev-parse --abbrev-ref HEAD", {
+            encoding: "utf8",
+            stdio: "pipe"
+        });
+        const branch = result.trim();
+        return branch || null;
+    }
+    catch (error) {
+        log.debug(`Failed to get Git branch: ${error}`);
+        return null;
+    }
+}
+export function isGitRepository() {
+    try {
+        execSync("git rev-parse --git-dir", {
+            encoding: "utf8",
+            stdio: "pipe"
+        });
+        return true;
+    }
+    catch (error) {
+        log.debug(`Failed to check Git repository: ${error}`);
+        return false;
+    }
+}