windmill-utils-internal 1.3.3 → 1.3.5

package/dist/esm/inline-scripts/extractor.d.ts

@@ -1,13 +1,16 @@
 import { PathAssigner } from "../path-utils/path-assigner";
-import { FlowModule } from "../gen/types.gen";
+import { FlowModule, ScriptLang } from "../gen/types.gen";
 /**
  * Represents an inline script extracted from a flow module
  */
-interface InlineScript {
+export interface InlineScript {
     /** File path where the script content should be written */
     path: string;
     /** The actual script content */
     content: string;
+    /** The script language */
+    language: ScriptLang;
+    is_lock: boolean;
 }
 /**
  * Options for extractInlineScripts function
@@ -37,5 +40,4 @@ export declare function extractInlineScripts(modules: FlowModule[], mapping?: Re
  * @param mapping - Existing mapping to extend (defaults to empty object)
  * @returns Record mapping module IDs to their corresponding file paths
  */
-export declare function extractCurrentMapping(modules: FlowModule[] | undefined, mapping?: Record<string, string>): Record<string, string>;
-export {};
+export declare function extractCurrentMapping(modules: FlowModule[] | undefined, mapping?: Record<string, string>, failureModule?: FlowModule, preprocessorModule?: FlowModule): Record<string, string>;

package/dist/esm/inline-scripts/extractor.js

@@ -2,14 +2,15 @@ import { newPathAssigner } from "../path-utils/path-assigner";
 function extractRawscriptInline(id, summary, rawscript, mapping, separator, assigner) {
     const [basePath, ext] = assigner.assignPath(summary ?? id, rawscript.language);
     const path = mapping[id] ?? basePath + ext;
+    const language = rawscript.language;
     const content = rawscript.content;
-    const r = [{ path: path, content: content }];
+    const r = [{ path: path, content: content, language, is_lock: false }];
     rawscript.content = "!inline " + path.replaceAll(separator, "/");
     const lock = rawscript.lock;
     if (lock && lock != "") {
         const lockPath = basePath + "lock";
         rawscript.lock = "!inline " + lockPath.replaceAll(separator, "/");
-        r.push({ path: lockPath, content: lock });
+        r.push({ path: lockPath, content: lock, language, is_lock: true });
     }
     return r;
 }
@@ -70,7 +71,13 @@ export function extractInlineScripts(modules, mapping = {}, separator = "/", def
  * @param mapping - Existing mapping to extend (defaults to empty object)
  * @returns Record mapping module IDs to their corresponding file paths
  */
-export function extractCurrentMapping(modules, mapping = {}) {
+export function extractCurrentMapping(modules, mapping = {}, failureModule, preprocessorModule) {
+    if (failureModule) {
+        extractCurrentMapping([failureModule], mapping);
+    }
+    if (preprocessorModule) {
+        extractCurrentMapping([preprocessorModule], mapping);
+    }
     if (!modules || !Array.isArray(modules)) {
         return mapping;
     }

package/dist/esm/inline-scripts/replacer.d.ts

@@ -1,4 +1,10 @@
-import { FlowModule } from "../gen/types.gen";
+import { FlowModule, FlowValue, RawScript } from "../gen/types.gen";
+export type LocalScriptInfo = {
+    content: string;
+    language: RawScript["language"];
+    lock?: string;
+    tag?: string;
+};
 /**
  * Replaces inline script references with actual file content from the filesystem.
  * This function recursively processes all flow modules and their nested structures.
@@ -14,3 +20,24 @@ export declare function replaceInlineScripts(modules: FlowModule[], fileReader:
     info: (message: string) => void;
     error: (message: string) => void;
 } | undefined, localPath: string, separator?: string, removeLocks?: string[]): Promise<void>;
+/**
+ * Replaces PathScript ("script" type) modules with RawScript ("rawscript" type) using local file content.
+ * This is used during flow preview so that local script changes are tested instead of remote versions.
+ *
+ * @param modules - Array of flow modules to process
+ * @param scriptReader - Function that takes a script path and returns local content/language/lock, or undefined if not found locally
+ * @param logger - Logger for info/error messages
+ */
+export declare function replacePathScriptsWithLocal(modules: FlowModule[], scriptReader: (scriptPath: string) => Promise<LocalScriptInfo | undefined>, logger?: {
+    info: (message: string) => void;
+    error: (message: string) => void;
+}): Promise<void>;
+/**
+ * Replaces all PathScript modules in a flow value (modules, failure_module, preprocessor_module)
+ * with RawScript using local file content.
+ */
+export declare function replaceAllPathScriptsWithLocal(flowValue: FlowValue, scriptReader: (scriptPath: string) => Promise<LocalScriptInfo | undefined>, logger?: {
+    info: (message: string) => void;
+    error: (message: string) => void;
+}): Promise<void>;
+export declare function collectPathScriptPaths(flowValue: FlowValue): string[];

package/dist/esm/inline-scripts/replacer.js

@@ -83,3 +83,134 @@ export async function replaceInlineScripts(modules, fileReader, logger = {
         }
     }));
 }
+/**
+ * Replaces PathScript ("script" type) modules with RawScript ("rawscript" type) using local file content.
+ * This is used during flow preview so that local script changes are tested instead of remote versions.
+ *
+ * @param modules - Array of flow modules to process
+ * @param scriptReader - Function that takes a script path and returns local content/language/lock, or undefined if not found locally
+ * @param logger - Logger for info/error messages
+ */
+export async function replacePathScriptsWithLocal(modules, scriptReader, logger = {
+    info: () => { },
+    error: () => { },
+}) {
+    await Promise.all(modules.map(async (module) => {
+        if (!module.value) {
+            return;
+        }
+        if (module.value.type === "script") {
+            const scriptPath = module.value.path;
+            const localScript = await scriptReader(scriptPath);
+            if (localScript) {
+                const pathScript = module.value;
+                module.value = {
+                    type: "rawscript",
+                    content: localScript.content,
+                    language: localScript.language,
+                    lock: localScript.lock,
+                    path: scriptPath,
+                    input_transforms: pathScript.input_transforms,
+                    tag: pathScript.tag_override ?? localScript.tag,
+                };
+            }
+        }
+        else if (module.value.type === "forloopflow" || module.value.type === "whileloopflow") {
+            await replacePathScriptsWithLocal(module.value.modules, scriptReader, logger);
+        }
+        else if (module.value.type === "branchall") {
+            await Promise.all(module.value.branches.map(async (branch) => {
+                await replacePathScriptsWithLocal(branch.modules, scriptReader, logger);
+            }));
+        }
+        else if (module.value.type === "branchone") {
+            await Promise.all(module.value.branches.map(async (branch) => {
+                await replacePathScriptsWithLocal(branch.modules, scriptReader, logger);
+            }));
+            await replacePathScriptsWithLocal(module.value.default, scriptReader, logger);
+        }
+        else if (module.value.type === "aiagent") {
+            await Promise.all((module.value.tools ?? []).map(async (tool) => {
+                const toolValue = tool.value;
+                if (!toolValue || toolValue.tool_type !== "flowmodule" || toolValue.type !== "script") {
+                    return;
+                }
+                const localScript = await scriptReader(toolValue.path);
+                if (localScript) {
+                    tool.value = {
+                        tool_type: "flowmodule",
+                        type: "rawscript",
+                        content: localScript.content,
+                        language: localScript.language,
+                        lock: localScript.lock,
+                        path: toolValue.path,
+                        input_transforms: toolValue.input_transforms,
+                        tag: toolValue.tag_override ?? localScript.tag,
+                    };
+                }
+            }));
+        }
+    }));
+}
+function collectPathScriptPathsFromModules(modules, paths) {
+    for (const module of modules) {
+        if (!module.value) {
+            continue;
+        }
+        if (module.value.type === "script") {
+            paths.add(module.value.path);
+        }
+        else if (module.value.type === "forloopflow" ||
+            module.value.type === "whileloopflow") {
+            collectPathScriptPathsFromModules(module.value.modules, paths);
+        }
+        else if (module.value.type === "branchall") {
+            for (const branch of module.value.branches) {
+                collectPathScriptPathsFromModules(branch.modules, paths);
+            }
+        }
+        else if (module.value.type === "branchone") {
+            for (const branch of module.value.branches) {
+                collectPathScriptPathsFromModules(branch.modules, paths);
+            }
+            collectPathScriptPathsFromModules(module.value.default, paths);
+        }
+        else if (module.value.type === "aiagent") {
+            for (const tool of module.value.tools ?? []) {
+                const toolValue = tool.value;
+                if (toolValue &&
+                    toolValue.tool_type === "flowmodule" &&
+                    toolValue.type === "script") {
+                    paths.add(toolValue.path);
+                }
+            }
+        }
+    }
+}
+/**
+ * Replaces all PathScript modules in a flow value (modules, failure_module, preprocessor_module)
+ * with RawScript using local file content.
+ */
+export async function replaceAllPathScriptsWithLocal(flowValue, scriptReader, logger = {
+    info: () => { },
+    error: () => { },
+}) {
+    await replacePathScriptsWithLocal(flowValue.modules, scriptReader, logger);
+    if (flowValue.failure_module) {
+        await replacePathScriptsWithLocal([flowValue.failure_module], scriptReader, logger);
+    }
+    if (flowValue.preprocessor_module) {
+        await replacePathScriptsWithLocal([flowValue.preprocessor_module], scriptReader, logger);
+    }
+}
+export function collectPathScriptPaths(flowValue) {
+    const paths = new Set();
+    collectPathScriptPathsFromModules(flowValue.modules, paths);
+    if (flowValue.failure_module) {
+        collectPathScriptPathsFromModules([flowValue.failure_module], paths);
+    }
+    if (flowValue.preprocessor_module) {
+        collectPathScriptPathsFromModules([flowValue.preprocessor_module], paths);
+    }
+    return [...paths];
+}

package/dist/esm/parse/parse-schema.js

@@ -47,6 +47,10 @@ export function argSigToJsonSchemaType(t, oldS) {
         newS.type = "string";
         newS.format = "date-time";
     }
+    else if (t === "date") {
+        newS.type = "string";
+        newS.format = "date";
+    }
     else if (typeof t !== "string" && "oneof" in t) {
         newS.type = "object";
         if (t.oneof) {

package/dist/esm/path-utils/path-assigner.js

@@ -26,6 +26,7 @@ export const LANGUAGE_EXTENSIONS = {
     java: "java",
     duckdb: "duckdb.sql",
     bunnative: "ts",
+    ruby: "rb",
     // for related places search: ADD_NEW_LANG
 };
 /**
@@ -69,6 +70,7 @@ export const EXTENSION_TO_LANGUAGE = {
     "playbook.yml": "ansible",
     "java": "java",
     "duckdb.sql": "duckdb",
+    "rb": "ruby",
     // Plain .ts defaults to bun (will be overridden by defaultTs setting)
     "ts": "bun",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-utils-internal",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Internal utility functions for Windmill",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -31,4 +31,4 @@
   "files": [
     "dist/**/*"
   ]
-}
+}