windmill-components 1.472.1 → 1.472.2

package/package/components/TemplateEditor.svelte.d.ts

@@ -0,0 +1,209 @@
+import { SvelteComponent } from "svelte";
+import '@codingame/monaco-vscode-standalone-languages';
+import '@codingame/monaco-vscode-standalone-typescript-language-features';
+declare const __propDef: {
+    props: {
+        [x: string]: any;
+        conf?: {
+            wordPattern: RegExp;
+            comments: {
+                lineComment: string;
+                blockComment: [string, string];
+            };
+            brackets: [string, string][];
+            onEnterRules: never[];
+            autoClosingPairs: ({
+                open: string;
+                close: string;
+                notIn?: undefined;
+            } | {
+                open: string;
+                close: string;
+                notIn: string[];
+            })[];
+            folding: {
+                markers: {
+                    start: RegExp;
+                    end: RegExp;
+                };
+            };
+        } | undefined;
+        language?: {
+            defaultToken: string;
+            tokenPostfix: string;
+            keywords: string[];
+            operators: string[];
+            symbols: RegExp;
+            escapes: RegExp;
+            digits: RegExp;
+            octaldigits: RegExp;
+            binarydigits: RegExp;
+            hexdigits: RegExp;
+            regexpctl: RegExp;
+            regexpesc: RegExp;
+            tokenizer: {
+                root: ((string | RegExp)[] | (RegExp | {
+                    token: string;
+                    next: string;
+                })[])[];
+                common: ((string | RegExp)[] | (RegExp | {
+                    cases: {
+                        '@keywords': string;
+                        '@default': string;
+                    };
+                })[] | {
+                    include: string;
+                } | (RegExp | {
+                    token: string;
+                    bracket: string;
+                    next: string;
+                })[] | (RegExp | {
+                    cases: {
+                        '@operators': string;
+                        '@default': string;
+                    };
+                })[])[];
+                whitespace: (string | RegExp)[][];
+                comment: (string | RegExp)[][];
+                jsdoc: (string | RegExp)[][];
+                regexp: ((string | RegExp)[] | (RegExp | (string | {
+                    token: string;
+                    next: string;
+                })[])[] | (RegExp | (string | {
+                    token: string;
+                    bracket: string;
+                    next: string;
+                })[])[])[];
+                regexrange: ((string | RegExp)[] | (RegExp | {
+                    token: string;
+                    next: string;
+                    bracket: string;
+                })[])[];
+                string_double: (string | RegExp)[][];
+                string_single: (string | RegExp)[][];
+                string_backtick: ((string | RegExp)[] | (RegExp | {
+                    token: string;
+                    next: string;
+                })[])[];
+                bracketCounting: ((string | RegExp)[] | {
+                    include: string;
+                })[];
+            };
+        } | undefined;
+        code?: string | undefined;
+        hash?: string | undefined;
+        automaticLayout?: boolean | undefined;
+        extraLib?: string | undefined;
+        autoHeight?: boolean | undefined;
+        fixedOverflowWidgets?: boolean | undefined;
+        fontSize?: number | undefined;
+        insertAtCursor?: ((code: string) => void) | undefined;
+        setCode?: ((ncode: string) => void) | undefined;
+        getCode?: (() => string) | undefined;
+        focus?: (() => void) | undefined;
+    };
+    events: {
+        focus: CustomEvent<any>;
+        change: CustomEvent<any>;
+        blur: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TemplateEditorProps = typeof __propDef.props;
+export type TemplateEditorEvents = typeof __propDef.events;
+export type TemplateEditorSlots = typeof __propDef.slots;
+export default class TemplateEditor extends SvelteComponent<TemplateEditorProps, TemplateEditorEvents, TemplateEditorSlots> {
+    get conf(): {
+        wordPattern: RegExp;
+        comments: {
+            lineComment: string;
+            blockComment: [string, string];
+        };
+        brackets: [string, string][];
+        onEnterRules: never[];
+        autoClosingPairs: ({
+            open: string;
+            close: string;
+            notIn?: undefined;
+        } | {
+            open: string;
+            close: string;
+            notIn: string[];
+        })[];
+        folding: {
+            markers: {
+                start: RegExp;
+                end: RegExp;
+            };
+        };
+    };
+    get language(): {
+        defaultToken: string;
+        tokenPostfix: string;
+        keywords: string[];
+        operators: string[];
+        symbols: RegExp;
+        escapes: RegExp;
+        digits: RegExp;
+        octaldigits: RegExp;
+        binarydigits: RegExp;
+        hexdigits: RegExp;
+        regexpctl: RegExp;
+        regexpesc: RegExp;
+        tokenizer: {
+            root: ((string | RegExp)[] | (RegExp | {
+                token: string;
+                next: string;
+            })[])[];
+            common: ((string | RegExp)[] | (RegExp | {
+                cases: {
+                    '@keywords': string;
+                    '@default': string;
+                };
+            })[] | {
+                include: string;
+            } | (RegExp | {
+                token: string;
+                bracket: string;
+                next: string;
+            })[] | (RegExp | {
+                cases: {
+                    '@operators': string;
+                    '@default': string;
+                };
+            })[])[];
+            whitespace: (string | RegExp)[][];
+            comment: (string | RegExp)[][];
+            jsdoc: (string | RegExp)[][];
+            regexp: ((string | RegExp)[] | (RegExp | (string | {
+                token: string;
+                next: string;
+            })[])[] | (RegExp | (string | {
+                token: string;
+                bracket: string;
+                next: string;
+            })[])[])[];
+            regexrange: ((string | RegExp)[] | (RegExp | {
+                token: string;
+                next: string;
+                bracket: string;
+            })[])[];
+            string_double: (string | RegExp)[][];
+            string_single: (string | RegExp)[][];
+            string_backtick: ((string | RegExp)[] | (RegExp | {
+                token: string;
+                next: string;
+            })[])[];
+            bracketCounting: ((string | RegExp)[] | {
+                include: string;
+            })[];
+        };
+    };
+    get insertAtCursor(): (code: string) => void;
+    get setCode(): (ncode: string) => void;
+    get getCode(): () => string;
+    get focus(): () => void;
+}
+export {};

package/package/components/TestConnection.svelte

@@ -0,0 +1,197 @@
+<script>import { JobService } from '../gen';
+import { Database, Loader2 } from 'lucide-svelte';
+import Button from './common/button/Button.svelte';
+import { sendUserToast } from '../toast';
+import { workspaceStore } from '../stores';
+import { tryEvery } from '../utils';
+export let workspaceOverride = undefined;
+export let resourceType;
+export let args = {};
+export let buttonTextOverride = undefined;
+const scripts = {
+    postgresql: {
+        code: `SELECT 1`,
+        lang: 'postgresql',
+        argName: 'database'
+    },
+    mysql: {
+        code: `SELECT 1`,
+        lang: 'mysql',
+        argName: 'database'
+    },
+    bigquery: {
+        code: `select 1`,
+        lang: 'bigquery',
+        argName: 'database'
+    },
+    snowflake: {
+        code: `select 1`,
+        lang: 'snowflake',
+        argName: 'database'
+    },
+    snowflake_oauth: {
+        code: `select 1`,
+        lang: 'snowflake',
+        argName: 'database'
+    },
+    ms_sql_server: {
+        code: `SELECT 1`,
+        lang: 'mssql',
+        argName: 'database'
+    },
+    oracledb: {
+        code: `SELECT 1 FROM DUAL`,
+        lang: 'oracledb',
+        argName: 'database'
+    },
+    s3: {
+        code: `
+import * as wmill from "windmill-client"
+
+type S3 = object
+
+export async function main(s3: S3) {
+	return fetch(process.env["BASE_URL"] + '/api/settings/test_object_storage_config', {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+			Authorization: 'Bearer ' + process.env["WM_TOKEN"],
+		},
+		body: JSON.stringify({
+			type: "S3",
+			region: s3.region,
+			bucket: s3.bucket,
+			endpoint: s3.endPoint,
+			port: s3.port,
+			allow_http: !s3.useSSL,
+			access_key: s3.accessKey,
+			secret_key: s3.secretKey,
+			path_style: s3.pathStyle,
+		}),
+	}).then(async (res) => {
+		if (!res.ok) {
+			throw new Error(await res.text())
+		}
+		return res.text()
+	})
+}
+`,
+        lang: 'bun',
+        argName: 's3'
+    },
+    graphql: {
+        code: '{ __typename }',
+        lang: 'graphql',
+        argName: 'api',
+        additionalCheck: (testResult) => {
+            if (testResult.success &&
+                (typeof testResult.result !== 'object' || !('__typename' in (testResult.result ?? {})))) {
+                return {
+                    ...testResult,
+                    result: {
+                        error: {
+                            message: 'Invalid GraphQL API response'
+                        }
+                    },
+                    success: false
+                };
+            }
+            else {
+                return testResult;
+            }
+        }
+    },
+    s3_bucket: {
+        code: `
+
+const process = require('process');
+
+export async function main(bucket: any) {
+	const req = await fetch(process.env.BASE_URL + '/api/settings/test_object_storage_config', {
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+			Authorization: 'Bearer ' + process.env.WM_TOKEN,
+		},
+		body: JSON.stringify(bucket),
+	});
+	if (!req.ok) {
+		throw new Error(await req.text());
+	}
+	return await req.text();
+}
+`,
+        lang: 'bun',
+        argName: 'bucket'
+    }
+};
+let loading = false;
+async function testConnection() {
+    if (!resourceType)
+        return;
+    loading = true;
+    const resourceScript = scripts[resourceType];
+    const job = await JobService.runScriptPreview({
+        workspace: workspaceOverride ?? $workspaceStore,
+        requestBody: {
+            path: `testConnection: ${resourceType}`,
+            language: resourceScript.lang,
+            content: resourceScript.code,
+            args: {
+                [resourceScript.argName]: args
+            }
+        }
+    });
+    tryEvery({
+        tryCode: async () => {
+            let testResult = await JobService.getCompletedJob({
+                workspace: workspaceOverride ?? $workspaceStore,
+                id: job
+            });
+            if (resourceScript.additionalCheck) {
+                testResult = resourceScript.additionalCheck(testResult);
+            }
+            loading = false;
+            sendUserToast(testResult.success
+                ? 'Connection successful'
+                : 'Connection error: ' + testResult.result?.['error']?.['message'], !testResult.success);
+        },
+        timeoutCode: async () => {
+            loading = false;
+            sendUserToast('Connection did not resolve after 5s or job did not start. Do you have native workers or a worker group listening to the proper tag available?', true);
+            try {
+                await JobService.cancelQueuedJob({
+                    workspace: workspaceOverride ?? $workspaceStore,
+                    id: job,
+                    requestBody: {
+                        reason: 'Connection did not resolve after 5s. Do you have native workers or a worker group listening to the proper tag available?'
+                    }
+                });
+            }
+            catch (err) {
+                console.error(err);
+            }
+        },
+        interval: 500,
+        timeout: 5000
+    });
+}
+</script>
+
+{#if Object.keys(scripts).includes(resourceType || '')}
+	<Button
+		spacingSize="sm"
+		size="xs"
+		btnClasses="h-8"
+		color="light"
+		variant="border"
+		on:click={testConnection}
+	>
+		{#if loading}
+			<Loader2 class="animate-spin mr-2 !h-4 !w-4" />
+		{:else}
+			<Database class="mr-2 !h-4 !w-4" />
+		{/if}
+		{buttonTextOverride ?? 'Test connection'}
+	</Button>
+{/if}

package/package/components/TestConnection.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        workspaceOverride?: string | undefined;
+        resourceType: string | undefined;
+        args?: Record<string, any> | any;
+        buttonTextOverride?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TestConnectionProps = typeof __propDef.props;
+export type TestConnectionEvents = typeof __propDef.events;
+export type TestConnectionSlots = typeof __propDef.slots;
+export default class TestConnection extends SvelteComponent<TestConnectionProps, TestConnectionEvents, TestConnectionSlots> {
+}
+export {};

package/package/components/TestJobLoader.svelte

@@ -0,0 +1,275 @@
+<script>import { JobService } from '../gen';
+import { workspaceStore } from '../stores';
+import { onDestroy, tick } from 'svelte';
+import { createEventDispatcher } from 'svelte';
+import { sendUserToast } from '../toast';
+import { isScriptPreview } from '../utils';
+export let isLoading = false;
+export let job = undefined;
+export let workspaceOverride = undefined;
+export let notfound = false;
+export let jobUpdateLastFetch = undefined;
+export let toastError = false;
+export let lazyLogs = false;
+// Will be set to number if job is not a flow
+// If you want to find out progress of subjobs of a flow, check job.flow_status.progress
+export let scriptProgress = undefined;
+/// 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();
+$: workspace = 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 = undefined;
+$: isLoading = currentId !== undefined;
+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) {
+    // 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
+        }
+    }));
+}
+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>
+
+<slot
+	{job}
+	{isLoading}
+	{workspaceOverride}
+	{notfound}
+	{abstractRun}
+	{runScriptByPath}
+	{runFlowByPath}
+	{runPreview}
+	{cancelJob}
+	{clearCurrentJob}
+	{watchJob}
+	{loadTestJob}
+	{syncer}
+/>