windmill-cli 1.518.2 → 1.518.3

package/esm/deps/jsr.io/@std/yaml/1.0.5/_utils.js

@@ -0,0 +1,13 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+export function isObject(value) {
+    return value !== null && typeof value === "object";
+}
+export function isNegativeZero(i) {
+    return i === 0 && Number.NEGATIVE_INFINITY === 1 / i;
+}
+export function isPlainObject(object) {
+    return Object.prototype.toString.call(object) === "[object Object]";
+}

package/esm/deps/jsr.io/@std/yaml/1.0.5/mod.js

@@ -0,0 +1,52 @@
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * {@linkcode parse} and {@linkcode stringify} for handling
+ * {@link https://yaml.org/ | YAML} encoded data.
+ *
+ * Ported from
+ * {@link https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da | js-yaml v3.13.1}.
+ *
+ * Use {@linkcode parseAll} for parsing multiple documents in a single YAML
+ * string.
+ *
+ * This package generally supports
+ * {@link https://yaml.org/spec/1.2.2/ | YAML 1.2.x} (latest) and some
+ * {@link https://yaml.org/spec/1.1/current.html | YAML 1.1} features that are
+ * commonly used in the wild.
+ *
+ * Supported YAML 1.1 features include:
+ * - {@link https://yaml.org/type/merge.html | Merge} type (`<<` symbol)
+ *
+ * Unsupported YAML 1.1 features include:
+ * - Yes, No, On, Off literals for bool type
+ * - Sexagesimal numbers (e.g. `3:25:45`)
+ *
+ * ```ts
+ * import { parse, stringify } from "@std/yaml";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = parse(`
+ * foo: bar
+ * baz:
+ *   - qux
+ *   - quux
+ * `);
+ * assertEquals(data, { foo: "bar", baz: [ "qux", "quux" ] });
+ *
+ * const yaml = stringify({ foo: "bar", baz: ["qux", "quux"] });
+ * assertEquals(yaml, `foo: bar
+ * baz:
+ *   - qux
+ *   - quux
+ * `);
+ * ```
+ *
+ * ## Limitations
+ * - `binary` type is currently not stable.
+ *
+ * @module
+ */
+export * from "./parse.js";
+export * from "./stringify.js";

package/esm/deps/jsr.io/@std/yaml/1.0.5/parse.js

@@ -0,0 +1,93 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { isEOL } from "./_chars.js";
+import { LoaderState } from "./_loader_state.js";
+import { SCHEMA_MAP } from "./_schema.js";
+function sanitizeInput(input) {
+    input = String(input);
+    if (input.length > 0) {
+        // Add trailing `\n` if not exists
+        if (!isEOL(input.charCodeAt(input.length - 1)))
+            input += "\n";
+        // Strip BOM
+        if (input.charCodeAt(0) === 0xfeff)
+            input = input.slice(1);
+    }
+    // Use 0 as string terminator. That significantly simplifies bounds check.
+    input += "\0";
+    return input;
+}
+/**
+ * Parse and return a YAML string as a parsed YAML document object.
+ *
+ * Note: This does not support functions. Untrusted data is safe to parse.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/yaml/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = parse(`
+ * id: 1
+ * name: Alice
+ * `);
+ *
+ * assertEquals(data, { id: 1, name: "Alice" });
+ * ```
+ *
+ * @throws {SyntaxError} Throws error on invalid YAML.
+ * @param content YAML string to parse.
+ * @param options Parsing options.
+ * @returns Parsed document.
+ */
+export function parse(content, options = {}) {
+    content = sanitizeInput(content);
+    const state = new LoaderState(content, {
+        ...options,
+        schema: SCHEMA_MAP.get(options.schema),
+    });
+    const documentGenerator = state.readDocuments();
+    const document = documentGenerator.next().value;
+    if (!documentGenerator.next().done) {
+        throw new SyntaxError("Found more than 1 document in the stream: expected a single document");
+    }
+    return document ?? null;
+}
+/**
+ * Same as {@linkcode parse}, but understands multi-document YAML sources, and
+ * returns multiple parsed YAML document objects.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseAll } from "@std/yaml/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = parseAll(`
+ * ---
+ * id: 1
+ * name: Alice
+ * ---
+ * id: 2
+ * name: Bob
+ * ---
+ * id: 3
+ * name: Eve
+ * `);
+ * assertEquals(data, [ { id: 1, name: "Alice" }, { id: 2, name: "Bob" }, { id: 3, name: "Eve" }]);
+ * ```
+ *
+ * @param content YAML string to parse.
+ * @param options Parsing options.
+ * @returns Array of parsed documents.
+ */
+export function parseAll(content, options = {}) {
+    content = sanitizeInput(content);
+    const state = new LoaderState(content, {
+        ...options,
+        schema: SCHEMA_MAP.get(options.schema),
+    });
+    return [...state.readDocuments()];
+}

package/esm/deps/jsr.io/@std/yaml/1.0.5/stringify.js

@@ -0,0 +1,33 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { DumperState } from "./_dumper_state.js";
+import { SCHEMA_MAP } from "./_schema.js";
+/**
+ * Converts a JavaScript object or value to a YAML document string.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/yaml/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = { id: 1, name: "Alice" };
+ * const yaml = stringify(data);
+ *
+ * assertEquals(yaml, "id: 1\nname: Alice\n");
+ * ```
+ *
+ * @throws {TypeError} If `data` contains invalid types.
+ * @param data The data to serialize.
+ * @param options The options for serialization.
+ * @returns A YAML string.
+ */
+export function stringify(data, options = {}) {
+    const state = new DumperState({
+        ...options,
+        schema: SCHEMA_MAP.get(options.schema),
+    });
+    return state.stringify(data);
+}

package/esm/deps.js

@@ -12,16 +12,16 @@ export { NpmProvider } from "./deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-r
 export { Provider } from "./deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-rc.5/upgrade/mod.js";
 export { CompletionsCommand } from "./deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-rc.5/completions/mod.js";
 // std
-export { ensureDir } from "./deps/jsr.io/@std/fs/1.0.19/mod.js";
-export { SEPARATOR as SEP } from "./deps/jsr.io/@std/path/1.1.1/mod.js";
-export * as path from "./deps/jsr.io/@std/path/1.1.1/mod.js";
+export { ensureDir } from "./deps/jsr.io/@std/fs/1.0.16/mod.js";
+export { SEPARATOR as SEP } from "./deps/jsr.io/@std/path/1.0.8/mod.js";
+export * as path from "./deps/jsr.io/@std/path/1.0.8/mod.js";
 export { encodeHex } from "./deps/jsr.io/@std/encoding/1.0.4/mod.js";
 export { writeAllSync } from "./deps/jsr.io/@std/io/0.225.2/write_all.js";
 export { copy } from "./deps/jsr.io/@std/io/0.225.2/copy.js";
 export { readAll } from "./deps/jsr.io/@std/io/0.225.2/read_all.js";
 export * as log from "./deps/jsr.io/@std/log/0.224.14/mod.js";
-export { stringify as yamlStringify } from "./deps/jsr.io/@std/yaml/1.0.9/mod.js";
-import { parse as yamlParse } from "./deps/jsr.io/@std/yaml/1.0.9/mod.js";
+export { stringify as yamlStringify } from "./deps/jsr.io/@std/yaml/1.0.5/mod.js";
+import { parse as yamlParse } from "./deps/jsr.io/@std/yaml/1.0.5/mod.js";
 export async function yamlParseFile(path, options = {}) {
     try {
         return yamlParse(await dntShim.Deno.readTextFile(path), options);

package/esm/gen/services.gen.js

@@ -476,6 +476,37 @@ export const existsUsername = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * checks that all given databases exist or else return the ones that don't
+ * @param data The data for the request.
+ * @param data.requestBody
+ * @returns string databases that do not exist
+ * @throws ApiError
+ */
+export const databasesExist = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/settings/databases_exist',
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * Runs CREATE DATABASE on the Windmill Postgres and grants access to the ducklake_user
+ * @param data The data for the request.
+ * @param data.name The name of the database to create
+ * @returns unknown status
+ * @throws ApiError
+ */
+export const createDucklakeDatabase = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/settings/create_ducklake_database/{name}',
+        path: {
+            name: data.name
+        }
+    });
+};
 /**
  * get global settings
  * @param data The data for the request.
@@ -1599,6 +1630,41 @@ export const editLargeFileStorageConfig = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * list ducklakes
+ * @param data The data for the request.
+ * @param data.workspace
+ * @returns string status
+ * @throws ApiError
+ */
+export const listDucklakes = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/workspaces/list_ducklakes',
+        path: {
+            workspace: data.workspace
+        }
+    });
+};
+/**
+ * edit ducklake settings
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody Ducklake settings
+ * @returns unknown status
+ * @throws ApiError
+ */
+export const editDucklakeConfig = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspaces/edit_ducklake_config',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * edit workspace git sync settings
  * @param data The data for the request.

