windmill-components 1.504.6 → 1.511.0

package/package/toast.js

@@ -1,6 +1,16 @@
 import Toast from './components/Toast.svelte';
 import { toast } from '@zerodevx/svelte-toast';
 export function sendUserToast(message, error = false, actions = [], errorMessage = undefined, duration = 5000) {
+    if (globalThis.windmillToast) {
+        globalThis.windmillToast({
+            message,
+            error,
+            actions,
+            errorMessage,
+            duration
+        });
+        return;
+    }
     toast.push({
         component: {
             // https://github.com/zerodevx/svelte-toast/issues/115

package/package/utils.d.ts

@@ -32,12 +32,11 @@ export declare namespace OpenApi {
 export declare function isJobCancelable(j: Job): boolean;
 export declare function isJobReRunnable(j: Job): boolean;
 export declare const WORKER_NAME_PREFIX = "wk";
-export declare const AGENT_WORKER_NAME_PREFIX = "ag";
-export declare function isAgentWorkerShell(workerName: string): boolean;
 export declare function isJobSelectable(selectionType: RunsSelectionMode): (j: Job) => boolean;
 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;
+export declare function retrieveCommonWorkerPrefix(workerName: string): string;
 export declare function subtractDaysFromDateString(dateString: string | undefined, days: number): string | undefined;
 export declare function displayDate(dateString: string | Date | undefined, displaySecond?: boolean, displayDate?: boolean): string;
 export declare function displayTime(dateString: string | Date | undefined): string;
@@ -209,3 +208,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[];

package/package/utils.js

@@ -75,11 +75,6 @@ export function isJobReRunnable(j) {
     return (j.job_kind === 'script' || j.job_kind === 'flow') && j.parent_job === undefined;
 }
 export const WORKER_NAME_PREFIX = 'wk';
-export const AGENT_WORKER_NAME_PREFIX = 'ag';
-const SSH_AGENT_WORKER_SUFFIX = '/ssh';
-export function isAgentWorkerShell(workerName) {
-    return (workerName.startsWith(AGENT_WORKER_NAME_PREFIX) && workerName.endsWith(SSH_AGENT_WORKER_SUFFIX));
-}
 export function isJobSelectable(selectionType) {
     const f = {
         cancel: isJobCancelable,
@@ -122,6 +117,10 @@ export function displayDateOnly(dateString) {
         });
     }
 }
+export function retrieveCommonWorkerPrefix(workerName) {
+    const lastDashIndex = workerName.lastIndexOf('-');
+    return workerName.substring(0, lastDashIndex);
+}
 export function subtractDaysFromDateString(dateString, days) {
     if (dateString == undefined) {
         return undefined;
@@ -1224,3 +1223,19 @@ export function isS3Uri(uri) {
     const match = uri.match(/^s3:\/\/([^/]*)\/(.*)$/);
     return !!match && match.length === 3;
 }
+export function uniqueBy(array, key) {
+    const seen = new Set();
+    return array.filter((item) => {
+        const value = key(item);
+        if (seen.has(value)) {
+            return false;
+        }
+        else {
+            seen.add(value);
+            return true;
+        }
+    });
+}
+export function pruneNullishArrayWithSet(array) {
+    return array.filter((item) => item !== null && item !== undefined);
+}

package/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "windmill-components",
-	"version": "1.504.6",
+	"version": "1.511.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",
 		"preview": "vite preview",
-		"postinstall": "if [ -f ./scripts/untar_ui_builder.js ]; then node ./scripts/untar_ui_builder.js && node ./scripts/patch_files.js; fi",
+		"postinstall": "node -e \"if (require('fs').existsSync('./scripts/untar_ui_builder.js')) { require('child_process').execSync('node ./scripts/untar_ui_builder.js && node ./scripts/patch_files.js', {stdio: 'inherit'}) }\"",
 		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --threshold warning",
 		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
 		"lint": "prettier --ignore-path .gitignore --check --plugin-search-dir=. . && eslint --ignore-path .gitignore .",
@@ -146,10 +146,10 @@
 		"windmill-parser-wasm-java": "^1.478.1",
 		"windmill-parser-wasm-nu": "^1.474.1",
 		"windmill-parser-wasm-php": "^1.429.0",
-		"windmill-parser-wasm-py": "^1.504.0",
-		"windmill-parser-wasm-regex": "^1.504.0",
+		"windmill-parser-wasm-py": "^1.510.0",
+		"windmill-parser-wasm-regex": "^1.510.0",
 		"windmill-parser-wasm-rust": "^1.429.0",
-		"windmill-parser-wasm-ts": "^1.504.0",
+		"windmill-parser-wasm-ts": "^1.510.0",
 		"windmill-parser-wasm-yaml": "^1.429.0",
 		"windmill-sql-datatype-parser-wasm": "^1.318.0",
 		"xterm": "^5.3.0",
@@ -180,10 +180,10 @@
 			"types": "./package/components/scriptBuilder.d.ts",
 			"default": "./package/components/scriptBuilder.js"
 		},
-		"./components/TestJobLoader.svelte": {
-			"types": "./package/components/TestJobLoader.svelte.d.ts",
-			"svelte": "./package/components/TestJobLoader.svelte",
-			"default": "./package/components/TestJobLoader.svelte"
+		"./components/JobLoader.svelte": {
+			"types": "./package/components/JobLoader.svelte.d.ts",
+			"svelte": "./package/components/JobLoader.svelte",
+			"default": "./package/components/JobLoader.svelte"
 		},
 		"./components/common/kbd/Kbd.svelte": {
 			"types": "./package/components/common/kbd/Kbd.svelte.d.ts",
@@ -404,8 +404,8 @@
 			"components/IconedResourceType.svelte": [
 				"./package/components/IconedResourceType.svelte.d.ts"
 			],
-			"components/TestJobLoader.svelte": [
-				"./package/components/TestJobLoader.svelte.d.ts"
+			"components/JobLoader.svelte": [
+				"./package/components/JobLoader.svelte.d.ts"
 			],
 			"components/SchemaForm.svelte": [
 				"./package/components/SchemaForm.svelte.d.ts"

package/package/components/ResultJobLoader.svelte

@@ -1,219 +0,0 @@
-<script lang="ts">import { JobService } from '../gen';
-import { workspaceStore } from '../stores';
-import { onDestroy, tick, untrack } from 'svelte';
-import { createEventDispatcher } from 'svelte';
-let { isLoading = $bindable(false), job = $bindable(undefined), workspaceOverride = undefined, notfound = $bindable(false), isEditor = false, allowConcurentRequests = false } = $props();
-const dispatch = createEventDispatcher();
-let workspace = $derived(workspaceOverride ?? $workspaceStore);
-let syncIteration = 0;
-let errorIteration = 0;
-let ITERATIONS_BEFORE_SLOW_REFRESH = 10;
-let ITERATIONS_BEFORE_SUPER_SLOW_REFRESH = 100;
-let lastStartedAt = Date.now();
-let currentId = $state(undefined);
-$effect(() => {
-    let newIsLoading = currentId !== undefined;
-    untrack(() => {
-        if (isLoading !== newIsLoading) {
-            isLoading = newIsLoading;
-        }
-    });
-});
-let running = false;
-let lastCallbacks = undefined;
-let finished = [];
-export async function abstractRun(fn, callbacks) {
-    try {
-        running = false;
-        isLoading = true;
-        clearCurrentJob();
-        const startedAt = Date.now();
-        const testId = await fn();
-        lastCallbacks = callbacks;
-        if (lastStartedAt < startedAt || allowConcurentRequests) {
-            lastStartedAt = startedAt;
-            if (testId) {
-                dispatch('started', testId);
-                try {
-                    await watchJob(testId, callbacks);
-                }
-                catch (e) {
-                    callbacks?.cancel();
-                    dispatch('cancel', testId);
-                    if (currentId === testId) {
-                        currentId = undefined;
-                    }
-                }
-            }
-        }
-        return testId;
-    }
-    catch (err) {
-        callbacks?.error(err);
-        // if error happens on submitting the job, reset UI state so the user can try again
-        isLoading = false;
-        currentId = undefined;
-        job = undefined;
-        throw err;
-    }
-}
-export async function runScriptByPath(path, args, callbacks) {
-    return abstractRun(() => JobService.runScriptByPath({
-        workspace: workspace,
-        path: path,
-        requestBody: args,
-        skipPreprocessor: true
-    }), callbacks);
-}
-export async function runScriptByHash(hash, args, callbacks) {
-    return abstractRun(() => JobService.runScriptByHash({
-        workspace: workspace,
-        hash: hash,
-        requestBody: args,
-        skipPreprocessor: true
-    }), callbacks);
-}
-export async function runFlowByPath(path, args, callbacks) {
-    return abstractRun(() => JobService.runFlowByPath({
-        workspace: workspace,
-        path: path ?? '',
-        requestBody: args,
-        skipPreprocessor: true
-    }), callbacks);
-}
-export async function runPreview(path, code, lang, args, tag, callbacks) {
-    return abstractRun(() => JobService.runScriptPreview({
-        workspace: workspace,
-        requestBody: {
-            path,
-            content: code,
-            args,
-            language: lang,
-            tag
-        }
-    }), callbacks);
-}
-export async function cancelJob() {
-    const id = currentId;
-    if (id) {
-        lastCallbacks?.cancel();
-        lastCallbacks = undefined;
-        dispatch('cancel', id);
-        currentId = undefined;
-        try {
-            await JobService.cancelQueuedJob({
-                workspace: workspace ?? '',
-                id,
-                requestBody: {}
-            });
-        }
-        catch (err) {
-            console.error(err);
-        }
-    }
-}
-export async function clearCurrentJob() {
-    if (currentId && !allowConcurentRequests) {
-        lastCallbacks?.cancel();
-        dispatch('cancel', currentId);
-        lastCallbacks = undefined;
-        job = undefined;
-        await cancelJob();
-    }
-}
-export async function watchJob(testId, callbacks) {
-    syncIteration = 0;
-    errorIteration = 0;
-    currentId = testId;
-    job = undefined;
-    const isCompleted = await loadTestJob(testId, callbacks);
-    if (!isCompleted) {
-        setTimeout(() => {
-            syncer(testId, callbacks);
-        }, 50);
-    }
-}
-async function loadTestJob(id, callbacks) {
-    let isCompleted = false;
-    if (currentId === id || allowConcurentRequests) {
-        try {
-            let maybe_job = await JobService.getCompletedJobResultMaybe({
-                workspace: workspace ?? '',
-                id,
-                getStarted: isEditor
-            });
-            if (maybe_job.started && !running) {
-                running = true;
-                dispatch('running', id);
-            }
-            if (maybe_job.completed) {
-                isCompleted = true;
-                if (currentId === id || allowConcurentRequests) {
-                    job = { ...maybe_job, id };
-                    await tick();
-                    if (!job?.success && typeof job?.result == 'object' && 'error' in (job?.result ?? {})) {
-                        callbacks?.error(job.result.error);
-                        dispatch('doneError', {
-                            id,
-                            error: job.result.error
-                        });
-                    }
-                    else {
-                        callbacks?.done(job.result);
-                        dispatch('done', job);
-                    }
-                    finished.push(id);
-                    if (!allowConcurentRequests) {
-                        currentId = undefined;
-                    }
-                }
-                else {
-                    callbacks?.cancel();
-                    dispatch('cancel', id);
-                }
-            }
-            notfound = false;
-        }
-        catch (err) {
-            errorIteration += 1;
-            if (errorIteration == 5) {
-                notfound = true;
-                await clearCurrentJob();
-                dispatch('doneError', err);
-            }
-            console.warn(err);
-        }
-        return isCompleted;
-    }
-    else {
-        callbacks?.cancel();
-        dispatch('cancel', id);
-        return true;
-    }
-}
-async function syncer(id, callbacks) {
-    if ((currentId != id && !allowConcurentRequests) || finished.includes(id)) {
-        callbacks?.cancel();
-        dispatch('cancel', id);
-        return;
-    }
-    syncIteration++;
-    let r = await loadTestJob(id, callbacks);
-    if (r) {
-        return;
-    }
-    let nextIteration = 50;
-    if (syncIteration > ITERATIONS_BEFORE_SLOW_REFRESH) {
-        nextIteration = 500;
-    }
-    else if (syncIteration > ITERATIONS_BEFORE_SUPER_SLOW_REFRESH) {
-        nextIteration = 2000;
-    }
-    setTimeout(() => {
-        syncer(id, callbacks);
-    }, nextIteration);
-}
-onDestroy(async () => {
-    currentId = undefined;
-});
-</script>

package/package/components/ResultJobLoader.svelte.d.ts

@@ -1,52 +0,0 @@
-import type { SupportedLanguage } from '../common';
-interface Props {
-    isLoading?: boolean;
-    job?: {
-        completed: boolean;
-        result: any;
-        id: string;
-        success?: boolean;
-    } | undefined;
-    workspaceOverride?: string | undefined;
-    notfound?: boolean;
-    isEditor?: boolean;
-    allowConcurentRequests?: boolean;
-}
-type Callbacks = {
-    done: (x: any) => void;
-    cancel: () => void;
-    error: (err: Error) => void;
-};
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const ResultJobLoader: $$__sveltets_2_IsomorphicComponent<Props, {
-    started: CustomEvent<any>;
-    cancel: CustomEvent<any>;
-    running: CustomEvent<any>;
-    doneError: CustomEvent<any>;
-    done: CustomEvent<any>;
-} & {
-    [evt: string]: CustomEvent<any>;
-}, {}, {
-    abstractRun: (fn: () => Promise<string>, callbacks?: Callbacks) => Promise<string>;
-    runScriptByPath: (path: string, args: Record<string, any>, callbacks?: Callbacks) => Promise<string>;
-    runScriptByHash: (hash: string, args: Record<string, any>, callbacks?: Callbacks) => Promise<string>;
-    runFlowByPath: (path: string | undefined, args: Record<string, any>, callbacks?: Callbacks) => Promise<string>;
-    runPreview: (path: string | undefined, code: string, lang: SupportedLanguage, args: Record<string, any>, tag: string | undefined, callbacks?: Callbacks) => Promise<string>;
-    cancelJob: () => Promise<void>;
-    clearCurrentJob: () => Promise<void>;
-    watchJob: (testId: string, callbacks?: Callbacks) => Promise<void>;
-}, "job" | "isLoading" | "notfound">;
-type ResultJobLoader = InstanceType<typeof ResultJobLoader>;
-export default ResultJobLoader;

package/package/components/TestJobLoader.svelte

@@ -1,274 +0,0 @@
-<script lang="ts">import { JobService } from '../gen';
-import { workspaceStore } from '../stores';
-import { onDestroy, tick, untrack } from 'svelte';
-import { createEventDispatcher } from 'svelte';
-import { sendUserToast } from '../toast';
-import { isScriptPreview } from '../utils';
-let { isLoading = $bindable(false), job = $bindable(undefined), workspaceOverride = undefined, notfound = $bindable(false), jobUpdateLastFetch = $bindable(undefined), toastError = false, lazyLogs = false, scriptProgress = $bindable(undefined), children } = $props();
-/// Last time asked for job progress
-let lastTimeCheckedProgress = undefined;
-/// Will try to poll progress every 5s and if once progress returned was not undefined, will be ignored
-/// and getProgressRate will be used instead
-const getProgressRetryRate = 5000;
-/// How often loader poll progress
-const getProgressRate = 1000;
-const dispatch = createEventDispatcher();
-let workspace = $derived(workspaceOverride ?? $workspaceStore);
-let syncIteration = 0;
-let errorIteration = 0;
-let logOffset = 0;
-let ITERATIONS_BEFORE_SLOW_REFRESH = 10;
-let ITERATIONS_BEFORE_SUPER_SLOW_REFRESH = 100;
-let lastStartedAt = Date.now();
-let currentId = $state(undefined);
-$effect(() => {
-    let newIsLoading = currentId !== undefined;
-    untrack(() => {
-        if (isLoading !== newIsLoading) {
-            isLoading = newIsLoading;
-        }
-    });
-});
-export async function abstractRun(fn) {
-    try {
-        isLoading = true;
-        clearCurrentJob();
-        const startedAt = Date.now();
-        const testId = await fn();
-        if (lastStartedAt < startedAt) {
-            lastStartedAt = startedAt;
-            if (testId) {
-                try {
-                    await watchJob(testId);
-                }
-                catch {
-                    if (currentId === testId) {
-                        currentId = undefined;
-                    }
-                }
-            }
-        }
-        return testId;
-    }
-    catch (err) {
-        if (toastError) {
-            sendUserToast(err.body, true);
-        }
-        // if error happens on submitting the job, reset UI state so the user can try again
-        isLoading = false;
-        currentId = undefined;
-        job = undefined;
-        throw err;
-    }
-}
-export async function runScriptByPath(path, args) {
-    return abstractRun(() => JobService.runScriptByPath({
-        workspace: $workspaceStore,
-        path: path ?? '',
-        requestBody: args,
-        skipPreprocessor: true
-    }));
-}
-export async function runFlowByPath(path, args) {
-    return abstractRun(() => JobService.runFlowByPath({
-        workspace: $workspaceStore,
-        path: path ?? '',
-        requestBody: args,
-        skipPreprocessor: true
-    }));
-}
-export async function getLogs() {
-    if (job) {
-        const getUpdate = await JobService.getJobUpdates({
-            workspace: workspace,
-            id: job.id,
-            running: `running` in job && job.running,
-            logOffset: job.logs?.length ?? 0
-        });
-        if ((job?.logs ?? '').length == 0) {
-            job.logs = getUpdate.new_logs ?? '';
-            logOffset = getUpdate.log_offset ?? 0;
-        }
-    }
-}
-export async function runPreview(path, code, lang, args, tag, lock, hash) {
-    // Reset in case we rerun job without reloading
-    scriptProgress = undefined;
-    lastTimeCheckedProgress = undefined;
-    return abstractRun(() => JobService.runScriptPreview({
-        workspace: $workspaceStore,
-        requestBody: {
-            path,
-            content: code,
-            args,
-            language: lang,
-            tag,
-            lock,
-            script_hash: hash
-        }
-    }));
-}
-export async function cancelJob() {
-    const id = currentId;
-    if (id) {
-        dispatch('cancel', id);
-        currentId = undefined;
-        try {
-            await JobService.cancelQueuedJob({
-                workspace: $workspaceStore ?? '',
-                id,
-                requestBody: {}
-            });
-        }
-        catch (err) {
-            console.error(err);
-        }
-    }
-}
-export async function clearCurrentJob() {
-    if (currentId) {
-        job = undefined;
-        await cancelJob();
-    }
-}
-export async function watchJob(testId) {
-    logOffset = 0;
-    syncIteration = 0;
-    errorIteration = 0;
-    currentId = testId;
-    job = undefined;
-    const isCompleted = await loadTestJob(testId);
-    if (!isCompleted) {
-        setTimeout(() => {
-            syncer(testId);
-        }, 50);
-    }
-}
-async function loadTestJob(id) {
-    let isCompleted = false;
-    if (currentId === id) {
-        try {
-            if (job && `running` in job) {
-                let getProgress = undefined;
-                // We only pull individual job progress this way
-                // Flow's progress we are getting from FlowStatusModule of flow job
-                if (job.job_kind == 'script' || isScriptPreview(job.job_kind)) {
-                    // First time, before running job, lastTimeCheckedProgress is always undefined
-                    if (lastTimeCheckedProgress) {
-                        const lastTimeCheckedMs = Date.now() - lastTimeCheckedProgress;
-                        // Ask for progress if the last time we asked is >5s OR the progress was once not undefined
-                        if (lastTimeCheckedMs > getProgressRetryRate ||
-                            (scriptProgress != undefined && lastTimeCheckedMs > getProgressRate)) {
-                            lastTimeCheckedProgress = Date.now();
-                            getProgress = true;
-                        }
-                    }
-                    else {
-                        // Make it think we asked for progress, but in reality we didnt. First 5s we want to wait without putting extra work on db
-                        // 99.99% of the jobs won't have progress be set so we have to do a balance between having low-latency for jobs that use it and job that don't
-                        // we would usually not care to have progress the first 5s and jobs that are less than 5s
-                        lastTimeCheckedProgress = Date.now();
-                    }
-                }
-                const offset = logOffset == 0 ? (job.logs?.length ? job.logs?.length + 1 : 0) : logOffset;
-                let previewJobUpdates = await JobService.getJobUpdates({
-                    workspace: workspace,
-                    id,
-                    running: job.running,
-                    logOffset: offset,
-                    getProgress: getProgress
-                });
-                // Clamp number between two values with the following line:
-                const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
-                if (previewJobUpdates.progress) {
-                    // Progress cannot go back and cannot be set to 100
-                    scriptProgress = clamp(previewJobUpdates.progress, scriptProgress ?? 0, 99);
-                }
-                if (previewJobUpdates.new_logs) {
-                    if (offset == 0) {
-                        job.logs = previewJobUpdates.new_logs ?? '';
-                    }
-                    else {
-                        job.logs = (job?.logs ?? '').concat(previewJobUpdates.new_logs);
-                    }
-                }
-                if (previewJobUpdates.log_offset) {
-                    logOffset = previewJobUpdates.log_offset ?? 0;
-                }
-                if (previewJobUpdates.flow_status) {
-                    job.flow_status = previewJobUpdates.flow_status;
-                }
-                if (previewJobUpdates.mem_peak && job) {
-                    job.mem_peak = previewJobUpdates.mem_peak;
-                }
-                if ((previewJobUpdates.running ?? false) || (previewJobUpdates.completed ?? false)) {
-                    job = await JobService.getJob({ workspace: workspace, id });
-                }
-            }
-            else {
-                job = await JobService.getJob({ workspace: workspace, id, noLogs: lazyLogs });
-            }
-            jobUpdateLastFetch = new Date();
-            if (job?.type === 'CompletedJob') {
-                //only CompletedJob has success property
-                isCompleted = true;
-                if (currentId === id) {
-                    await tick();
-                    dispatch('done', job);
-                    currentId = undefined;
-                }
-            }
-            notfound = false;
-        }
-        catch (err) {
-            errorIteration += 1;
-            if (errorIteration == 5) {
-                notfound = true;
-                job = undefined;
-            }
-            console.warn(err);
-        }
-        return isCompleted;
-    }
-    else {
-        return true;
-    }
-}
-async function syncer(id) {
-    if (currentId != id) {
-        dispatch('cancel', id);
-        return;
-    }
-    syncIteration++;
-    if (await loadTestJob(id)) {
-        return;
-    }
-    let nextIteration = 50;
-    if (syncIteration > ITERATIONS_BEFORE_SLOW_REFRESH) {
-        nextIteration = 500;
-    }
-    else if (syncIteration > ITERATIONS_BEFORE_SUPER_SLOW_REFRESH) {
-        nextIteration = 2000;
-    }
-    setTimeout(() => syncer(id), nextIteration);
-}
-onDestroy(async () => {
-    currentId = undefined;
-});
-</script>
-
-{@render children?.({
-	job,
-	isLoading,
-	workspaceOverride,
-	notfound,
-	abstractRun,
-	runScriptByPath,
-	runFlowByPath,
-	runPreview,
-	cancelJob,
-	clearCurrentJob,
-	watchJob,
-	loadTestJob,
-	syncer
-})}