windmill-utils-internal 1.3.2 → 1.3.4

package/dist/esm/index.js

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Main entry point for windmill-utils-internal package
+ *
+ * This module provides utilities for handling Windmill flows, scripts, and schemas:
+ * - Inline script extraction and replacement
+ * - Path utilities for different programming languages
+ * - Schema parsing and conversion utilities
+ * - Cross-platform path constants
+ */
+export * from "./inline-scripts";
+export * from "./path-utils";
+export * from "./parse";
+export * from "./config";
+export { SEP, DELIMITER } from "./constants";

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

@@ -0,0 +1,41 @@
+import { PathAssigner } from "../path-utils/path-assigner";
+import { FlowModule } from "../gen/types.gen";
+/**
+ * Represents an inline script extracted from a flow module
+ */
+interface InlineScript {
+    /** File path where the script content should be written */
+    path: string;
+    /** The actual script content */
+    content: string;
+}
+/**
+ * Options for extractInlineScripts function
+ */
+export interface ExtractInlineScriptsOptions {
+    /** When true, skip the .inline_script. suffix in file names */
+    skipInlineScriptSuffix?: boolean;
+}
+/**
+ * Extracts inline scripts from flow modules, converting them to separate files
+ * and replacing the original content with file references.
+ *
+ * @param modules - Array of flow modules to process
+ * @param mapping - Optional mapping of module IDs to custom file paths
+ * @param separator - Path separator to use
+ * @param defaultTs - Default TypeScript runtime to use ("bun" or "deno")
+ * @param pathAssigner - Optional path assigner to reuse (for nested calls)
+ * @param options - Optional configuration options
+ * @returns Array of inline scripts with their paths and content
+ */
+export declare function extractInlineScripts(modules: FlowModule[], mapping?: Record<string, string>, separator?: string, defaultTs?: "bun" | "deno", pathAssigner?: PathAssigner, options?: ExtractInlineScriptsOptions): InlineScript[];
+/**
+ * Extracts the current mapping of module IDs to file paths from flow modules
+ * by analyzing existing inline script references.
+ *
+ * @param modules - Array of flow modules to analyze (can be undefined)
+ * @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 {};

package/dist/{inline-scripts → esm/inline-scripts}/extractor.js

@@ -1,4 +1,18 @@
 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 content = rawscript.content;
+    const r = [{ path: path, content: content }];
+    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 });
+    }
+    return r;
+}
 /**
  * Extracts inline scripts from flow modules, converting them to separate files
  * and replacing the original content with file references.
@@ -16,18 +30,7 @@ export function extractInlineScripts(modules, mapping = {}, separator = "/", def
     const assigner = pathAssigner ?? newPathAssigner(defaultTs ?? "bun", { skipInlineScriptSuffix: options?.skipInlineScriptSuffix });
     return modules.flatMap((m) => {
         if (m.value.type == "rawscript") {
-            const [basePath, ext] = assigner.assignPath(m.summary, m.value.language);
-            const path = mapping[m.id] ?? basePath + ext;
-            const content = m.value.content;
-            const r = [{ path: path, content: content }];
-            m.value.content = "!inline " + path.replaceAll(separator, "/");
-            const lock = m.value.lock;
-            if (lock && lock != "") {
-                const lockPath = basePath + "lock";
-                m.value.lock = "!inline " + lockPath.replaceAll(separator, "/");
-                r.push({ path: lockPath, content: lock });
-            }
-            return r;
+            return extractRawscriptInline(m.id, m.summary, m.value, mapping, separator, assigner);
         }
         else if (m.value.type == "forloopflow") {
             return extractInlineScripts(m.value.modules, mapping, separator, defaultTs, assigner);
@@ -44,6 +47,16 @@ export function extractInlineScripts(modules, mapping = {}, separator = "/", def
                 ...extractInlineScripts(m.value.default, mapping, separator, defaultTs, assigner),
             ];
         }
+        else if (m.value.type == "aiagent") {
+            return (m.value.tools ?? []).flatMap((tool) => {
+                const toolValue = tool.value;
+                // Only process flowmodule tools with rawscript type
+                if (!toolValue || toolValue.tool_type !== 'flowmodule' || toolValue.type !== 'rawscript') {
+                    return [];
+                }
+                return extractRawscriptInline(tool.id, tool.summary, toolValue, mapping, separator, assigner);
+            });
+        }
         else {
             return [];
         }
@@ -81,6 +94,15 @@ export function extractCurrentMapping(modules, mapping = {}) {
             m.value.branches.forEach((b) => extractCurrentMapping(b.modules, mapping));
             extractCurrentMapping(m.value.default, mapping);
         }
+        else if (m.value.type === "aiagent") {
+            (m.value.tools ?? []).forEach((tool) => {
+                const toolValue = tool.value;
+                if (!toolValue || toolValue.tool_type !== 'flowmodule' || toolValue.type !== 'rawscript' || !toolValue.content || !toolValue.content.startsWith("!inline")) {
+                    return;
+                }
+                mapping[tool.id] = toolValue.content.trim().split(" ")[1];
+            });
+        }
     });
     return mapping;
 }

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

@@ -0,0 +1,2 @@
+export * from "./replacer";
+export * from "./extractor";

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

@@ -0,0 +1,16 @@
+import { FlowModule } from "../gen/types.gen";
+/**
+ * Replaces inline script references with actual file content from the filesystem.
+ * This function recursively processes all flow modules and their nested structures.
+ *
+ * @param modules - Array of flow modules to process
+ * @param fileReader - Function to read file content (typically fs.readFile or similar)
+ * @param logger - Optional logger object with info and error methods
+ * @param localPath - Base path for resolving relative file paths
+ * @param removeLocks - Optional array of paths for which to remove lock files
+ * @returns Promise that resolves when all inline scripts have been replaced
+ */
+export declare function replaceInlineScripts(modules: FlowModule[], fileReader: (path: string) => Promise<string>, logger: {
+    info: (message: string) => void;
+    error: (message: string) => void;
+} | undefined, localPath: string, separator?: string, removeLocks?: string[]): Promise<void>;

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

