windmill-cli 1.516.0 → 1.518.1

package/esm/dev.js

@@ -7,7 +7,7 @@ import { resolveWorkspace } from "./context.js";
 import { mergeConfigWithConfigFile, readConfigFile, } from "./conf.js";
 import { exts, findGlobalDeps, removeExtensionToPath } from "./script.js";
 import { inferContentTypeFromFilePath } from "./script_common.js";
-import { replaceInlineScripts } from "./flow.js";
+import { replaceInlineScripts } from "./windmill-utils-internal/src/inline-scripts/replacer.js";
 import { parseMetadataFile } from "./metadata.js";
 const PORT = 3001;
 async function dev(opts) {
@@ -48,7 +48,7 @@ async function dev(opts) {
             if (typ == "flow") {
                 const localPath = cpath.split(DOT_FLOW_SEP)[0] + DOT_FLOW_SEP;
                 const localFlow = (await yamlParseFile(localPath + "flow.yaml"));
-                replaceInlineScripts(localFlow.value.modules, localPath, undefined);
+                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,

package/esm/flow.js

@@ -11,50 +11,8 @@ import { defaultFlowDefinition } from "./bootstrap/flow_bootstrap.js";
 import { generateFlowLockInternal } from "./metadata.js";
 import { mergeConfigWithConfigFile } from "./conf.js";
 import { FSFSElement, elementsToMap, ignoreF } from "./sync.js";
-import { readInlinePathSync } from "./utils.js";
+import { replaceInlineScripts } from "./windmill-utils-internal/src/inline-scripts/replacer.js";
 const alreadySynced = [];
-export function replaceInlineScripts(modules, localPath, removeLocks) {
-    modules.forEach((m, i) => {
-        if (!m.value) {
-            throw Error(`Module value is undefined for flow module ${i} in ${localPath}`);
-            return;
-        }
-        if (m.value.type == "rawscript") {
-            if (m.value.content.startsWith("!inline")) {
-                const path = m.value.content.split(" ")[1];
-                m.value.content = dntShim.Deno.readTextFileSync(localPath + path);
-                const lock = m.value.lock;
-                if (removeLocks && removeLocks.includes(path)) {
-                    m.value.lock = undefined;
-                }
-                else if (lock &&
-                    typeof lock == "string" &&
-                    lock.trimStart().startsWith("!inline ")) {
-                    const path = lock.split(" ")[1];
-                    try {
-                        m.value.lock = readInlinePathSync(localPath + path);
-                    }
-                    catch {
-                        log.error(`Lock file ${path} not found`);
-                    }
-                }
-            }
-        }
-        else if (m.value.type == "forloopflow") {
-            replaceInlineScripts(m.value.modules, localPath, removeLocks);
-        }
-        else if (m.value.type == "whileloopflow") {
-            replaceInlineScripts(m.value.modules, localPath, removeLocks);
-        }
-        else if (m.value.type == "branchall") {
-            m.value.branches.forEach((b) => replaceInlineScripts(b.modules, localPath, removeLocks));
-        }
-        else if (m.value.type == "branchone") {
-            m.value.branches.forEach((b) => replaceInlineScripts(b.modules, localPath, removeLocks));
-            replaceInlineScripts(m.value.default, localPath, removeLocks);
-        }
-    });
-}
 export async function pushFlow(workspace, remotePath, localPath, message) {
     if (alreadySynced.includes(localPath)) {
         return;
@@ -75,7 +33,7 @@ export async function pushFlow(workspace, remotePath, localPath, message) {
         localPath += SEP;
     }
     const localFlow = (await yamlParseFile(localPath + "flow.yaml"));
-    replaceInlineScripts(localFlow.value.modules, localPath, undefined);
+    await replaceInlineScripts(localFlow.value.modules, async (path) => await dntShim.Deno.readTextFile(localPath + path), log, localPath, SEP);
     if (flow) {
         if (isSuperset(localFlow, flow)) {
             log.info(colors.green(`Flow ${remotePath} is up to date`));

package/esm/gen/core/OpenAPI.js

@@ -32,7 +32,7 @@ export const OpenAPI = {
     PASSWORD: undefined,
     TOKEN: getEnv("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: '1.516.0',
+    VERSION: '1.518.1',
     WITH_CREDENTIALS: true,
     interceptors: {
         request: new Interceptors(),

package/esm/main.js

@@ -39,7 +39,7 @@ export { flow, app, script, workspace, resource, resourceType, user, variable, h
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.516.0";
+export const VERSION = "1.518.1";
 const command = new Command()
     .name("wmill")
     .action(() => log.info(`Welcome to Windmill CLI ${VERSION}. Use -h for help.`))
@@ -162,7 +162,8 @@ const command = new Command()
             }
             catch (error) {
                 // If there's an error checking backend settings, just continue with defaults
-                log.warn(`Could not check backend for git-sync settings: ${error.message}`);
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                log.warn(`Could not check backend for git-sync settings: ${errorMessage}`);
                 log.info("Continuing with default settings");
             }
         }
@@ -174,16 +175,16 @@ const command = new Command()
         // Create .cursor/rules directory
         await dntShim.Deno.mkdir(".cursor/rules", { recursive: true });
         // Create windmill.mdc file
-        if (!await dntShim.Deno.stat(".cursor/rules/script.mdc").catch(() => null)) {
+        if (!(await dntShim.Deno.stat(".cursor/rules/script.mdc").catch(() => null))) {
             await dntShim.Deno.writeTextFile(".cursor/rules/script.mdc", scriptGuidanceContent);
             log.info(colors.green("Created .cursor/rules/script.mdc"));
         }
-        if (!await dntShim.Deno.stat(".cursor/rules/flow.mdc").catch(() => null)) {
+        if (!(await dntShim.Deno.stat(".cursor/rules/flow.mdc").catch(() => null))) {
             await dntShim.Deno.writeTextFile(".cursor/rules/flow.mdc", flowGuidanceContent);
             log.info(colors.green("Created .cursor/rules/flow.mdc"));
         }
         // Create CLAUDE.md file
-        if (!await dntShim.Deno.stat("CLAUDE.md").catch(() => null)) {
+        if (!(await dntShim.Deno.stat("CLAUDE.md").catch(() => null))) {
             await dntShim.Deno.writeTextFile("CLAUDE.md", `
                         # Claude
 

package/esm/metadata.js

@@ -5,9 +5,11 @@ import { defaultScriptMetadata, } from "./bootstrap/script_bootstrap.js";
 import { languagesWithRawReqsSupport, } from "./script_common.js";
 import { inferContentTypeFromFilePath } from "./script_common.js";
 import { exts, findGlobalDeps } from "./script.js";
-import { FSFSElement, extractInlineScriptsForFlows, findCodebase, newPathAssigner, yamlOptions, } from "./sync.js";
+import { FSFSElement, findCodebase, newPathAssigner, yamlOptions } from "./sync.js";
 import { generateHash, readInlinePathSync } from "./utils.js";
-import { replaceInlineScripts } from "./flow.js";
+import { replaceInlineScripts } from "./windmill-utils-internal/src/inline-scripts/replacer.js";
+import { extractInlineScripts as extractInlineScriptsForFlows } from "./windmill-utils-internal/src/inline-scripts/extractor.js";
+import { argSigToJsonSchemaType } from "./windmill-utils-internal/src/parse/parse-schema.js";
 import { getIsWin } from "./main.js";
 export class LockfileGenerationError extends Error {
     constructor(message) {
@@ -104,10 +106,10 @@ export async function generateFlowLockInternal(folder, dryRun, workspace, opts,
             }
         }
         log.info(`Recomputing locks of ${changedScripts.join(", ")} in ${folder}`);
-        replaceInlineScripts(flowValue.value.modules, folder + SEP, changedScripts);
+        await replaceInlineScripts(flowValue.value.modules, async (path) => await dntShim.Deno.readTextFile(folder + SEP + path), log, folder + SEP, SEP, changedScripts, (path, newPath) => dntShim.Deno.renameSync(path, newPath), (path) => dntShim.Deno.removeSync(path));
         //removeChangedLocks
         flowValue.value = await updateFlow(workspace, flowValue.value, remote_path, rawReqs);
-        const inlineScripts = extractInlineScriptsForFlows(flowValue.value.modules, newPathAssigner(opts.defaultTs ?? "bun"));
+        const inlineScripts = extractInlineScriptsForFlows(flowValue.value.modules, {}, SEP, opts.defaultTs, newPathAssigner(opts.defaultTs ?? "bun"));
         inlineScripts
             .filter((s) => s.path.endsWith(".lock"))
             .forEach((s) => {
@@ -478,216 +480,6 @@ function sortObject(obj) {
         [key]: obj[key],
     }), {});
 }
-//copied straight fron frontend /src/utils/inferArgs.ts
-export function argSigToJsonSchemaType(t, oldS) {
-    const newS = { type: "" };
-    if (t === "int") {
-        newS.type = "integer";
-    }
-    else if (t === "float") {
-        newS.type = "number";
-    }
-    else if (t === "bool") {
-        newS.type = "boolean";
-    }
-    else if (t === "email") {
-        newS.type = "string";
-        newS.format = "email";
-    }
-    else if (t === "sql") {
-        newS.type = "string";
-        newS.format = "sql";
-    }
-    else if (t === "yaml") {
-        newS.type = "string";
-        newS.format = "yaml";
-    }
-    else if (t === "bytes") {
-        newS.type = "string";
-        newS.contentEncoding = "base64";
-        newS.originalType = "bytes";
-    }
-    else if (t === "datetime") {
-        newS.type = "string";
-        newS.format = "date-time";
-    }
-    else if (typeof t !== "string" && "oneof" in t) {
-        newS.type = "object";
-        if (t.oneof) {
-            newS.oneOf = t.oneof.map((obj) => {
-                const oldObjS = oldS.oneOf?.find((o) => o?.title === obj.label) ?? undefined;
-                const properties = {};
-                for (const prop of obj.properties) {
-                    if (oldObjS?.properties && prop.key in oldObjS?.properties) {
-                        properties[prop.key] = oldObjS?.properties[prop.key];
-                    }
-                    else {
-                        properties[prop.key] = { description: "", type: "" };
-                    }
-                    argSigToJsonSchemaType(prop.typ, properties[prop.key]);
-                }
-                return {
-                    type: "object",
-                    title: obj.label,
-                    properties,
-                    order: oldObjS?.order ?? undefined,
-                };
-            });
-        }
-    }
-    else if (typeof t !== "string" && `object` in t) {
-        newS.type = "object";
-        if (t.object.name) {
-            newS.format = `resource-${t.object.name}`;
-        }
-        if (t.object.props) {
-            const properties = {};
-            for (const prop of t.object.props) {
-                if (oldS.properties && prop.key in oldS.properties) {
-                    properties[prop.key] = oldS.properties[prop.key];
-                }
-                else {
-                    properties[prop.key] = { description: "", type: "" };
-                }
-                argSigToJsonSchemaType(prop.typ, properties[prop.key]);
-            }
-            newS.properties = properties;
-        }
-    }
-    else if (typeof t !== "string" && `str` in t) {
-        newS.type = "string";
-        if (t.str) {
-            newS.originalType = "enum";
-            newS.enum = t.str;
-        }
-        else if (oldS.originalType == "string" && oldS.enum) {
-            newS.originalType = "string";
-            newS.enum = oldS.enum;
-        }
-        else {
-            newS.originalType = "string";
-            newS.enum = undefined;
-        }
-    }
-    else if (typeof t !== "string" && `resource` in t) {
-        newS.type = "object";
-        newS.format = `resource-${t.resource}`;
-    }
-    else if (typeof t !== "string" && `dynselect` in t) {
-        newS.type = "object";
-        newS.format = `dynselect-${t.dynselect}`;
-    }
-    else if (typeof t !== "string" && `list` in t) {
-        newS.type = "array";
-        if (t.list === "int" || t.list === "float") {
-            newS.items = { type: "number" };
-            newS.originalType = "number[]";
-        }
-        else if (t.list === "bytes") {
-            newS.items = { type: "string", contentEncoding: "base64" };
-            newS.originalType = "bytes[]";
-        }
-        else if (t.list &&
-            typeof t.list == "object" &&
-            "str" in t.list &&
-            t.list.str) {
-            newS.items = { type: "string", enum: t.list.str };
-            newS.originalType = "enum[]";
-        }
-        else if (t.list == "string" ||
-            (t.list && typeof t.list == "object" && "str" in t.list)) {
-            newS.items = { type: "string", enum: oldS.items?.enum };
-            newS.originalType = "string[]";
-        }
-        else if (t.list &&
-            typeof t.list == "object" &&
-            "resource" in t.list &&
-            t.list.resource) {
-            newS.items = {
-                type: "resource",
-                resourceType: t.list.resource,
-            };
-            newS.originalType = "resource[]";
-        }
-        else if (t.list &&
-            typeof t.list == "object" &&
-            "object" in t.list &&
-            t.list.object) {
-            if (t.list.object.name) {
-                newS.format = `resource-${t.list.object.name}`;
-            }
-            if (t.list.object.props && t.list.object.props.length > 0) {
-                const properties = {};
-                for (const prop of t.list.object.props) {
-                    properties[prop.key] = { description: "", type: "" };
-                    argSigToJsonSchemaType(prop.typ, properties[prop.key]);
-                }
-                newS.items = { type: "object", properties: properties };
-            }
-            else {
-                newS.items = { type: "object" };
-            }
-            newS.originalType = "record[]";
-        }
-        else {
-            newS.items = { type: "object" };
-            newS.originalType = "object[]";
-        }
-    }
-    else {
-        newS.type = "object";
-    }
-    const preservedFields = [
-        "description",
-        "pattern",
-        "min",
-        "max",
-        "currency",
-        "currencyLocale",
-        "multiselect",
-        "customErrorMessage",
-        "required",
-        "showExpr",
-        "password",
-        "order",
-        "dateFormat",
-        "title",
-        "placeholder",
-    ];
-    preservedFields.forEach((field) => {
-        // @ts-ignore
-        if (oldS[field] !== undefined) {
-            // @ts-ignore
-            newS[field] = oldS[field];
-        }
-    });
-    if (oldS.type != newS.type) {
-        for (const prop of Object.getOwnPropertyNames(newS)) {
-            if (prop != "description") {
-                // @ts-ignore
-                delete oldS[prop];
-            }
-        }
-    }
-    else if ((oldS.format == "date" || oldS.format === "date-time") &&
-        newS.format == "string") {
-        newS.format = oldS.format;
-    }
-    else if (newS.format == "date-time" && oldS.format == "date") {
-        newS.format = "date";
-    }
-    else if (oldS.items?.type != newS.items?.type) {
-        delete oldS.items;
-    }
-    if (oldS.format && !newS.format) {
-        oldS.format = undefined;
-    }
-    Object.assign(oldS, newS);
-    // if (sameItems && savedItems != undefined && savedItems.enum != undefined) {
-    // 	sendUserToast(JSON.stringify(savedItems))
-    // 	oldS.items = savedItems
-    // }
-}
 ////////////////////////////////////////////////////////////////////////////////////////////
 // end of refactoring TODO                                                                //
 ////////////////////////////////////////////////////////////////////////////////////////////
@@ -770,12 +562,20 @@ export async function readLockfile() {
         }
     }
     catch {
-        const lock = { locks: {} };
+        const lock = { locks: {}, version: "v2" };
         await dntShim.Deno.writeTextFile(WMILL_LOCKFILE, yamlStringify(lock, yamlOptions));
         log.info(colors.green("wmill-lock.yaml created"));
         return lock;
     }
 }
+function v2LockPath(path, subpath) {
+    if (subpath) {
+        return `${path}+${subpath}`;
+    }
+    else {
+        return path;
+    }
+}
 export async function checkifMetadataUptodate(path, hash, conf, subpath) {
     if (!conf) {
         conf = await readLockfile();
@@ -783,9 +583,16 @@ export async function checkifMetadataUptodate(path, hash, conf, subpath) {
     if (!conf.locks) {
         return false;
     }
-    const obj = conf.locks?.[path];
-    const current = subpath && typeof obj == "object" ? obj?.[subpath] : obj;
-    return current == hash;
+    const isV2 = conf?.version == "v2";
+    if (isV2) {
+        const current = conf.locks?.[v2LockPath(path, subpath)];
+        return current == hash;
+    }
+    else {
+        const obj = conf.locks?.[path];
+        const current = subpath && typeof obj == "object" ? obj?.[subpath] : obj;
+        return current == hash;
+    }
 }
 export async function generateScriptHash(rawReqs, scriptContent, newMetadataContent) {
     return await generateHash((rawReqs ?? "") + scriptContent + newMetadataContent);
@@ -795,16 +602,22 @@ export async function updateMetadataGlobalLock(path, hash, subpath) {
     if (!conf?.locks) {
         conf.locks = {};
     }
-    if (subpath) {
-        let prev = conf.locks[path];
-        if (!prev || typeof prev != "object") {
-            prev = {};
-            conf.locks[path] = prev;
-        }
-        prev[subpath] = hash;
+    const isV2 = conf?.version == "v2";
+    if (isV2) {
+        conf.locks[v2LockPath(path, hash)] = hash;
     }
     else {
-        conf.locks[path] = hash;
+        if (subpath) {
+            let prev = conf.locks[path];
+            if (!prev || typeof prev != "object") {
+                prev = {};
+                conf.locks[path] = prev;
+            }
+            prev[subpath] = hash;
+        }
+        else {
+            conf.locks[path] = hash;
+        }
     }
     await dntShim.Deno.writeTextFile(WMILL_LOCKFILE, yamlStringify(conf, yamlOptions));
 }