package/esm/src/commands/app/apps.js

@@ -0,0 +1,124 @@
+// deno-lint-ignore-file no-explicit-any
+import { requireLogin } from "../../core/auth.js";
+import { resolveWorkspace, validatePath } from "../../core/context.js";
+import { colors, Command, log, SEP, Table, yamlParseFile } from "../../../deps.js";
+import * as wmill from "../../../gen/services.gen.js";
+import { isSuperset } from "../../types.js";
+import { readInlinePathSync } from "../../utils/utils.js";
+const alreadySynced = [];
+export async function pushApp(workspace, remotePath, localPath, message) {
+    if (alreadySynced.includes(localPath)) {
+        return;
+    }
+    alreadySynced.push(localPath);
+    remotePath = remotePath.replaceAll(SEP, "/");
+    let app = undefined;
+    // deleting old app if it exists in raw mode
+    try {
+        app = await wmill.getAppByPath({
+            workspace,
+            path: remotePath,
+        });
+    }
+    catch {
+        //ignore
+    }
+    if (!localPath.endsWith(SEP)) {
+        localPath += SEP;
+    }
+    const path = localPath + "app.yaml";
+    const localApp = (await yamlParseFile(path));
+    function replaceInlineScripts(rec) {
+        if (!rec) {
+            return;
+        }
+        if (typeof rec == "object") {
+            return Object.entries(rec).flatMap(([k, v]) => {
+                if (k == "inlineScript" && typeof v == "object") {
+                    const o = v;
+                    if (o["content"] && o["content"].startsWith("!inline")) {
+                        const basePath = localPath + o["content"].split(" ")[1];
+                        o["content"] = readInlinePathSync(basePath);
+                    }
+                    if (o["lock"] && o["lock"].startsWith("!inline")) {
+                        const basePath = localPath + o["lock"].split(" ")[1];
+                        o["lock"] = readInlinePathSync(basePath);
+                    }
+                }
+                else {
+                    replaceInlineScripts(v);
+                }
+            });
+        }
+        return [];
+    }
+    replaceInlineScripts(localApp.value);
+    if (app) {
+        if (isSuperset(localApp, app)) {
+            log.info(colors.green(`App ${remotePath} is up to date`));
+            return;
+        }
+        log.info(colors.bold.yellow(`Updating app ${remotePath}...`));
+        await wmill.updateApp({
+            workspace,
+            path: remotePath,
+            requestBody: {
+                deployment_message: message,
+                ...localApp,
+            },
+        });
+    }
+    else {
+        log.info(colors.yellow.bold("Creating new app..."));
+        await wmill.createApp({
+            workspace,
+            requestBody: {
+                path: remotePath,
+                deployment_message: message,
+                ...localApp,
+            },
+        });
+    }
+}
+async function list(opts) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    let page = 0;
+    const perPage = 10;
+    const total = [];
+    while (true) {
+        const res = await wmill.listApps({
+            workspace: workspace.workspaceId,
+            page,
+            perPage,
+            includeDraftOnly: opts.includeDraftOnly ?? false,
+        });
+        page += 1;
+        total.push(...res);
+        if (res.length < perPage) {
+            break;
+        }
+    }
+    new Table()
+        .header(["path", "summary"])
+        .padding(2)
+        .border(true)
+        .body(total.map((x) => [x.path, x.summary]))
+        .render();
+}
+async function push(opts, filePath, remotePath) {
+    if (!validatePath(remotePath)) {
+        return;
+    }
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    await pushApp(workspace.workspaceId, remotePath, filePath);
+    log.info(colors.bold.underline.green("Flow pushed"));
+}
+const command = new Command()
+    .description("app related commands")
+    .action(list)
+    .command("push", "push a local app ")
+    .arguments("<file_path:string> <remote_path:string>")
+    .action(push);
+export default command;