@@ -0,0 +1,85 @@
+async function replaceRawscriptInline(id, rawscript, fileReader, logger, separator, removeLocks) {
+    if (!rawscript.content || !rawscript.content.startsWith("!inline")) {
+        return;
+    }
+    const path = rawscript.content.split(" ")[1];
+    const pathSuffix = path.split(".").slice(1).join(".");
+    const newPath = id + "." + pathSuffix;
+    try {
+        rawscript.content = await fileReader(path);
+    }
+    catch {
+        logger.error(`Script file ${path} not found`);
+        try {
+            rawscript.content = await fileReader(newPath);
+        }
+        catch {
+            logger.error(`Script file ${newPath} not found`);
+        }
+    }
+    const lock = rawscript.lock;
+    if (removeLocks && removeLocks.includes(path)) {
+        rawscript.lock = undefined;
+    }
+    else if (lock &&
+        typeof lock === "string" &&
+        lock.trimStart().startsWith("!inline ")) {
+        const lockPath = lock.split(" ")[1];
+        try {
+            rawscript.lock = await fileReader(lockPath.replaceAll("/", separator));
+        }
+        catch {
+            logger.error(`Lock file ${lockPath} not found, treating as empty`);
+            rawscript.lock = "";
+        }
+    }
+}
+/**
+ * Replaces inline script references with actual file content from the filesystem.
+ * This function recursively processes all flow modules and their nested structures.
+ *
+ * @param modules - Array of flow modules to process
+ * @param fileReader - Function to read file content (typically fs.readFile or similar)
+ * @param logger - Optional logger object with info and error methods
+ * @param localPath - Base path for resolving relative file paths
+ * @param removeLocks - Optional array of paths for which to remove lock files
+ * @returns Promise that resolves when all inline scripts have been replaced
+ */
+export async function replaceInlineScripts(modules, fileReader, logger = {
+    info: () => { },
+    error: () => { },
+}, localPath, separator = "/", removeLocks) {
+    await Promise.all(modules.map(async (module) => {
+        if (!module.value) {
+            throw new Error(`Module value is undefined for module ${module.id}`);
+        }
+        if (module.value.type === "rawscript") {
+            await replaceRawscriptInline(module.id, module.value, fileReader, logger, separator, removeLocks);
+        }
+        else if (module.value.type === "forloopflow" || module.value.type === "whileloopflow") {
+            await replaceInlineScripts(module.value.modules, fileReader, logger, localPath, separator, removeLocks);
+        }
+        else if (module.value.type === "branchall") {
+            await Promise.all(module.value.branches.map(async (branch) => {
+                await replaceInlineScripts(branch.modules, fileReader, logger, localPath, separator, removeLocks);
+            }));
+        }
+        else if (module.value.type === "branchone") {
+            await Promise.all(module.value.branches.map(async (branch) => {
+                await replaceInlineScripts(branch.modules, fileReader, logger, localPath, separator, removeLocks);
+            }));
+            await replaceInlineScripts(module.value.default, fileReader, logger, localPath, separator, removeLocks);
+        }
+        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 !== "rawscript") {
+                    return;
+                }
+                await replaceRawscriptInline(tool.id, toolValue, fileReader, logger, separator, removeLocks);
+            }));
+        }
+    }));
+}

