windmill-cli 1.641.0 → 1.643.0

package/esm/src/commands/trigger/trigger.js

@@ -1,269 +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, TRIGGER_TYPES, extractNativeTriggerInfo, } from "../../types.js";
-import { fromBranchSpecificPath, isBranchSpecificFile, } from "../../core/specific_items.js";
-import { getCurrentGitBranch } from "../../utils/git.js";
-import { requireLogin } from "../../core/auth.js";
-import { validatePath, resolveWorkspace } from "../../core/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,
-        email: wmill.getEmailTrigger,
-    };
-    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: wmill.updateGcpTrigger,
-        email: wmill.updateEmailTrigger,
-    };
-    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: wmill.createGcpTrigger,
-        email: wmill.createEmailTrigger,
-    };
-    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;
-        }
-    }
-}
-export async function pushNativeTrigger(workspace, filePath, _remoteTrigger, localTrigger) {
-    const triggerInfo = extractNativeTriggerInfo(filePath);
-    if (!triggerInfo) {
-        throw new Error(`Invalid native trigger file path: ${filePath}. Expected format: {script_path}.{flow|script}.{external_id}.{service}_native_trigger.json`);
-    }
-    const { externalId, serviceName } = triggerInfo;
-    log.debug(`Processing local native trigger: service=${serviceName}, external_id=${externalId}`);
-    let remoteTrigger;
-    try {
-        const result = await wmill.getNativeTrigger({
-            workspace,
-            serviceName: serviceName,
-            externalId,
-        });
-        // getNativeTrigger returns NativeTriggerWithExternal, extract NativeTrigger fields
-        remoteTrigger = {
-            external_id: result.external_id,
-            workspace_id: result.workspace_id,
-            service_name: result.service_name,
-            script_path: result.script_path,
-            is_flow: result.is_flow,
-            service_config: result.service_config,
-            error: result.error,
-        };
-        log.debug(`Native trigger ${serviceName}/${externalId} exists on remote`);
-    }
-    catch {
-        log.debug(`Native trigger ${serviceName}/${externalId} does not exist on remote`);
-    }
-    const triggerData = {
-        script_path: localTrigger.script_path,
-        is_flow: localTrigger.is_flow,
-        service_config: localTrigger.service_config,
-    };
-    if (remoteTrigger) {
-        // Compare relevant fields
-        const localCompare = {
-            script_path: localTrigger.script_path,
-            is_flow: localTrigger.is_flow,
-            service_config: localTrigger.service_config,
-        };
-        const remoteCompare = {
-            script_path: remoteTrigger.script_path,
-            is_flow: remoteTrigger.is_flow,
-            service_config: remoteTrigger.service_config,
-        };
-        if (isSuperset(localCompare, remoteCompare)) {
-            log.debug(`Native trigger ${serviceName}/${externalId} is up to date`);
-            return;
-        }
-        log.debug(`Native trigger ${serviceName}/${externalId} is not up-to-date, updating...`);
-        try {
-            await wmill.updateNativeTrigger({
-                workspace,
-                serviceName: serviceName,
-                externalId,
-                requestBody: triggerData,
-            });
-        }
-        catch (e) {
-            console.error(e.body);
-            throw e;
-        }
-    }
-    else {
-        console.log(colors.bold.yellow(`Creating new native trigger: ${serviceName}/${externalId}`));
-        try {
-            await wmill.createNativeTrigger({
-                workspace,
-                serviceName: serviceName,
-                requestBody: triggerData,
-            });
-        }
-        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 emailTriggers = await wmill.listEmailTriggers({
-        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" })),
-        ...emailTriggers.map((x) => ({ path: x.path, kind: "email" })),
-    ];
-    new Table()
-        .header(["Path", "Kind"])
-        .padding(2)
-        .border(true)
-        .body(triggers.map((x) => [x.path, x.kind]))
-        .render();
-}
-function checkIfValidTrigger(kind) {
-    if (kind && TRIGGER_TYPES.includes(kind)) {
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-function extractTriggerKindFromPath(filePath) {
-    let pathToAnalyze = filePath;
-    // If this is a branch-specific file, convert it to the base path first
-    if (isBranchSpecificFile(filePath)) {
-        const currentBranch = getCurrentGitBranch();
-        if (currentBranch) {
-            pathToAnalyze = fromBranchSpecificPath(filePath, currentBranch);
-        }
-    }
-    // Now extract trigger type from the base path: "something.kafka_trigger.yaml" -> "kafka"
-    const triggerMatch = pathToAnalyze.match(/\.(\w+)_trigger\.yaml$/);
-    return triggerMatch ? triggerMatch[1] : undefined;
-}
-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 = extractTriggerKindFromPath(filePath);
-    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/src/commands/user/user.js

@@ -1,428 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-import * as dntShim from "../../../_dnt.shims.js";
-import { requireLogin } from "../../core/auth.js";
-import { isSuperset, removeType, removePathPrefix, } from "../../types.js";
-import { compareInstanceObjects } from "../instance/instance.js";
-import { colors, Command, log, Table, yamlStringify, yamlParseFile, } from "../../../deps.js";
-import * as wmill from "../../../gen/services.gen.js";
-const INSTANCE_USERS_PATH = "instance_users.yaml";
-let instanceUsersPath = INSTANCE_USERS_PATH;
-function checkInstanceUsersPath(opts) {
-    if (opts.prefix && opts.folderPerInstance && opts.prefixSettings) {
-        instanceUsersPath = `${opts.prefix}/${INSTANCE_USERS_PATH}`;
-    }
-}
-const INSTANCE_GROUPS_PATH = "instance_groups.yaml";
-let instanceGroupsPath = INSTANCE_GROUPS_PATH;
-function checkInstanceGroupsPath(opts) {
-    if (opts.prefix && opts.folderPerInstance && opts.prefixSettings) {
-        instanceGroupsPath = `${opts.prefix}/${INSTANCE_GROUPS_PATH}`;
-    }
-}
-async function list(opts) {
-    await requireLogin(opts);
-    const perPage = 10;
-    let page = 0;
-    const total = [];
-    while (true) {
-        const res = await wmill.listUsersAsSuperAdmin({ page, perPage });
-        total.push(...res);
-        page += 1;
-        if (res.length < perPage) {
-            break;
-        }
-    }
-    new Table()
-        .header(["email", "name", "company", "verified", "super admin"])
-        .padding(2)
-        .border(true)
-        .body(total.map((x) => [
-        x.email,
-        x.name ?? "-",
-        x.company ?? "-",
-        x.verified ? "true" : "false",
-        x.super_admin ? "true" : "false",
-    ]))
-        .render();
-}
-function rdString() {
-    return Math.random().toString(36).slice(2, 7);
-}
-async function add(opts, email, password) {
-    await requireLogin(opts);
-    const password_final = password ?? rdString();
-    await wmill.createUserGlobally({
-        requestBody: {
-            email,
-            password: password_final,
-            super_admin: opts.superadmin ?? false,
-            company: opts.company,
-            name: opts.name,
-        },
-    });
-    if (!password) {
-        log.info(colors.red("New Password: " + password_final));
-    }
-    log.info(colors.underline.green("New User Created."));
-}
-async function remove(opts, email) {
-    await requireLogin(opts);
-    await wmill.globalUserDelete({ email });
-    log.info(colors.green("Deleted User " + email));
-}
-async function createToken(opts) {
-    await requireLogin(opts);
-    if (opts.email && opts.password) {
-        log.info("Token: " +
-            (await wmill.login({
-                requestBody: {
-                    email: opts.email,
-                    password: opts.password,
-                },
-            })));
-        return;
-    }
-    log.info("Token: " + (await wmill.createToken({ requestBody: {} })));
-}
-export async function pushWorkspaceUser(workspace, path, user, localUser) {
-    const email = removePathPrefix(removeType(path, "user"), "users");
-    log.debug(`Processing local user ${email}`);
-    if (!["operator", "developer", "admin"].includes(localUser.role)) {
-        throw new Error(`Invalid role for user ${email}: ${localUser.role}`);
-    }
-    try {
-        const remoteUser = await wmill.getUser({
-            workspace,
-            username: localUser.username,
-        });
-        user = {
-            role: remoteUser.is_admin
-                ? "admin"
-                : remoteUser.operator
-                    ? "operator"
-                    : "developer",
-            username: remoteUser.username,
-            disabled: remoteUser.disabled,
-        };
-        log.debug(`User ${email} exists on remote`);
-    }
-    catch {
-        log.debug(`User ${email} does not exist on remote`);
-        //ignore
-    }
-    if (user && user.username !== localUser.username) {
-        throw new Error("Username cannot be changed");
-    }
-    if (user) {
-        if (isSuperset(localUser, user)) {
-            log.debug(`User ${email} is up to date`);
-            return;
-        }
-        log.debug(`User ${email} is not up-to-date, updating...`);
-        try {
-            await wmill.updateUser({
-                workspace: workspace,
-                username: localUser.username,
-                requestBody: {
-                    is_admin: localUser.role === "admin",
-                    operator: localUser.role === "operator",
-                    disabled: localUser.disabled,
-                },
-            });
-        }
-        catch (e) {
-            //@ts-ignore
-            console.error(e.body);
-            throw e;
-        }
-    }
-    else {
-        console.log(colors.bold.yellow("Creating new user: " + email));
-        try {
-            const automatedUsernameCreation = (await wmill.getGlobal({
-                key: "automate_username_creation",
-            }));
-            await wmill.addUser({
-                workspace: workspace,
-                requestBody: {
-                    email: email,
-                    is_admin: localUser.role === "admin",
-                    operator: localUser.role === "operator",
-                    username: !automatedUsernameCreation ? localUser.username : undefined,
-                },
-            });
-        }
-        catch (e) {
-            //@ts-ignore
-            console.error(e.body);
-            throw e;
-        }
-    }
-}
-export async function pushGroup(workspace, path, group, localGroup) {
-    const name = removePathPrefix(removeType(path, "group"), "groups");
-    log.debug(`Processing local group ${name}`);
-    try {
-        const remoteGroup = await wmill.getGroup({
-            workspace,
-            name,
-        });
-        // only consider extra_perms that concern actual members of the group
-        const admins = Object.entries(remoteGroup.extra_perms ?? {})
-            .filter(([k, v]) => v && remoteGroup.members?.includes(k.slice(2)))
-            .map(([k, _]) => k)
-            .sort();
-        group = {
-            summary: remoteGroup.summary,
-            admins,
-            // remove members that are also admins as they are already in the admins list
-            members: (remoteGroup.members ?? [])
-                .map((m) => "u/" + m)
-                .filter((m) => !admins.includes(m)),
-        };
-        log.debug(`Group ${name} exists on remote`);
-    }
-    catch {
-        log.debug(`Group ${name} does not exist on remote`);
-        //ignore
-    }
-    if (group) {
-        if (isSuperset(localGroup, group)) {
-            log.debug(`Group ${name} is up to date`);
-            return;
-        }
-        log.debug(`Group ${name} is not up-to-date, updating...`);
-        try {
-            await wmill.updateGroup({
-                workspace: workspace,
-                name,
-                requestBody: {
-                    summary: localGroup.summary,
-                },
-            });
-        }
-        catch (e) {
-            //@ts-ignore
-            console.error(e.body);
-            throw e;
-        }
-        for (const member of [...localGroup.members, ...localGroup.admins]) {
-            try {
-                if ([...group.members, ...group.admins].includes(member)) {
-                    log.debug(`${member} is already in group ${name}`);
-                }
-                else {
-                    log.debug(`Adding ${member} to group ${name}`);
-                    await wmill.addUserToGroup({
-                        workspace: workspace,
-                        name,
-                        requestBody: {
-                            username: member.slice(2),
-                        },
-                    });
-                }
-                if (localGroup.admins.includes(member) &&
-                    !group.admins.includes(member)) {
-                    log.debug(`Setting role of ${member} as admin in group ${name}`);
-                    await wmill.addGranularAcls({
-                        workspace: workspace,
-                        kind: "group_",
-                        path: name,
-                        requestBody: {
-                            owner: member,
-                            write: true,
-                        },
-                    });
-                }
-                if (localGroup.members.includes(member) &&
-                    !group.members.includes(member)) {
-                    log.debug(`Setting role of ${member} as member in group ${name}`);
-                    await wmill.addGranularAcls({
-                        workspace: workspace,
-                        kind: "group_",
-                        path: name,
-                        requestBody: {
-                            owner: member,
-                            write: false,
-                        },
-                    });
-                }
-            }
-            catch (e) {
-                //@ts-ignore
-                console.error(e.body);
-                throw e;
-            }
-        }
-        for (const member of [...group.members, ...group.admins]) {
-            if (![...localGroup.members, ...localGroup.admins].includes(member)) {
-                log.debug(`Removing ${member} and any associated role from group ${name}`);
-                try {
-                    await wmill.removeUserToGroup({
-                        workspace: workspace,
-                        name,
-                        requestBody: {
-                            username: member.slice(2),
-                        },
-                    });
-                    await wmill.removeGranularAcls({
-                        workspace: workspace,
-                        kind: "group_",
-                        path: name,
-                        requestBody: {
-                            owner: member,
-                        },
-                    });
-                }
-                catch (e) {
-                    //@ts-ignore
-                    console.error(e.body);
-                    throw e;
-                }
-            }
-        }
-    }
-    else {
-        console.log(colors.bold.yellow("Creating new user: " + name));
-        try {
-            await wmill.createGroup({
-                workspace: workspace,
-                requestBody: {
-                    name,
-                    summary: localGroup.summary,
-                },
-            });
-            for (const member of [...localGroup.members, ...localGroup.admins]) {
-                log.debug(`Adding user ${member} to group ${name}`);
-                try {
-                    await wmill.addUserToGroup({
-                        workspace: workspace,
-                        name,
-                        requestBody: {
-                            username: member.slice(2),
-                        },
-                    });
-                    if (localGroup.admins.includes(member)) {
-                        log.debug(`Setting role of ${member} as admin in group ${name}`);
-                        await wmill.addGranularAcls({
-                            workspace: workspace,
-                            kind: "group_",
-                            path: name,
-                            requestBody: {
-                                owner: member,
-                                write: true,
-                            },
-                        });
-                    }
-                }
-                catch (e) {
-                    //@ts-ignore
-                    console.error(e.body);
-                    throw e;
-                }
-            }
-        }
-        catch (e) {
-            //@ts-ignore
-            console.error(e.body);
-            throw e;
-        }
-    }
-}
-export async function pullInstanceUsers(opts, preview = false) {
-    const remoteUsers = await wmill.globalUsersExport();
-    checkInstanceUsersPath(opts);
-    if (preview) {
-        const localUsers = await readInstanceUsers(opts);
-        return compareInstanceObjects(remoteUsers, localUsers, "email", "user");
-    }
-    else {
-        log.info("Pulling users from instance...");
-        await dntShim.Deno.writeTextFile(instanceUsersPath, yamlStringify(remoteUsers));
-        log.info(colors.green(`Users written to ${instanceUsersPath}`));
-    }
-}
-export async function readInstanceUsers(opts) {
-    let localUsers = [];
-    await checkInstanceUsersPath(opts);
-    try {
-        localUsers = (await yamlParseFile(instanceUsersPath));
-    }
-    catch {
-        log.warn(`No ${instanceUsersPath} file found`);
-    }
-    return localUsers;
-}
-export async function readInstanceGroups(opts) {
-    let localGroups = [];
-    checkInstanceGroupsPath(opts);
-    try {
-        localGroups = (await yamlParseFile(instanceGroupsPath));
-    }
-    catch {
-        log.warn(`No ${instanceGroupsPath} file found`);
-    }
-    return localGroups;
-}
-export async function pushInstanceUsers(opts, preview = false) {
-    const remoteUsers = await wmill.globalUsersExport();
-    const localUsers = await readInstanceUsers(opts);
-    if (preview) {
-        return compareInstanceObjects(localUsers, remoteUsers, "email", "user");
-    }
-    else {
-        log.info("Pushing users to instance...");
-        await wmill.globalUsersOverwrite({
-            requestBody: localUsers,
-        });
-        log.info(colors.green("Users pushed to the instance"));
-    }
-}
-export async function pullInstanceGroups(opts, preview = false) {
-    const remoteGroups = await wmill.exportInstanceGroups();
-    checkInstanceGroupsPath(opts);
-    if (preview) {
-        const localGroups = await readInstanceGroups(opts);
-        return compareInstanceObjects(remoteGroups, localGroups, "name", "group");
-    }
-    else {
-        log.info("Pulling groups from instance...");
-        await dntShim.Deno.writeTextFile(instanceGroupsPath, yamlStringify(remoteGroups));
-        log.info(colors.green(`Groups written to ${instanceGroupsPath}`));
-    }
-}
-export async function pushInstanceGroups(opts, preview = false) {
-    const remoteGroups = await wmill.exportInstanceGroups();
-    const localGroups = await readInstanceGroups(opts);
-    if (preview) {
-        return compareInstanceObjects(localGroups, remoteGroups, "name", "group");
-    }
-    else {
-        log.info("Pushing groups to instance...");
-        await wmill.overwriteInstanceGroups({
-            requestBody: localGroups,
-        });
-        log.info(colors.green("Groups pushed to the instance"));
-    }
-}
-const command = new Command()
-    .description("user related commands")
-    .action(list)
-    .command("add", "Create a user")
-    .arguments("<email:string> [password:string]")
-    .option("--superadmin", "Specify to make the new user superadmin.")
-    .option("--company <company:string>", "Specify to set the company of the new user.")
-    .option("--name <name:string>", "Specify to set the name of the new user.")
-    .action(add)
-    .command("remove", "Delete a user")
-    .arguments("<email:string>")
-    .action(remove)
-    .command("create-token")
-    .option("--email <email:string>", "Specify credentials to use for authentication. This will not be stored. It will only be used to exchange for a token with the API server, which will not be stored either.", {
-    depends: ["password"],
-})
-    .option("--password <password:string>", "Specify credentials to use for authentication. This will not be stored. It will only be used to exchange for a token with the API server, which will not be stored either.", {
-    depends: ["email"],
-})
-    .action(createToken);
-export default command;