windmill-utils-internal 1.0.0 → 1.0.1

package/dist/config/config.d.ts

@@ -0,0 +1,11 @@
+export declare const WINDMILL_CONFIG_DIR = "windmill";
+export declare const WINDMILL_ACTIVE_WORKSPACE_FILE = "activeWorkspace";
+export declare const WINDMILL_WORKSPACE_CONFIG_FILE = "remotes.ndjson";
+export declare const INSTANCES_CONFIG_FILE = "instances.ndjson";
+export declare const WINDMILL_ACTIVE_INSTANCE_FILE = "activeInstance";
+export declare function getBaseConfigDir(configDirOverride?: string): Promise<string>;
+export declare function getConfigDirPath(configDirOverride?: string): Promise<string>;
+export declare function getWorkspaceConfigFilePath(configDirOverride?: string): Promise<string>;
+export declare function getActiveWorkspaceConfigFilePath(configDirOverride?: string): Promise<string>;
+export declare function getInstancesConfigFilePath(configDirOverride?: string): Promise<string>;
+export declare function getActiveInstanceFilePath(configDirOverride?: string): Promise<string>;

package/dist/config/config.js

@@ -0,0 +1,231 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WINDMILL_ACTIVE_INSTANCE_FILE = exports.INSTANCES_CONFIG_FILE = exports.WINDMILL_WORKSPACE_CONFIG_FILE = exports.WINDMILL_ACTIVE_WORKSPACE_FILE = exports.WINDMILL_CONFIG_DIR = void 0;
+exports.getBaseConfigDir = getBaseConfigDir;
+exports.getConfigDirPath = getConfigDirPath;
+exports.getWorkspaceConfigFilePath = getWorkspaceConfigFilePath;
+exports.getActiveWorkspaceConfigFilePath = getActiveWorkspaceConfigFilePath;
+exports.getInstancesConfigFilePath = getInstancesConfigFilePath;
+exports.getActiveInstanceFilePath = getActiveInstanceFilePath;
+// Runtime detection
+// @ts-ignore - Cross-platform runtime detection
+const isDeno = typeof Deno !== "undefined";
+// @ts-ignore - Cross-platform runtime detection  
+const isNode = typeof process !== "undefined" && process.versions?.node;
+exports.WINDMILL_CONFIG_DIR = "windmill";
+exports.WINDMILL_ACTIVE_WORKSPACE_FILE = "activeWorkspace";
+exports.WINDMILL_WORKSPACE_CONFIG_FILE = "remotes.ndjson";
+exports.INSTANCES_CONFIG_FILE = "instances.ndjson";
+exports.WINDMILL_ACTIVE_INSTANCE_FILE = "activeInstance";
+// Cross-platform environment variable access
+function getEnv(key) {
+    if (isDeno) {
+        // @ts-ignore - Deno API
+        return Deno.env.get(key);
+    }
+    else {
+        // @ts-ignore - Node API
+        return process.env[key];
+    }
+}
+// Cross-platform OS detection with normalization
+function getOS() {
+    if (isDeno) {
+        // @ts-ignore - Deno API
+        return Deno.build.os;
+    }
+    else if (isNode) {
+        // @ts-ignore - Node API
+        const platform = process.platform;
+        switch (platform) {
+            case "linux": return "linux";
+            case "darwin": return "darwin";
+            case "win32": return "windows"; // Normalize win32 to windows
+            default: return null;
+        }
+    }
+    return null;
+}
+// Cross-platform file system operations
+async function stat(path) {
+    if (isDeno) {
+        // @ts-ignore - Deno API
+        return await Deno.stat(path);
+    }
+    else {
+        // @ts-ignore - Node API
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        return await fs.stat(path);
+    }
+}
+async function mkdir(path, options) {
+    if (isDeno) {
+        // @ts-ignore - Deno API
+        await Deno.mkdir(path, options);
+    }
+    else {
+        // @ts-ignore - Node API
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        await fs.mkdir(path, options);
+    }
+}
+function throwIfNotDirectory(fileInfo) {
+    if (!fileInfo.isDirectory) {
+        throw new Error("Path is not a directory");
+    }
+}
+function config_dir() {
+    const os = getOS();
+    switch (os) {
+        case "linux": {
+            const xdg = getEnv("XDG_CONFIG_HOME");
+            if (xdg)
+                return xdg;
+            const home = getEnv("HOME");
+            if (home)
+                return `${home}/.config`;
+            break;
+        }
+        case "darwin": {
+            const home = getEnv("HOME");
+            if (home)
+                return `${home}/Library/Preferences`;
+            break;
+        }
+        case "windows":
+            return getEnv("APPDATA") ?? null;
+    }
+    return null;
+}
+function tmp_dir() {
+    const os = getOS();
+    switch (os) {
+        case "linux": {
+            const xdg = getEnv("XDG_RUNTIME_DIR");
+            if (xdg)
+                return `${xdg}-/tmp`;
+            const tmpDir = getEnv("TMPDIR");
+            if (tmpDir)
+                return tmpDir;
+            const tempDir = getEnv("TEMP");
+            if (tempDir)
+                return tempDir;
+            const tmp = getEnv("TMP");
+            if (tmp)
+                return tmp;
+            return "/var/tmp";
+        }
+        case "darwin":
+            return getEnv("TMPDIR") ?? null;
+        case "windows":
+            return getEnv("TMP") ?? getEnv("TEMP") ?? null;
+    }
+    return null;
+}
+async function ensureDir(dir) {
+    try {
+        const fileInfo = await stat(dir);
+        throwIfNotDirectory(fileInfo);
+        return;
+    }
+    catch (err) {
+        // Check for file not found error in cross-platform way
+        if (isDeno) {
+            // @ts-ignore - Deno API
+            if (!(err instanceof Deno.errors.NotFound)) {
+                throw err;
+            }
+        }
+        else {
+            // Node.js error codes
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+        }
+    }
+    // The dir doesn't exist. Create it.
+    // This can be racy. So we catch AlreadyExists and check stat again.
+    try {
+        await mkdir(dir, { recursive: true });
+    }
+    catch (err) {
+        // Check for already exists error in cross-platform way
+        if (isDeno) {
+            // @ts-ignore - Deno API
+            if (!(err instanceof Deno.errors.AlreadyExists)) {
+                throw err;
+            }
+        }
+        else {
+            // Node.js error codes
+            if (err.code !== 'EEXIST') {
+                throw err;
+            }
+        }
+        const fileInfo = await stat(dir);
+        throwIfNotDirectory(fileInfo);
+    }
+}
+async function getBaseConfigDir(configDirOverride) {
+    const baseDir = configDirOverride ??
+        getEnv("WMILL_CONFIG_DIR") ??
+        config_dir() ??
+        tmp_dir() ??
+        "/tmp/";
+    return baseDir;
+}
+async function getConfigDirPath(configDirOverride) {
+    const baseDir = await getBaseConfigDir(configDirOverride);
+    const store = baseDir + `/${exports.WINDMILL_CONFIG_DIR}/`;
+    await ensureDir(store);
+    return store;
+}
+async function getWorkspaceConfigFilePath(configDirOverride) {
+    const configDir = await getConfigDirPath(configDirOverride);
+    return `${configDir}/${exports.WINDMILL_WORKSPACE_CONFIG_FILE}`;
+}
+async function getActiveWorkspaceConfigFilePath(configDirOverride) {
+    const configDir = await getConfigDirPath(configDirOverride);
+    return `${configDir}/${exports.WINDMILL_ACTIVE_WORKSPACE_FILE}`;
+}
+async function getInstancesConfigFilePath(configDirOverride) {
+    const configDir = await getConfigDirPath(configDirOverride);
+    return `${configDir}/${exports.INSTANCES_CONFIG_FILE}`;
+}
+async function getActiveInstanceFilePath(configDirOverride) {
+    const configDir = await getConfigDirPath(configDirOverride);
+    return `${configDir}/${exports.WINDMILL_ACTIVE_INSTANCE_FILE}`;
+}