package/esm/src/commands/dev/dev.js

@@ -0,0 +1,145 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { Command, SEP, WebSocketServer, express, getPort, http, log, open, yamlParseFile, } from "../../../deps.js";
+import { getTypeStrFromPath } from "../../types.js";
+import { ignoreF } from "../sync/sync.js";
+import { requireLogin } from "../../core/auth.js";
+import { resolveWorkspace } from "../../core/context.js";
+import { mergeConfigWithConfigFile, readConfigFile, } from "../../core/conf.js";
+import { exts, findGlobalDeps, removeExtensionToPath } from "../script/script.js";
+import { inferContentTypeFromFilePath } from "../../utils/script_common.js";
+import { replaceInlineScripts } from "../../../windmill-utils-internal/src/inline-scripts/replacer.js";
+import { parseMetadataFile } from "../../utils/metadata.js";
+const PORT = 3001;
+async function dev(opts) {
+    const workspace = await resolveWorkspace(opts);
+    await requireLogin(opts);
+    log.info("Started dev mode");
+    const conf = await readConfigFile();
+    let currentLastEdit = undefined;
+    const watcher = dntShim.Deno.watchFs(".");
+    const base = await dntShim.Deno.realPath(".");
+    opts = await mergeConfigWithConfigFile(opts);
+    const ignore = await ignoreF(opts);
+    const changesTimeouts = {};
+    async function watchChanges() {
+        for await (const event of watcher) {
+            // console.log(">>>> event", event);
+            const key = event.paths.join(",");
+            if (changesTimeouts[key]) {
+                clearTimeout(changesTimeouts[key]);
+            }
+            // @ts-ignore
+            changesTimeouts[key] = setTimeout(async () => {
+                delete changesTimeouts[key];
+                await loadPaths(event.paths);
+            }, 100);
+        }
+    }
+    const DOT_FLOW_SEP = ".flow" + SEP;
+    async function loadPaths(pathsToLoad) {
+        const paths = pathsToLoad.filter((path) => exts.some((ext) => path.endsWith(ext) || path.endsWith(DOT_FLOW_SEP + "flow.yaml")));
+        if (paths.length == 0) {
+            return;
+        }
+        const cpath = (await dntShim.Deno.realPath(paths[0])).replace(base + SEP, "");
+        if (!ignore(cpath, false)) {
+            const typ = getTypeStrFromPath(cpath);
+            log.info("Detected change in " + cpath + " (" + typ + ")");
+            if (typ == "flow") {
+                const localPath = cpath.split(DOT_FLOW_SEP)[0] + DOT_FLOW_SEP;
+                const localFlow = (await yamlParseFile(localPath + "flow.yaml"));
+                await replaceInlineScripts(localFlow.value.modules, async (path) => await dntShim.Deno.readTextFile(localPath + path), log, localPath, SEP, undefined, (path, newPath) => dntShim.Deno.renameSync(path, newPath), (path) => dntShim.Deno.removeSync(path));
+                currentLastEdit = {
+                    type: "flow",
+                    flow: localFlow,
+                    uriPath: localPath,
+                };
+                log.info("Updated " + localPath);
+                broadcastChanges(currentLastEdit);
+            }
+            else if (typ == "script") {
+                const content = await dntShim.Deno.readTextFile(cpath);
+                const splitted = cpath.split(".");
+                const wmPath = splitted[0];
+                const lang = inferContentTypeFromFilePath(cpath, conf.defaultTs);
+                const globalDeps = await findGlobalDeps();
+                const typed = (await parseMetadataFile(removeExtensionToPath(cpath), undefined, globalDeps, []))?.payload;
+                currentLastEdit = {
+                    type: "script",
+                    content,
+                    path: wmPath,
+                    language: lang,
+                    tag: typed?.tag,
+                    lock: typed?.lock,
+                };
+                log.info("Updated " + wmPath);
+                broadcastChanges(currentLastEdit);
+            }
+        }
+    }
+    const connectedClients = new Set();
+    // Function to send a message to all connected clients
+    function broadcastChanges(lastEdit) {
+        for (const client of connectedClients.values()) {
+            client.send(JSON.stringify(lastEdit));
+        }
+    }
+    async function startApp() {
+        const app = express.default();
+        const server = http.createServer(app);
+        const wss = new WebSocketServer({ server });
+        // WebSocket server event listeners
+        wss.on("connection", (ws) => {
+            connectedClients.add(ws);
+            console.log("New client connected");
+            ws.on("open", () => {
+                if (currentLastEdit) {
+                    broadcastChanges(currentLastEdit);
+                }
+            });
+            ws.on("close", () => {
+                connectedClients.delete(ws);
+                console.log("Client disconnected");
+            });
+            ws.on("message", (message) => {
+                let data;
+                try {
+                    data = JSON.parse(message);
+                }
+                catch (e) {
+                    console.log("Received invalid JSON: " + message + " " + e);
+                    return;
+                }
+                if (data.type === "load") {
+                    loadPaths([data.path]);
+                }
+            });
+        });
+        // Start the server
+        const port = await getPort.default({ port: 3001 });
+        const url = `${workspace.remote}dev?workspace=${workspace.workspaceId}&local=true&wm_token=${workspace.token}` +
+            (port === PORT ? "" : `&port=${port}`);
+        console.log(`Go to ${url}`);
+        try {
+            open.openApp(open.apps.browser, { arguments: [url] }).catch((error) => {
+                console.error(`Failed to open browser, please navigate to ${url}, error: ${error}`);
+            });
+            console.log("Opened browser for you");
+        }
+        catch (error) {
+            console.error(`Failed to open browser, please navigate to ${url}, ${error}`);
+        }
+        console.log("Dev server will automatically point to the last script edited locally");
+        server.listen(port, () => {
+            console.log(`Server listening on port ${port}`);
+        });
+    }
+    await Promise.all([startApp(), watchChanges()]);
+    console.log("Stopped dev mode");
+}
+const command = new Command()
+    .description("Launch a dev server that will spawn a webserver with HMR")
+    .option("--includes <pattern...:string>", "Filter paths givena glob pattern or path")
+    // deno-lint-ignore no-explicit-any
+    .action(dev);
+export default command;