package/dist/esm/parse/index.js

@@ -0,0 +1 @@
+export * from "./parse-schema";

package/dist/esm/parse/parse-schema.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Type alias for enum values - can be an array of strings or undefined
+ */
+export type EnumType = string[] | {
+    label: string;
+    value: string;
+}[] | undefined;
+/**
+ * Represents a property in a JSON schema with various validation and display options
+ */
+export interface SchemaProperty {
+    type: string | undefined;
+    description?: string;
+    pattern?: string;
+    default?: any;
+    enum?: EnumType;
+    contentEncoding?: "base64" | "binary";
+    format?: string;
+    items?: {
+        type?: "string" | "number" | "bytes" | "object" | "resource";
+        contentEncoding?: "base64";
+        enum?: EnumType;
+        resourceType?: string;
+        properties?: {
+            [name: string]: SchemaProperty;
+        };
+    };
+    min?: number;
+    max?: number;
+    currency?: string;
+    currencyLocale?: string;
+    multiselect?: boolean;
+    customErrorMessage?: string;
+    properties?: {
+        [name: string]: SchemaProperty;
+    };
+    required?: string[];
+    showExpr?: string;
+    password?: boolean;
+    order?: string[];
+    nullable?: boolean;
+    dateFormat?: string;
+    title?: string;
+    placeholder?: string;
+    oneOf?: SchemaProperty[];
+    originalType?: string;
+}
+/**
+ * Converts argument signature types to JSON schema properties.
+ * This function handles various Windmill-specific types and converts them
+ * to standard JSON schema format while preserving existing property metadata.
+ *
+ * @param t - The argument signature type definition (can be string or complex object types)
+ * @param oldS - Existing schema property to update with new type information
+ */
+export declare function argSigToJsonSchemaType(t: string | {
+    resource: string | null;
+} | {
+    list: (string | {
+        name?: string;
+        props?: {
+            key: string;
+            typ: any;
+        }[];
+    }) | {
+        str: any;
+    } | {
+        object: {
+            name?: string;
+            props?: {
+                key: string;
+                typ: any;
+            }[];
+        };
+    } | null;
+} | {
+    dynselect: string;
+} | {
+    dynmultiselect: string;
+} | {
+    str: string[] | null;
+} | {
+    object: {
+        name?: string;
+        props?: {
+            key: string;
+            typ: any;
+        }[];
+    };
+} | {
+    oneof: {
+        label: string;
+        properties: {
+            key: string;
+            typ: any;
+        }[];
+    }[];
+}, oldS: SchemaProperty): void;

