windmill-utils-internal 1.3.2 → 1.3.3

package/dist/cjs/gen/types.gen.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELIMITER = exports.SEP = void 0;
+__exportStar(require("./inline-scripts"), exports);
+__exportStar(require("./path-utils"), exports);
+__exportStar(require("./parse"), exports);
+__exportStar(require("./config"), exports);
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "SEP", { enumerable: true, get: function () { return constants_1.SEP; } });
+Object.defineProperty(exports, "DELIMITER", { enumerable: true, get: function () { return constants_1.DELIMITER; } });

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractInlineScripts = extractInlineScripts;
+exports.extractCurrentMapping = extractCurrentMapping;
+const path_assigner_1 = require("../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.
+ *
+ * @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
+ */
+function extractInlineScripts(modules, mapping = {}, separator = "/", defaultTs, pathAssigner, options) {
+    // Create pathAssigner only if not provided (top-level call), but reuse it for nested calls
+    const assigner = pathAssigner ?? (0, path_assigner_1.newPathAssigner)(defaultTs ?? "bun", { skipInlineScriptSuffix: options?.skipInlineScriptSuffix });
+    return modules.flatMap((m) => {
+        if (m.value.type == "rawscript") {
+            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);
+        }
+        else if (m.value.type == "branchall") {
+            return m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs, assigner));
+        }
+        else if (m.value.type == "whileloopflow") {
+            return extractInlineScripts(m.value.modules, mapping, separator, defaultTs, assigner);
+        }
+        else if (m.value.type == "branchone") {
+            return [
+                ...m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs, assigner)),
+                ...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 [];
+        }
+    });
+}
+/**
+ * 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
+ */
+function extractCurrentMapping(modules, mapping = {}) {
+    if (!modules || !Array.isArray(modules)) {
+        return mapping;
+    }
+    modules.forEach((m) => {
+        if (!m?.value?.type) {
+            return;
+        }
+        if (m.value.type === "rawscript") {
+            if (m.value.content && m.value.content.startsWith("!inline ")) {
+                mapping[m.id] = m.value.content.trim().split(" ")[1];
+            }
+        }
+        else if (m.value.type === "forloopflow" ||
+            m.value.type === "whileloopflow") {
+            extractCurrentMapping(m.value.modules, mapping);
+        }
+        else if (m.value.type === "branchall") {
+            m.value.branches.forEach((b) => extractCurrentMapping(b.modules, mapping));
+        }
+        else if (m.value.type === "branchone") {
+            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/cjs/inline-scripts/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./replacer"), exports);
+__exportStar(require("./extractor"), exports);

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceInlineScripts = replaceInlineScripts;
+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
+ */
+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/cjs/parse/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parse-schema"), exports);

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

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argSigToJsonSchemaType = argSigToJsonSchemaType;
+const ITEMS_PRESERVED_FIELDS = [
+    "properties",
+    "required",
+    "additionalProperties",
+    "enum",
+    "resourceType",
+    "contentEncoding",
+    "description",
+];
+/**
+ * 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
+ */
+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" && `dynmultiselect` in t) {
+        newS.type = "object";
+        newS.format = `dynmultiselect-${t.dynmultiselect}`;
+    }
+    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 {
+                // Preserve ALL user-defined fields when parser cannot infer structure
+                newS.items = { type: oldS.items?.type || "object" };
+                if (oldS.items && typeof oldS.items === "object") {
+                    ITEMS_PRESERVED_FIELDS.forEach((field) => {
+                        if (oldS.items && oldS.items[field] !== undefined) {
+                            newS.items[field] = oldS.items[field];
+                        }
+                    });
+                }
+            }
+            newS.originalType = "record[]";
+        }
+        else {
+            // Preserve ALL user-defined fields for untyped lists (same as record[] branch)
+            newS.items = { type: oldS.items?.type || "object" };
+            if (oldS.items && typeof oldS.items === "object") {
+                ITEMS_PRESERVED_FIELDS.forEach((field) => {
+                    if (oldS.items && oldS.items[field] !== undefined) {
+                        newS.items[field] = oldS.items[field];
+                    }
+                });
+            }
+            newS.originalType = "object[]";
+        }
+    }
+    else {
+        // Preserve existing type when inference fails, default to "object" for undefined/null
+        newS.type = oldS.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 (newS.format == "date" || newS.format == "date-time") {
+        newS.format = oldS.format;
+    }
+    else if (oldS.items?.type != newS.items?.type) {
+        delete oldS.items;
+    }
+    else if (oldS.type == "string" && oldS.format != undefined) {
+        newS.format = oldS.format;
+    }
+    if ((oldS.type != newS.type || newS.type != "string") &&
+        newS.format == undefined) {
+        oldS.format = undefined;
+    }
+    Object.assign(oldS, newS);
+}

package/dist/cjs/path-utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./path-assigner"), exports);