windmill-components 1.623.1 → 1.642.0

package/package/components/FlowStatusViewerInner.svelte.d.ts

@@ -18,7 +18,6 @@ interface Props {
     } | undefined;
     innerModule?: FlowModuleValue | undefined;
     render?: boolean;
-    isOwner?: boolean;
     selectedNode?: string | undefined;
     globalModuleStates: Record<string, GraphModuleState>[];
     globalDurationStatuses?: Record<string, DurationStatus>[];
@@ -26,7 +25,6 @@ interface Props {
     isSubflow?: boolean;
     reducedPolling?: boolean;
     wideResults?: boolean;
-    hideFlowResult?: boolean;
     topModuleStates?: Record<string, GraphModuleState>;
     workspace?: string | undefined;
     prefix?: string | undefined;
@@ -39,7 +37,7 @@ interface Props {
     job?: (Job & {
         result_stream?: string;
     }) | undefined;
-    rightColumnSelect?: 'timeline' | 'node_status' | 'node_definition' | 'user_states';
+    rightColumnSelect?: 'timeline' | 'node_status' | 'node_definition' | 'user_states' | 'tracing';
     localModuleStates?: Record<string, GraphModuleState>;
     localDurationStatuses?: Record<string, DurationStatus>;
     onResultStreamUpdate?: ({ jobId, result_stream }: {
@@ -67,6 +65,8 @@ interface Props {
         isToolCallToBeLoaded: (storeKey: string) => boolean;
         addToolCallToLoad: (storeKey: string) => void;
     };
+    showLogsWithResult?: boolean;
+    showJobDetailHeader?: boolean;
 }
 export type FlowModuleForTimeline = {
     id: string;

package/package/components/FlowStatusWaitingForEvents.svelte

@@ -8,19 +8,15 @@ import Tooltip from './Tooltip.svelte';
 import { Button } from './common';
 import SchemaForm from './SchemaForm.svelte';
 import { twMerge } from 'tailwind-merge';
-export let isOwner;
-export let workspaceId;
-export let job;
-export let light = false;
-let default_payload = {};
-let resumeUrl = undefined;
-let cancelUrl = undefined;
-let description = undefined;
-let hide_cancel = false;
-$: approvalStep = (job?.flow_status?.step ?? 1) - 1;
-let defaultValues = {};
-$: job && getDefaultArgs();
-let schema = {};
+import { untrack } from 'svelte';
+let { isOwner, workspaceId, job, light = false } = $props();
+let default_payload = $state({});
+let resumeUrl = $state(undefined);
+let cancelUrl = $state(undefined);
+let description = $state(undefined);
+let hide_cancel = $state(false);
+let defaultValues = $state({});
+let schema = $state({});
 let lastJobId = undefined;
 async function getDefaultArgs() {
     let jobId = job?.flow_status?.modules?.[approvalStep]?.job;
@@ -44,7 +40,9 @@ async function getDefaultArgs() {
     hide_cancel = job?.raw_flow?.modules?.[approvalStep]?.suspend?.hide_cancel ?? false;
     schema = mergeSchema(job?.raw_flow?.modules?.[approvalStep]?.suspend?.resume_form?.schema ?? {}, job_result?.enums ?? {});
 }
+let loading = $state(false);
 async function continu(approve) {
+    loading = true;
     if ((resumeUrl && approve) || (cancelUrl && !approve)) {
         let split = (approve ? resumeUrl : cancelUrl).split('/');
         let signatureUrl = split.pop() ?? '';
@@ -103,37 +101,43 @@ async function continu(approve) {
         }
     }
 }
+let approvalStep = $derived((job?.flow_status?.step ?? 1) - 1);
+$effect(() => {
+    job && untrack(() => getDefaultArgs());
+});
 </script>
 
-<div class="w-full h-full mt-2 text-xs text-primary">
-	{#if !light}
-		<p>Waiting to be resumed</p>
-	{/if}
+<div class="w-full h-full text-xs text-primary">
 	{#if description != undefined}
 		<DisplayResult {workspaceId} noControls result={description} language={job?.language} />
+		<div class="mt-2"></div>
 	{/if}
 	<div>
 		{#if isOwner || resumeUrl}
-			<div class={twMerge('flex gap-2 mt-2', light ? 'flex-col' : 'flex-row ')}>
-				{#if cancelUrl && !hide_cancel}
+			<div class={twMerge('flex gap-2', light ? 'flex-col' : 'flex-row ')}>
+				{#if !hide_cancel}
 					<div>
 						<Button
-							title="Cancel the flow"
+							title="Cancel the step"
+							{loading}
 							iconOnly
 							startIcon={{ icon: X }}
 							variant="default"
+							disabled={!cancelUrl}
 							destructive
+							unifiedSize="md"
 							on:click={() => continu(false)}
 						/>
 					</div>
 				{/if}
 				<div>
-					<Button variant="accent" on:click={() => continu(true)}
-						>Resume <Tooltip class="text-white"
-							>Since you are an owner of this flow, you can send resume events without necessarily
-							knowing the resume id sent by the approval step</Tooltip
-						></Button
-					>
+					<Button variant="accent" onClick={() => continu(true)} {loading} unifiedSize="md">
+						Resume
+						<Tooltip class="text-white">
+							Since you are an owner of this flow, you can send resume events without necessarily
+							knowing the resume id sent by the approval step
+						</Tooltip>
+					</Button>
 				</div>
 
 				{#if job?.raw_flow?.modules?.[approvalStep]?.suspend?.resume_form?.schema}
@@ -145,10 +149,11 @@ async function continu(approve) {
 					>
 						<SchemaForm onlyMaskPassword bind:args={default_payload} {defaultValues} {schema} />
 					</div>
+					<Tooltip>
+						The payload is optional, it is passed to the following step through the `resume`
+						variable
+					</Tooltip>
 				{/if}
-				<Tooltip
-					>The payload is optional, it is passed to the following step through the `resume` variable</Tooltip
-				>
 			</div>
 		{:else}
 			You cannot resume the flow yourself without receiving the resume secret since you are not an

package/package/components/FlowStatusWaitingForEvents.svelte.d.ts

@@ -1,24 +1,10 @@
 import { type Job } from '../gen';
-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 FlowStatusWaitingForEvents: $$__sveltets_2_IsomorphicComponent<{
+interface Props {
     isOwner: boolean;
     workspaceId: string | undefined;
     job: Job;
     light?: boolean;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type FlowStatusWaitingForEvents = InstanceType<typeof FlowStatusWaitingForEvents>;
+}
+declare const FlowStatusWaitingForEvents: import("svelte").Component<Props, {}, "">;
+type FlowStatusWaitingForEvents = ReturnType<typeof FlowStatusWaitingForEvents>;
 export default FlowStatusWaitingForEvents;

package/package/components/FlowViewer.svelte

@@ -1,19 +1,92 @@
-<script lang="ts">import { Tab, Tabs, TabContent } from './common';
+<script lang="ts">import { FlowService } from '../gen';
+import { Tab, Tabs, TabContent } from './common';
 import SchemaViewer from './SchemaViewer.svelte';
 import FlowGraphViewer from './FlowGraphViewer.svelte';
+import { Loader2 } from 'lucide-svelte';
+import { orderedYamlStringify, cleanValueProperties, replaceFalseWithUndefined } from '../utils';
+import { workspaceStore } from '../stores';
+import { watch } from 'runed';
 import HighlightTheme from './HighlightTheme.svelte';
 import FlowViewerInner from './FlowViewerInner.svelte';
 import FlowInputViewer from './FlowInputViewer.svelte';
-let { flow, initialOpen = undefined, noSide = false, noGraph = false, tab = $bindable(noGraph ? 'schema' : 'ui'), noSummary = false, noGraphDownload = false } = $props();
+let { flow, initialOpen = undefined, noSide = false, noGraph = false, availableVersions = undefined, initTab = undefined, noSummary = false, noGraphDownload = false, selectedVersionId = undefined } = $props();
 let open = {};
 if (initialOpen) {
     open[initialOpen] = true;
 }
+let previousVersionId = $state(undefined);
+let previousFlow = $state(undefined);
+let tab = $state(initTab ?? 'diff');
+let previousFlowCache = {};
+async function loadPreviousFlow(version) {
+    try {
+        if (previousFlowCache[version]) {
+            previousFlow = previousFlowCache[version];
+            return;
+        }
+        previousFlow = await FlowService.getFlowVersion({
+            workspace: $workspaceStore,
+            version
+        });
+        previousFlowCache[version] = previousFlow;
+    }
+    catch (e) {
+        console.error(e);
+        previousFlow = undefined;
+    }
+}
+// Load previous flow when previousVersionId changes
+$effect.pre(() => {
+    if (previousVersionId !== undefined) {
+        loadPreviousFlow(previousVersionId);
+    }
+    else {
+        previousFlow = undefined;
+    }
+});
+$effect.pre(() => {
+    if (initTab) {
+        return;
+    }
+    if (availableVersions && availableVersions.length > 0) {
+        tab = 'diff';
+    }
+    else {
+        if (noGraph) {
+            tab = 'schema';
+        }
+        else {
+            tab = 'ui';
+        }
+    }
+});
+// Auto-select first available version and validate current selection
+watch([() => availableVersions, () => selectedVersionId], () => {
+    if (availableVersions && availableVersions.length > 0) {
+        previousVersionId = availableVersions[0].id;
+    }
+    else {
+        previousVersionId = undefined;
+    }
+});
+let currentFlowYaml = $derived.by(() => {
+    const metadata = structuredClone(cleanValueProperties(replaceFalseWithUndefined(flow)));
+    return orderedYamlStringify(metadata);
+});
+let previousFlowYaml = $derived.by(() => {
+    if (!previousFlow)
+        return undefined;
+    const metadata = structuredClone(cleanValueProperties(replaceFalseWithUndefined(previousFlow)));
+    return orderedYamlStringify(metadata);
+});
 </script>
 
 <HighlightTheme />
 
 <Tabs bind:selected={tab}>
+	{#if availableVersions && availableVersions.length > 0}
+		<Tab value="diff" label="Diff" />
+	{/if}
 	{#if !noGraph}
 		<Tab value="ui" label="Graph" />
 	{/if}
@@ -21,6 +94,34 @@ if (initialOpen) {
 	<Tab value="schema" label="Input Schema" />
 
 	{#snippet content()}
+		{#if availableVersions && availableVersions.length > 0}
+			<TabContent value="diff">
+				<div class="flex flex-col gap-2 h-full">
+					<div class="flex flex-row items-center gap-2 py-2">
+						<div class="text-xs">Compare with:</div>
+						<select bind:value={previousVersionId} class="!text-xs !w-40">
+							{#each availableVersions as version (version.id)}
+								<option value={version.id} class="!text-xs">
+									{version.deployment_msg ?? `Version ${version.id}`}
+								</option>
+							{/each}
+						</select>
+					</div>
+
+					{#if previousFlowYaml}
+						<div class="h-[calc(100vh-150px)] min-h-[400px]">
+							{#await import('./FlowDiffViewer.svelte')}
+								<Loader2 class="animate-spin" />
+							{:then Module}
+								<Module.default beforeYaml={previousFlowYaml} afterYaml={currentFlowYaml} />
+							{/await}
+						</div>
+					{:else}
+						<Loader2 class="animate-spin" />
+					{/if}
+				</div>
+			</TabContent>
+		{/if}
 		<TabContent value="ui">
 			<div class="flow-root w-full pb-4">
 				{#if !noSummary}

package/package/components/FlowViewer.svelte.d.ts

@@ -1,4 +1,5 @@
-import type { FlowValue } from '../gen';
+import { type FlowValue } from '../gen';
+type TabValue = 'ui' | 'raw' | 'schema' | 'diff';
 interface Props {
     flow: {
         summary: string;
@@ -9,10 +10,15 @@ interface Props {
     initialOpen?: number | undefined;
     noSide?: boolean;
     noGraph?: boolean;
-    tab?: 'ui' | 'raw' | 'schema';
+    initTab?: TabValue;
     noSummary?: boolean;
     noGraphDownload?: boolean;
+    availableVersions?: Array<{
+        id: number;
+        deployment_msg?: string;
+    }>;
+    selectedVersionId?: number;
 }
-declare const FlowViewer: import("svelte").Component<Props, {}, "tab">;
+declare const FlowViewer: import("svelte").Component<Props, {}, "">;
 type FlowViewer = ReturnType<typeof FlowViewer>;
 export default FlowViewer;

package/package/components/FolderPicker.svelte

@@ -1,98 +1,228 @@
 <script lang="ts">import { FolderService } from '../gen';
 import { workspaceStore, userStore } from '../stores';
-import { Plus, Eye } from 'lucide-svelte';
+import { Pen, PlusIcon } from 'lucide-svelte';
 import { Button, Drawer, DrawerContent } from './common';
 import FolderEditor from './FolderEditor.svelte';
+import Select from './select/Select.svelte';
+import TextInput from './text_input/TextInput.svelte';
+import Label from './Label.svelte';
+import InputError from './InputError.svelte';
+import { tick } from 'svelte';
+import { sendUserToast } from '../toast';
+const VALID_FOLDER_NAME = /^[a-zA-Z_0-9]+$/;
 let folders = $state([]);
+let filterText = $state('');
+let selectOpen = $state(false);
+let nameInput = $state();
 let newFolder = $state(null);
 let viewFolder = $state(null);
 let newFolderName = $state('');
 let folderCreated = $state(undefined);
-let { folderName = $bindable(''), initialPath = $bindable(undefined), disabled = $bindable(undefined), disableEditing = $bindable(undefined), } = $props();
+let creating = $state(false);
+let loadingFolders = $state(true);
+let editingFolder = $state('');
+let { folderName = $bindable(''), initialPath = $bindable(undefined), disabled = $bindable(undefined), disableEditing = $bindable(undefined), size = 'md', drawerOffset = 0 } = $props();
+let hovering = $state(false);
 async function loadFolders() {
-    let initialFolders = [];
-    let initialFolder = '';
-    if (initialPath?.split('/')?.[0] == 'f') {
-        initialFolder = initialPath?.split('/')?.[1];
-        initialFolders.push({ name: initialFolder, write: true });
+    loadingFolders = true;
+    try {
+        let initialFolders = [];
+        let initialFolder = '';
+        if (initialPath?.split('/')?.[0] == 'f') {
+            initialFolder = initialPath?.split('/')?.[1];
+            initialFolders.push({ name: initialFolder, write: true });
+        }
+        const excludedFolders = [initialFolder, 'app_groups', 'app_custom', 'app_themes'];
+        folders = initialFolders.concat((await FolderService.listFolderNames({
+            workspace: $workspaceStore
+        }))
+            .filter((x) => !excludedFolders.includes(x))
+            .map((x) => ({
+            name: x,
+            write: $userStore?.folders?.includes(x) == true ||
+                ($userStore?.is_admin ?? false) ||
+                ($userStore?.is_super_admin ?? false)
+        })));
+    }
+    catch (e) {
+        sendUserToast(`Could not load folders: ${e}`, true);
+    }
+    finally {
+        loadingFolders = false;
     }
-    const excludedFolders = [initialFolder, 'app_groups', 'app_custom', 'app_themes'];
-    folders = initialFolders.concat((await FolderService.listFolderNames({
-        workspace: $workspaceStore
-    }))
-        .filter((x) => !excludedFolders.includes(x))
-        .map((x) => ({
-        name: x,
-        write: $userStore?.folders?.includes(x) == true ||
-            ($userStore?.is_admin ?? false) ||
-            ($userStore?.is_super_admin ?? false)
-    })));
+}
+async function openCreateFolder() {
+    newFolderName = filterText;
+    folderCreated = undefined;
+    newFolder?.openDrawer();
+    await tick();
+    nameInput?.focus();
 }
 async function addFolder() {
-    await FolderService.createFolder({
-        workspace: $workspaceStore ?? '',
-        requestBody: { name: newFolderName }
-    });
-    folderCreated = newFolderName;
-    $userStore?.folders?.push(newFolderName);
-    folderName = newFolderName;
-    loadFolders();
+    if (nameError || !newFolderName || creating)
+        return;
+    creating = true;
+    try {
+        await FolderService.createFolder({
+            workspace: $workspaceStore ?? '',
+            requestBody: { name: newFolderName }
+        });
+        folderCreated = newFolderName;
+        await loadFolders();
+        folderName = newFolderName;
+        // Writing $userStore.folders = [...] would call userStore.set(),
+        // which re-triggers Path.svelte's $effect.pre and calls initPath()/reset(),
+        // switching the owner toggle from "Folder" back to "User".
+        if ($userStore) {
+            if (!$userStore.folders)
+                $userStore.folders = [];
+            $userStore.folders.push(newFolderName);
+        }
+    }
+    catch (e) {
+        sendUserToast(`Could not create folder: ${e}`, true);
+    }
+    finally {
+        creating = false;
+    }
+}
+let selectItems = $derived(folders.map((f) => ({
+    value: f.name,
+    label: f.name + (f.write ? '' : ' (read-only)'),
+    disabled: !f.write
+})));
+let nameError = $derived(!newFolderName
+    ? ''
+    : !VALID_FOLDER_NAME.test(newFolderName)
+        ? 'Folder name can only contain alphanumeric characters and underscores'
+        : folders.some((f) => f.name === newFolderName)
+            ? 'A folder with this name already exists'
+            : '');
+let noMatchingItems = $derived(filterText &&
+    !selectItems.some((item) => item.label.toLowerCase().includes(filterText.toLowerCase())));
+function handleSelectKeydown(e) {
+    if (e.key === 'Enter' && selectOpen && noMatchingItems) {
+        e.preventDefault();
+        selectOpen = false;
+        openCreateFolder();
+    }
 }
 loadFolders();
 </script>
 
-<Drawer bind:this={newFolder} name="newFolder">
+<Drawer bind:this={newFolder} name="newFolder" offset={drawerOffset}>
 	<DrawerContent
-		title="New Folder"
+		title={folderCreated ? `Folder ${folderCreated}` : 'Create folder'}
 		on:close={() => {
 			newFolder?.closeDrawer()
 			folderCreated = undefined
 		}}
 	>
-		{#if !folderCreated}
-			<div class="flex flex-col gap-2">
-				<input placeholder="New folder name" bind:value={newFolderName} />
-				<Button size="md" startIcon={{ icon: Plus }} disabled={!newFolderName} on:click={addFolder}>
-					New&nbsp;folder
+		{#if folderCreated}
+			<FolderEditor name={folderCreated} />
+		{:else}
+			<div class="flex flex-col gap-4">
+				<Label label="Folder name">
+					<TextInput
+						bind:this={nameInput}
+						bind:value={newFolderName}
+						error={!!nameError}
+						inputProps={{
+							placeholder: 'folder_name',
+							onkeydown: (e: KeyboardEvent) => {
+								if (e.key === 'Enter' && newFolderName) {
+									e.preventDefault()
+									addFolder()
+								}
+							}
+						}}
+					/>
+					<InputError error={nameError} />
+				</Label>
+				<Button
+					variant="accent"
+					disabled={!newFolderName || !!nameError || creating}
+					loading={creating}
+					onClick={addFolder}
+				>
+					Create
 				</Button>
 			</div>
-		{:else}
-			<FolderEditor name={folderCreated} />
 		{/if}
 	</DrawerContent>
 </Drawer>
 
-<Drawer bind:this={viewFolder}>
-	<DrawerContent title="Folder {folderName}" on:close={viewFolder.closeDrawer}>
-		<FolderEditor name={folderName ?? ''} />
+<Drawer bind:this={viewFolder} offset={drawerOffset}>
+	<DrawerContent title="Folder {editingFolder}" on:close={viewFolder.closeDrawer}>
+		<FolderEditor name={editingFolder} />
 	</DrawerContent>
 </Drawer>
 
-<div class="flex flex-row items-center gap-1 w-full">
-	<select class="grow w-full" disabled={disabled || disableEditing} bind:value={folderName}>
-		{#if folders?.length == 0}
-			<option disabled>No folders</option>
-		{/if}
-		{#each folders as { name, write }}
-			<option disabled={!write}>{name}{write ? '' : ' (read-only)'}</option>
-		{/each}
-	</select>
-	<Button
-		title="View folder"
-		variant="default"
-		unifiedSize="md"
-		disabled={!folderName || folderName == ''}
-		on:click={viewFolder.openDrawer}
-		iconOnly
-		startIcon={{ icon: Eye }}
-	/>
-	<Button
-		title="New folder"
-		variant="default"
-		unifiedSize="md"
-		{disabled}
-		on:click={newFolder.openDrawer}
-		iconOnly
-		startIcon={{ icon: Plus }}
-	/>
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+<div
+	class="flex flex-row w-full items-center relative"
+	role="group"
+	onkeydown={handleSelectKeydown}
+	onmouseenter={() => (hovering = true)}
+	onmouseleave={() => (hovering = false)}
+>
+	<Select
+		bind:value={folderName}
+		bind:filterText
+		bind:open={selectOpen}
+		items={selectItems}
+		disabled={disabled || disableEditing}
+		loading={loadingFolders}
+		{size}
+		placeholder="Select folder"
+		class="grow min-w-0"
+	>
+		{#snippet endSnippet({ item, close })}
+			<Button
+				disabled={disabled || disableEditing}
+				variant="subtle"
+				unifiedSize="xs"
+				wrapperClasses="-mr-2 pl-1 -my-2"
+				btnClasses="hover:bg-surface-tertiary"
+				onClick={() => {
+					editingFolder = item.value ?? ''
+					viewFolder?.openDrawer()
+					close()
+				}}
+				startIcon={{ icon: Pen }}
+				iconOnly
+			/>
+		{/snippet}
+		{#snippet bottomSnippet({ close })}
+			<button
+				class="sticky py-2 px-4 w-full text-left text-xs font-medium hover:bg-surface-hover flex items-center justify-center gap-2 border-t border-border-light {noMatchingItems
+					? 'bg-surface-hover'
+					: ''}"
+				onclick={() => {
+					close()
+					openCreateFolder()
+				}}
+			>
+				<PlusIcon class="inline" size={16} />
+				Create folder
+			</button>
+		{/snippet}
+	</Select>
+	{#if folderName && hovering && !loadingFolders && !disabled && !disableEditing}
+		<div class="absolute right-2 z-20">
+			<Button
+				variant="subtle"
+				unifiedSize="xs"
+				wrapperClasses="pl-1"
+				btnClasses="hover:bg-surface-tertiary"
+				onClick={() => {
+					editingFolder = folderName
+					viewFolder?.openDrawer()
+				}}
+				startIcon={{ icon: Pen }}
+				iconOnly
+			/>
+		</div>
+	{/if}
 </div>

package/package/components/FolderPicker.svelte.d.ts

@@ -3,6 +3,8 @@ type Props = {
     initialPath?: string;
     disabled?: boolean;
     disableEditing?: boolean;
+    size?: 'sm' | 'md';
+    drawerOffset?: number;
 };
 declare const FolderPicker: import("svelte").Component<Props, {}, "disabled" | "folderName" | "initialPath" | "disableEditing">;
 type FolderPicker = ReturnType<typeof FolderPicker>;