package/dist/config/index.d.ts

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

package/dist/config/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("./config"), exports);

package/dist/gen/core/OpenAPI.js

@@ -30,7 +30,7 @@ exports.OpenAPI = {
     PASSWORD: undefined,
     TOKEN: getEnv("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: '1.516.0',
+    VERSION: '1.518.2',
     WITH_CREDENTIALS: true,
     interceptors: {
         request: new Interceptors(),

package/dist/index.d.ts

@@ -10,4 +10,5 @@
 export * from "./inline-scripts";
 export * from "./path-utils";
 export * from "./parse";
+export * from "./config";
 export { SEP, DELIMITER } from "./constants";

package/dist/index.js

@@ -27,6 +27,7 @@ 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/inline-scripts/extractor.js

@@ -13,9 +13,11 @@ const path_assigner_1 = require("../path-utils/path-assigner");
  * @returns Array of inline scripts with their paths and content
  */
 function extractInlineScripts(modules, mapping = {}, separator = "/", defaultTs) {
+    const pathAssigner = (0, path_assigner_1.newPathAssigner)(defaultTs ?? "bun");
     return modules.flatMap((m) => {
         if (m.value.type == "rawscript") {
-            const [basePath, ext] = (0, path_assigner_1.assignPath)(m.id, m.value.language, defaultTs);
+            let basePath, ext;
+            [basePath, ext] = pathAssigner.assignPath(m.summary, m.value.language);
             const path = mapping[m.id] ?? basePath + ext;
             const content = m.value.content;
             const r = [{ path: path, content: content }];

package/dist/inline-scripts/replacer.js

@@ -40,32 +40,30 @@ async function replaceInlineScripts(modules, fileReader, logger = {
                 }
             }
             // 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}`);
-                }
-            }
+            // 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}`);
-                        }
-                    }
-                }
+                // 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" &&

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

@@ -16,13 +16,13 @@ export declare const LANGUAGE_EXTENSIONS: Record<SupportedLanguage, string>;
  * @returns File extension string (without the dot)
  */
 export declare function getLanguageExtension(language: SupportedLanguage, defaultTs?: "bun" | "deno"): string;
+export interface PathAssigner {
+    assignPath(summary: string | undefined, language: SupportedLanguage): [string, string];
+}
 /**
- * Assigns a file path for an inline script based on its ID and language.
- * Returns both the base path and extension as separate components.
+ * Creates a new path assigner for inline scripts.
  *
- * @param id - Unique identifier for the script
- * @param language - Programming language of the script
  * @param defaultTs - Default TypeScript runtime ("bun" or "deno")
- * @returns Tuple containing [basePath, extension]
+ * @returns Path assigner function
  */
-export declare function assignPath(id: string, language: SupportedLanguage, defaultTs?: "bun" | "deno"): [string, string];
+export declare function newPathAssigner(defaultTs: "bun" | "deno"): PathAssigner;

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

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LANGUAGE_EXTENSIONS = void 0;
 exports.getLanguageExtension = getLanguageExtension;
-exports.assignPath = assignPath;
+exports.newPathAssigner = newPathAssigner;
+const INLINE_SCRIPT_PREFIX = "inline_script";
 /**
  * Mapping of supported languages to their file extensions
  */
@@ -29,7 +30,8 @@ exports.LANGUAGE_EXTENSIONS = {
     ansible: "playbook.yml",
     java: "java",
     duckdb: "duckdb.sql",
-    bunnative: "ts"
+    bunnative: "ts",
+    // for related places search: ADD_NEW_LANG
 };
 /**
  * Gets the appropriate file extension for a given programming language.
@@ -46,15 +48,29 @@ function getLanguageExtension(language, defaultTs = "bun") {
     return exports.LANGUAGE_EXTENSIONS[language] || "no_ext";
 }
 /**
- * Assigns a file path for an inline script based on its ID and language.
- * Returns both the base path and extension as separate components.
+ * Creates a new path assigner for inline scripts.
  *
- * @param id - Unique identifier for the script
- * @param language - Programming language of the script
  * @param defaultTs - Default TypeScript runtime ("bun" or "deno")
- * @returns Tuple containing [basePath, extension]
+ * @returns Path assigner function
  */
-function assignPath(id, language, defaultTs = "bun") {
-    const ext = getLanguageExtension(language, defaultTs);
-    return [`${id}.inline_script.`, ext];
+function newPathAssigner(defaultTs) {
+    let counter = 0;
+    const seen_names = new Set();
+    function assignPath(summary, language) {
+        let name;
+        name = summary?.toLowerCase()?.replaceAll(" ", "_") ?? "";
+        let original_name = name;
+        if (name == "") {
+            original_name = INLINE_SCRIPT_PREFIX;
+            name = `${INLINE_SCRIPT_PREFIX}_0`;
+        }
+        while (seen_names.has(name)) {
+            counter++;
+            name = `${original_name}_${counter}`;
+        }
+        seen_names.add(name);
+        const ext = getLanguageExtension(language, defaultTs);
+        return [`${name}.inline_script.`, ext];
+    }
+    return { assignPath };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-utils-internal",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Internal utility functions for Windmill",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",