package/dist/{parse → 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/index.js

@@ -0,0 +1 @@
+export * from "./path-assigner";

package/dist/esm/path-utils/path-assigner.d.ts

@@ -0,0 +1,58 @@
+import { RawScript } from "../gen/types.gen";
+/**
+ * Union type of all supported programming languages in Windmill
+ */
+export type SupportedLanguage = RawScript["language"] | "frontend" | "bunnative" | "oracledb" | "rust" | "csharp" | "nu" | "ansible" | "java" | "duckdb";
+/**
+ * Mapping of supported languages to their file extensions
+ */
+export declare const LANGUAGE_EXTENSIONS: Record<SupportedLanguage, string>;
+/**
+ * Gets the appropriate file extension for a given programming language.
+ * Handles special cases for TypeScript variants based on the default runtime.
+ *
+ * @param language - The programming language to get extension for
+ * @param defaultTs - Default TypeScript runtime ("bun" or "deno")
+ * @returns File extension string (without the dot)
+ */
+export declare function getLanguageExtension(language: SupportedLanguage, defaultTs?: "bun" | "deno"): string;
+/**
+ * Reverse mapping from file extensions to languages.
+ * Used when deriving language from file extension.
+ */
+export declare const EXTENSION_TO_LANGUAGE: Record<string, SupportedLanguage>;
+/**
+ * Gets the language from a file extension.
+ *
+ * @param ext - File extension (e.g., "py", "ts", "bun.ts")
+ * @param defaultTs - Default TypeScript runtime for plain .ts files
+ * @returns The language, or undefined if not recognized
+ */
+export declare function getLanguageFromExtension(ext: string, defaultTs?: "bun" | "deno"): SupportedLanguage | undefined;
+export interface PathAssigner {
+    assignPath(summary: string | undefined, language: SupportedLanguage): [string, string];
+}
+export interface PathAssignerOptions {
+    defaultTs: "bun" | "deno";
+    /** When true, skip the .inline_script. suffix in file names */
+    skipInlineScriptSuffix?: boolean;
+}
+/**
+ * Creates a new path assigner for inline scripts.
+ *
+ * @param defaultTs - Default TypeScript runtime ("bun" or "deno")
+ * @param options - Optional configuration (can pass options object instead of defaultTs)
+ * @returns Path assigner function
+ */
+export declare function newPathAssigner(defaultTs: "bun" | "deno" | PathAssignerOptions, options?: {
+    skipInlineScriptSuffix?: boolean;
+}): PathAssigner;
+/**
+ * Creates a new path assigner for raw app runnables.
+ * Unlike newPathAssigner, this does NOT add ".inline_script." prefix since
+ * everything in raw_app/backend/ is already known to be for inline scripts.
+ *
+ * @param defaultTs - Default TypeScript runtime ("bun" or "deno")
+ * @returns Path assigner function
+ */
+export declare function newRawAppPathAssigner(defaultTs: "bun" | "deno"): PathAssigner;

package/dist/{path-utils → 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,12 +1,22 @@
 {
   "name": "windmill-utils-internal",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "Internal utility functions for Windmill",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "types": "./dist/esm/index.d.ts"
+    }
+  },
   "scripts": {
     "dev": "./gen_wm_client.sh && ./remove-ts-ext.sh",
-    "build": "./gen_wm_client.sh && ./remove-ts-ext.sh && tsc",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "./gen_wm_client.sh && ./remove-ts-ext.sh && npm run build:cjs && npm run build:esm",
     "prepublishOnly": "npm run build"
   },
   "keywords": [

package/dist/inline-scripts/replacer.js

@@ -1,93 +0,0 @@
-/**
- * Replaces inline script references with actual file content from the filesystem.
- * This function recursively processes all flow modules and their nested structures.
- *
- * @param modules - Array of flow modules to process
- * @param fileReader - Function to read file content (typically fs.readFile or similar)
- * @param logger - Optional logger object with info and error methods
- * @param localPath - Base path for resolving relative file paths
- * @param removeLocks - Optional array of paths for which to remove lock files
- * @returns Promise that resolves when all inline scripts have been replaced
- */
-export async function replaceInlineScripts(modules, fileReader, logger = {
-    info: () => { },
-    error: () => { },
-}, localPath, separator = "/", removeLocks) {
-    await Promise.all(modules.map(async (module) => {
-        if (!module.value) {
-            throw new Error(`Module value is undefined for module ${module.id}`);
-        }
-        if (module.value.type === "rawscript" && module.value.content && module.value.content.startsWith("!inline")) {
-            const path = module.value.content.split(" ")[1];
-            // const pathPrefix = path.split(".")[0];
-            const pathSuffix = path.split(".").slice(1).join(".");
-            // new path is the module id with the same suffix
-            const newPath = module.id + "." + pathSuffix;
-            try {
-                module.value.content = await fileReader(path);
-            }
-            catch {
-                logger.error(`Script file ${path} not found`);
-                // try new path
-                try {
-                    module.value.content = await fileReader(newPath);
-                }
-                catch {
-                    logger.error(`Script file ${newPath} not found`);
-                }
-            }
-            // rename the file if the prefix is different from the module id (fix old naming)
-            // if (pathPrefix != module.id && renamer) {
-            //   logger.info(`Renaming ${path} to ${module.id}.${pathSuffix}`);
-            //   try {
-            //     renamer(localPath + path, localPath + module.id + "." + pathSuffix);
-            //   } catch {
-            //     logger.info(`Failed to rename ${path} to ${module.id}.${pathSuffix}`);
-            //   }
-            // }
-            const lock = module.value.lock;
-            if (removeLocks && removeLocks.includes(path)) {
-                module.value.lock = undefined;
-                // delete the file if the prefix is different from the module id (fix old naming)
-                // if (lock && lock != "") {
-                //   const path = lock.split(" ")[1];
-                //   const pathPrefix = path.split(".")[0];
-                //   if (pathPrefix != module.id && deleter) {
-                //     logger.info(`Deleting ${path}`);
-                //     try {
-                //       deleter(localPath + path);
-                //     } catch {
-                //       logger.error(`Failed to delete ${path}`);
-                //     } 
-                //   }
-                // }
-            }
-            else if (lock &&
-                typeof lock == "string" &&
-                lock.trimStart().startsWith("!inline ")) {
-                const path = lock.split(" ")[1];
-                try {
-                    module.value.lock = await fileReader(path.replaceAll("/", separator));
-                }
-                catch {
-                    logger.error(`Lock file ${path} not found, treating as empty`);
-                    module.value.lock = "";
-                }
-            }
-        }
-        else if (module.value.type === "forloopflow" || module.value.type === "whileloopflow") {
-            await replaceInlineScripts(module.value.modules, fileReader, logger, localPath, separator, removeLocks);
-        }
-        else if (module.value.type === "branchall") {
-            await Promise.all(module.value.branches.map(async (branch) => {
-                await replaceInlineScripts(branch.modules, fileReader, logger, localPath, separator, removeLocks);
-            }));
-        }
-        else if (module.value.type === "branchone") {
-            await Promise.all(module.value.branches.map(async (branch) => {
-                await replaceInlineScripts(branch.modules, fileReader, logger, localPath, separator, removeLocks);
-            }));
-            await replaceInlineScripts(module.value.default, fileReader, logger, localPath, separator, removeLocks);
-        }
-    }));
-}