windmill-components 1.511.1 → 1.522.0

package/package/services/JobManager.d.ts

@@ -0,0 +1,28 @@
+export interface JobStatus {
+    status: 'running' | 'success' | 'failure';
+    result?: any;
+    error?: string;
+}
+export interface JobOptions {
+    onProgress?: (status: JobStatus) => void;
+    timeout?: number;
+    workspace: string;
+    interval?: number;
+    timeoutMessage?: string;
+}
+export declare class JobManager {
+    private activeJobs;
+    private cleanupInterval;
+    private readonly STALE_TIMEOUT;
+    private readonly CLEANUP_INTERVAL;
+    constructor();
+    private startCleanupTimer;
+    private cleanup;
+    runWithProgress<T>(jobRunner: () => Promise<string>, options: JobOptions): Promise<T>;
+    cancel(jobId: string): void;
+    cancelAll(): void;
+    isActive(jobId: string): boolean;
+    get activeJobCount(): number;
+    destroy(): void;
+}
+export declare const jobManager: JobManager;

package/package/services/JobManager.js

@@ -0,0 +1,114 @@
+import { JobService } from '../gen';
+import { tryEvery } from '../utils';
+export class JobManager {
+    activeJobs = new Map();
+    cleanupInterval = null;
+    STALE_TIMEOUT = 300000; // 5 minutes
+    CLEANUP_INTERVAL = 60000; // 1 minute
+    constructor() {
+        this.startCleanupTimer();
+    }
+    startCleanupTimer() {
+        if (typeof window !== 'undefined') {
+            this.cleanupInterval = setInterval(() => {
+                this.cleanup();
+            }, this.CLEANUP_INTERVAL);
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        const staleJobs = [];
+        for (const [jobId, entry] of this.activeJobs.entries()) {
+            if (now - entry.startTime > this.STALE_TIMEOUT) {
+                entry.controller.abort();
+                staleJobs.push(jobId);
+            }
+        }
+        staleJobs.forEach(jobId => {
+            this.activeJobs.delete(jobId);
+        });
+        if (staleJobs.length > 0) {
+            console.warn(`Cleaned up ${staleJobs.length} stale job controllers`);
+        }
+    }
+    async runWithProgress(jobRunner, options) {
+        const { onProgress, timeout = 60000, workspace, interval = 500, timeoutMessage = `Job timed out after ${timeout / 1000}s` } = options;
+        const controller = new AbortController();
+        const jobId = await jobRunner();
+        this.activeJobs.set(jobId, {
+            controller,
+            startTime: Date.now()
+        });
+        try {
+            onProgress?.({ status: 'running' });
+            const result = await tryEvery({
+                tryCode: async () => {
+                    if (controller.signal.aborted) {
+                        throw new Error('Job was cancelled');
+                    }
+                    const jobResult = await JobService.getCompletedJob({
+                        workspace,
+                        id: jobId
+                    });
+                    const success = !!jobResult.success;
+                    const status = {
+                        status: success ? 'success' : 'failure',
+                        result: jobResult.result,
+                        error: success ? undefined : jobResult.result?.error?.message || 'Job failed'
+                    };
+                    onProgress?.(status);
+                    if (!success) {
+                        throw new Error(status.error);
+                    }
+                    return jobResult.result;
+                },
+                timeoutCode: async () => {
+                    try {
+                        await JobService.cancelQueuedJob({
+                            workspace,
+                            id: jobId,
+                            requestBody: { reason: timeoutMessage }
+                        });
+                    }
+                    catch (err) {
+                        console.error('Failed to cancel job:', err);
+                    }
+                    onProgress?.({ status: 'failure', error: timeoutMessage });
+                    throw new Error(timeoutMessage);
+                },
+                interval,
+                timeout
+            });
+            return result;
+        }
+        finally {
+            this.activeJobs.delete(jobId);
+        }
+    }
+    cancel(jobId) {
+        const entry = this.activeJobs.get(jobId);
+        if (entry) {
+            entry.controller.abort();
+            this.activeJobs.delete(jobId);
+        }
+    }
+    cancelAll() {
+        this.activeJobs.forEach(entry => entry.controller.abort());
+        this.activeJobs.clear();
+    }
+    isActive(jobId) {
+        return this.activeJobs.has(jobId);
+    }
+    get activeJobCount() {
+        return this.activeJobs.size;
+    }
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.cancelAll();
+    }
+}
+// Singleton instance for global usage
+export const jobManager = new JobManager();

