windmill-cli 1.518.1 → 1.518.3

package/esm/trigger.js

@@ -1,182 +0,0 @@
-import * as dntShim from "./_dnt.shims.js";
-import * as wmill from "./gen/services.gen.js";
-import { colors, Command, log, SEP, Table } from "./deps.js";
-import { isSuperset, parseFromFile, removeType, } from "./types.js";
-import { requireLogin } from "./auth.js";
-import { validatePath, resolveWorkspace } from "./context.js";
-async function getTrigger(triggerType, workspace, path) {
-    const triggerFunctions = {
-        http: wmill.getHttpTrigger,
-        websocket: wmill.getWebsocketTrigger,
-        kafka: wmill.getKafkaTrigger,
-        nats: wmill.getNatsTrigger,
-        postgres: wmill.getPostgresTrigger,
-        mqtt: wmill.getMqttTrigger,
-        sqs: wmill.getSqsTrigger,
-        gcp: wmill.getGcpTrigger,
-    };
-    const triggerFunction = triggerFunctions[triggerType];
-    const trigger = await triggerFunction({ workspace, path });
-    return trigger;
-}
-async function updateTrigger(triggerType, workspace, path, trigger) {
-    const triggerFunctions = {
-        http: wmill.updateHttpTrigger,
-        websocket: wmill.updateWebsocketTrigger,
-        kafka: wmill.updateKafkaTrigger,
-        nats: wmill.updateNatsTrigger,
-        postgres: wmill.updatePostgresTrigger,
-        mqtt: wmill.updateMqttTrigger,
-        sqs: wmill.updateSqsTrigger,
-        gcp: async (args) => {
-            throw new Error("GCP triggers are not supported yet");
-        },
-    };
-    const triggerFunction = triggerFunctions[triggerType];
-    await triggerFunction({ workspace, path, requestBody: trigger });
-}
-async function createTrigger(triggerType, workspace, path, trigger) {
-    const triggerFunctions = {
-        http: wmill.createHttpTrigger,
-        websocket: wmill.createWebsocketTrigger,
-        kafka: wmill.createKafkaTrigger,
-        nats: wmill.createNatsTrigger,
-        postgres: wmill.createPostgresTrigger,
-        mqtt: wmill.createMqttTrigger,
-        sqs: wmill.createSqsTrigger,
-        gcp: async (args) => {
-            throw new Error("GCP triggers are not supported yet");
-        },
-    };
-    const triggerFunction = triggerFunctions[triggerType];
-    await triggerFunction({ workspace, path, requestBody: trigger });
-}
-export async function pushTrigger(triggerType, workspace, path, trigger, localTrigger) {
-    path = removeType(path, triggerType + "_trigger").replaceAll(SEP, "/");
-    log.debug(`Processing local ${triggerType} trigger ${path}`);
-    try {
-        trigger = await getTrigger(triggerType, workspace, path);
-        log.debug(`${triggerType} trigger ${path} exists on remote`);
-    }
-    catch {
-        log.debug(`${triggerType} trigger ${path} does not exist on remote`);
-        //ignore
-    }
-    if (trigger) {
-        if (isSuperset(localTrigger, trigger)) {
-            log.debug(`${triggerType} trigger ${path} is up to date`);
-            return;
-        }
-        log.debug(`${triggerType} trigger ${path} is not up-to-date, updating...`);
-        try {
-            await updateTrigger(triggerType, workspace, path, {
-                ...localTrigger,
-                path,
-            });
-        }
-        catch (e) {
-            console.error(e.body);
-            throw e;
-        }
-    }
-    else {
-        console.log(colors.bold.yellow(`Creating new ${triggerType} trigger: ${path}`));
-        try {
-            await createTrigger(triggerType, workspace, path, {
-                ...localTrigger,
-                path,
-            });
-        }
-        catch (e) {
-            console.error(e.body);
-            throw e;
-        }
-    }
-}
-async function list(opts) {
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    const httpTriggers = await wmill.listHttpTriggers({
-        workspace: workspace.workspaceId,
-    });
-    const websocketTriggers = await wmill.listWebsocketTriggers({
-        workspace: workspace.workspaceId,
-    });
-    const kafkaTriggers = await wmill.listKafkaTriggers({
-        workspace: workspace.workspaceId,
-    });
-    const natsTriggers = await wmill.listNatsTriggers({
-        workspace: workspace.workspaceId,
-    });
-    const postgresTriggers = await wmill.listPostgresTriggers({
-        workspace: workspace.workspaceId,
-    });
-    const mqttTriggers = await wmill.listMqttTriggers({
-        workspace: workspace.workspaceId,
-    });
-    const sqsTriggers = await wmill.listSqsTriggers({
-        workspace: workspace.workspaceId,
-    });
-    const gcpTriggers = await wmill.listGcpTriggers({
-        workspace: workspace.workspaceId,
-    });
-    const triggers = [
-        ...httpTriggers.map((x) => ({ path: x.path, kind: "http" })),
-        ...websocketTriggers.map((x) => ({ path: x.path, kind: "websocket" })),
-        ...kafkaTriggers.map((x) => ({ path: x.path, kind: "kafka" })),
-        ...natsTriggers.map((x) => ({ path: x.path, kind: "nats" })),
-        ...postgresTriggers.map((x) => ({ path: x.path, kind: "postgres" })),
-        ...mqttTriggers.map((x) => ({ path: x.path, kind: "mqtt" })),
-        ...sqsTriggers.map((x) => ({ path: x.path, kind: "sqs" })),
-        ...gcpTriggers.map((x) => ({ path: x.path, kind: "gcp" })),
-    ];
-    new Table()
-        .header(["Path", "Kind"])
-        .padding(2)
-        .border(true)
-        .body(triggers.map((x) => [x.path, x.kind]))
-        .render();
-}
-function checkIfValidTrigger(kind) {
-    if (kind &&
-        [
-            "http",
-            "websocket",
-            "kafka",
-            "nats",
-            "postgres",
-            "mqtt",
-            "sqs",
-            "gcp",
-        ].includes(kind)) {
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-async function push(opts, filePath, remotePath) {
-    const workspace = await resolveWorkspace(opts);
-    await requireLogin(opts);
-    if (!validatePath(remotePath)) {
-        return;
-    }
-    const fstat = await dntShim.Deno.stat(filePath);
-    if (!fstat.isFile) {
-        throw new Error("file path must refer to a file.");
-    }
-    console.log(colors.bold.yellow("Pushing trigger..."));
-    const triggerKind = filePath.split(".")[1].split("_")[0];
-    if (!checkIfValidTrigger(triggerKind)) {
-        throw new Error("Invalid trigger kind: " + triggerKind);
-    }
-    await pushTrigger(triggerKind, workspace.workspaceId, remotePath, undefined, parseFromFile(filePath));
-    console.log(colors.bold.underline.green("Trigger pushed"));
-}
-const command = new Command()
-    .description("trigger related commands")
-    .action(list)
-    .command("push", "push a local trigger spec. This overrides any remote versions.")
-    .arguments("<file_path:string> <remote_path:string>")
-    .action(push);
-export default command;

package/esm/types.js

@@ -1,223 +0,0 @@
-// 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 "./apps.js";
-import { pushFolder } from "./folder.js";
-import { pushFlow } from "./flow.js";
-import { pushResource } from "./resource.js";
-import { pushResourceType } from "./resource-type.js";
-import { pushVariable } from "./variable.js";
-import { yamlOptions } from "./sync.js";
-import { showDiffs } from "./main.js";
-import { deepEqual, isFileResource } from "./utils.js";
-import { pushSchedule } from "./schedule.js";
-import { pushWorkspaceUser } from "./user.js";
-import { pushGroup } from "./user.js";
-import { pushWorkspaceSettings, pushWorkspaceKey } from "./settings.js";
-import { pushTrigger } from "./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/upgrade.js

@@ -1,48 +0,0 @@
-import { Provider } from "./deps.js";
-export class NpmProvider extends Provider {
-    constructor({ main, logger, ...options }) {
-        super({ main, logger });
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "npm"
-        });
-        Object.defineProperty(this, "repositoryUrl", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "https://npmjs.org/"
-        });
-        Object.defineProperty(this, "apiUrl", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "https://registry.npmjs.org/"
-        });
-        Object.defineProperty(this, "packageName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.packageName = "package" in options ? options.package : options.name;
-    }
-    async getVersions(name) {
-        const response = await fetch(new URL(`${this.packageName ?? name}`, this.apiUrl));
-        if (!response.ok) {
-            throw new Error("couldn't fetch the latest version - try again after sometime");
-        }
-        const { "dist-tags": { latest }, versions, } = (await response.json());
-        return {
-            latest,
-            versions: Object.keys(versions).reverse(),
-        };
-    }
-    getRepositoryUrl(name, version) {
-        return new URL(`package/${this.packageName ?? name}${version ? `/v/${version}` : ""}`, this.repositoryUrl).href;
-    }
-    getRegistryUrl(name, version) {
-        return `npm:${this.packageName ?? name}@${version}`;
-    }
-}