package/package/stores.d.ts

@@ -77,7 +77,7 @@ type SQLBaseSchema = {
 };
 export declare const SQLSchemaLanguages: readonly ["mysql", "bigquery", "postgresql", "snowflake", "mssql", "oracledb"];
 export interface SQLSchema {
-    lang: (typeof SQLSchemaLanguages)[number];
+    lang: (typeof SQLSchemaLanguages)[number] | 'ducklake';
     schema: SQLBaseSchema;
     publicOnly: boolean | undefined;
     stringified: string;

package/package/utils.d.ts

@@ -33,6 +33,7 @@ export declare function isJobCancelable(j: Job): boolean;
 export declare function isJobReRunnable(j: Job): boolean;
 export declare const WORKER_NAME_PREFIX = "wk";
 export declare function isJobSelectable(selectionType: RunsSelectionMode): (j: Job) => boolean;
+export declare function escapeHtml(unsafe: string): string;
 export declare function validateUsername(username: string): string;
 export declare function parseQueryParams(url: string | undefined): Record<string, string>;
 export declare function displayDateOnly(dateString: string | Date | undefined): string;
@@ -97,6 +98,21 @@ export declare function truncate(s: string, n: number, suffix?: string): string;
 export declare function truncateRev(s: string, n: number, prefix?: string): string;
 export declare function isString(value: any): value is string | String;
 export type InputCat = 'string' | 'email' | 'number' | 'boolean' | 'list' | 'resource-object' | 'enum' | 'date' | 'base64' | 'resource-string' | 'object' | 'sql' | 'yaml' | 'currency' | 'oneOf' | 'dynselect';
+export declare namespace DynamicSelect {
+    type HelperScript = {
+        type: 'inline';
+        path?: string;
+        lang: Script['language'];
+        code: string;
+    } | {
+        type: 'hash';
+        hash: string;
+    };
+    const generatePythonFnTemplate: (functionName: string) => string;
+    const generateJsFnTemplate: (functionName: string) => string;
+    const generateDefaultTemplateFn: (functionName: string, lang: ScriptLang) => string;
+    const getGenerateTemplateFn: (lang: ScriptLang) => (functionName: string) => string;
+}
 export declare function setInputCat(type: string | undefined, format: string | undefined, itemsType: string | undefined, enum_: any, contentEncoding: string | undefined): InputCat;
 export declare function formatCron(inp: string): string;
 export declare function scriptLangArrayToCommaList(languages: ScriptLang[]): string;
@@ -209,4 +225,5 @@ export declare function parseS3Object(s3Object: S3Object): {
 export declare function formatS3Object(s3Object: S3Object): S3Uri;
 export declare function isS3Uri(uri: string): uri is S3Uri;
 export declare function uniqueBy<T>(array: T[], key: (t: T) => any): T[];
-export declare function pruneNullishArrayWithSet<T>(array: (T | null | undefined)[]): T[];
+export declare function pruneNullishArray<T>(array: (T | null | undefined)[]): T[];
+export declare function assert(msg: string, condition: boolean, value?: any): void;

package/package/utils.js

@@ -82,6 +82,14 @@ export function isJobSelectable(selectionType) {
     }[selectionType];
     return f;
 }
+export function escapeHtml(unsafe) {
+    return unsafe
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}
 export function validateUsername(username) {
     if (username != '' && !/^[a-zA-Z]\w+$/.test(username)) {
         return 'username can only contain letters and numbers and must start with a letter';
@@ -474,6 +482,40 @@ export function truncateRev(s, n, prefix = '...') {
 export function isString(value) {
     return typeof value === 'string' || value instanceof String;
 }
+export var DynamicSelect;
+(function (DynamicSelect) {
+    DynamicSelect.generatePythonFnTemplate = (functionName) => {
+        return `
+def ${functionName}():
+    return [
+        { "label": "Foo", "value": "foo" },
+        { "label": "Bar", "value": "bar" }
+    ]
+
+`;
+    };
+    DynamicSelect.generateJsFnTemplate = (functionName) => {
+        return `
+// you can use filterText to filter the results from the backend
+// you can refer to other args directly as parameters (e.g. foobar: string)
+export function ${functionName}(filterText: string) {
+	return [
+		{ label: 'Foo', value: 'foo' },
+		{ label: 'Bar', value: 'bar' }
+	];
+}
+
+`;
+    };
+    DynamicSelect.generateDefaultTemplateFn = (functionName, lang) => {
+        return lang === 'bun'
+            ? DynamicSelect.generateJsFnTemplate(functionName)
+            : DynamicSelect.generatePythonFnTemplate(functionName);
+    };
+    DynamicSelect.getGenerateTemplateFn = (lang) => {
+        return lang === 'bun' ? DynamicSelect.generateJsFnTemplate : DynamicSelect.generatePythonFnTemplate;
+    };
+})(DynamicSelect || (DynamicSelect = {}));
 export function setInputCat(type, format, itemsType, enum_, contentEncoding) {
     if (type === 'number' || type === 'integer') {
         return 'number';
@@ -487,7 +529,8 @@ export function setInputCat(type, format, itemsType, enum_, contentEncoding) {
     else if (type == 'object' && format?.startsWith('resource')) {
         return 'resource-object';
     }
-    else if (type == 'object' && format?.startsWith('dynselect-')) {
+    else if (type == 'object' &&
+        (format?.startsWith('dynselect-') || format?.startsWith('dynselect_'))) {
         return 'dynselect';
     }
     else if (!type || type == 'object' || type == 'array') {
@@ -1236,6 +1279,16 @@ export function uniqueBy(array, key) {
         }
     });
 }
-export function pruneNullishArrayWithSet(array) {
+export function pruneNullishArray(array) {
     return array.filter((item) => item !== null && item !== undefined);
 }
+export function assert(msg, condition, value) {
+    if (!condition) {
+        let m = 'Assertion failed: ' + msg;
+        if (value)
+            m += '\nValue: ' + JSON.stringify(value, null, 2);
+        m += '\nPlease alert the Windmill team about this';
+        sendUserToast(m, true);
+        console.error(m);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "windmill-components",
-	"version": "1.511.1",
+	"version": "1.522.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",
@@ -147,11 +147,12 @@
 		"windmill-parser-wasm-nu": "1.510.1",
 		"windmill-parser-wasm-php": "1.510.1",
 		"windmill-parser-wasm-py": "1.510.1",
-		"windmill-parser-wasm-regex": "1.510.1",
+		"windmill-parser-wasm-regex": "1.512.0",
 		"windmill-parser-wasm-rust": "1.510.1",
-		"windmill-parser-wasm-ts": "1.510.1",
+		"windmill-parser-wasm-ts": "1.514.1",
 		"windmill-parser-wasm-yaml": "1.510.1",
-		"windmill-sql-datatype-parser-wasm": "1.318.0",
+		"windmill-sql-datatype-parser-wasm": "1.512.0",
+		"windmill-utils-internal": "^1.0.0",
 		"xterm": "^5.3.0",
 		"xterm-readline": "^1.1.2",
 		"y-monaco": "^0.1.4",