windmill-components 1.687.0 → 1.695.1

package/package/components/useNestedRestartState.svelte.js

@@ -0,0 +1,320 @@
+import { findStepPath, parseExpandedSubflowId } from './restartFromStepPath';
+import { emptyString } from '../utils';
+/**
+ * Returns true when the BranchOne ancestor's path branch (the one containing the
+ * selected leaf, encoded as `branchIndex` where -1 means default and 0..N-1
+ * means `branches[i]`) is the same branch the original run took. If the user
+ * clicked a step inside an `else` branch the original run didn't take, the
+ * step never executed — restart there is impossible.
+ *
+ * Three states for the lookup:
+ *   - `status === undefined`: the BranchOne isn't at the parent's top level, so
+ *     it lives on a child job we don't fetch here (e.g. nested inside a ForLoop
+ *     iteration). Permissive fallback — let the backend reject if needed.
+ *   - `status` defined but `chosen === undefined`: the BranchOne IS at the top
+ *     level but has no chosen branch (never executed / skipped / still
+ *     waiting). The leaf can't have run either, so reject.
+ *   - both defined: compare against `branchIndex`.
+ */
+function branchOneAncestorMatchesOriginal(job, ancestor) {
+    if (ancestor.type !== 'branchone')
+        return true;
+    const status = job.flow_status?.modules?.find((m) => m.id === ancestor.stepId);
+    const chosen = status?.branch_chosen;
+    if (!chosen)
+        return status === undefined;
+    const taken = chosen.type === 'default' ? -1 : (chosen.branch ?? -1);
+    return ancestor.branchIndex === taken;
+}
+/**
+ * Reactive state shared by the run page and the editor's flow preview to drive
+ * the "restart flow at step" UI. Given the currently selected step, the
+ * completed flow job, the graph's per-module display state, and any expanded
+ * subflow definitions, derives:
+ *
+ *   - `selectedJobStepIsTopLevel` — whether the selected step appears in the
+ *     parent flow's top-level `flow_status.modules`
+ *   - `selectedJobStepType` — `single` / `forloop` / `branchall`, used by the
+ *     popup to decide which controls to render for the OUTER container
+ *   - `restartBranchNames` — for top-level BranchAll steps, the labels for the
+ *     branch picker
+ *   - `nestedRestartTopStepId` / `nestedRestartTopBranchOrIterationN` /
+ *     `nestedRestartPath` — the API request shape when restarting at a nested
+ *     step (single source of truth for both call sites)
+ *   - `nestedRestartSupported` — gate for showing the button when the selected
+ *     step is nested (subflow expansion or BranchOne / sequential ForLoop)
+ *   - `topLevelLoopIteration` — when the selected step IS a top-level ForLoop,
+ *     the iteration the user is currently viewing (pre-fills the popup input)
+ *   - `iterationCounts` — map of step id → number of recorded iterations,
+ *     so the popup can render an iteration `<select>` matching the graph's tabs
+ *     instead of a free-form number input
+ *
+ * Inputs are passed as getters so the composable stays reactive in either
+ * caller's signal graph.
+ */
+export function useNestedRestartState(opts) {
+    let selectedJobStepIsTopLevel = $state(undefined);
+    let selectedJobStepType = $state('single');
+    let restartBranchNames = $state([]);
+    let nestedRestartTopStepId = $state(undefined);
+    let nestedRestartTopBranchOrIterationN = $state(undefined);
+    let nestedRestartPath = $state(undefined);
+    let nestedRestartSupported = $state(false);
+    // Iteration counts keyed by the popup's field-key ('top' or 'inner-N').
+    // Built during path construction so each entry uses the *correct* graph key
+    // for its level (prefixed for in-subflow ancestors). Avoids the collision
+    // that would happen if we double-indexed `iterationCounts` by bare step_id.
+    let nestedPathIterationCounts = $state({});
+    $effect(() => {
+        const selectedJobStep = opts.selectedJobStep();
+        const job = opts.job();
+        const graphModuleStates = opts.graphModuleStates();
+        const expandedSubflows = opts.expandedSubflows?.() ?? {};
+        nestedRestartTopStepId = undefined;
+        nestedRestartTopBranchOrIterationN = undefined;
+        nestedRestartPath = undefined;
+        nestedRestartSupported = false;
+        restartBranchNames = [];
+        selectedJobStepIsTopLevel = undefined;
+        nestedPathIterationCounts = {};
+        if (selectedJobStep === undefined || job?.flow_status?.modules === undefined) {
+            return;
+        }
+        const isTopLevel = job.flow_status.modules.findIndex((m) => m.id === selectedJobStep) >= 0;
+        selectedJobStepIsTopLevel = isTopLevel;
+        const moduleDefinition = job.raw_flow?.modules.find((m) => m.id === selectedJobStep);
+        if (moduleDefinition?.value.type === 'forloopflow') {
+            selectedJobStepType = 'forloop';
+        }
+        else if (moduleDefinition?.value.type === 'branchall') {
+            selectedJobStepType = 'branchall';
+            const newNames = [];
+            moduleDefinition.value.branches.forEach((branch, idx) => {
+                newNames.push([idx, emptyString(branch.summary) ? `Branch #${idx}` : branch.summary]);
+            });
+            restartBranchNames = newNames;
+        }
+        else {
+            selectedJobStepType = 'single';
+        }
+        // Read from the local — reading the `$state` we just wrote would register
+        // it as a dependency of this effect, causing `effect_update_depth_exceeded`
+        // because each write would reschedule the effect.
+        if (isTopLevel)
+            return;
+        // Inline-expanded subflow: id is `subflow:outerStep:[innerSubflow:...]<leaf>`.
+        // The graph adds the `subflow:` prefix only for subflow expansions, so each
+        // segment is a `Flow{path}` step. We walk the chain and, at the deepest
+        // subflow, recurse into its cached modules to detect BranchOne / ForLoop
+        // ancestors of the leaf so the chain captures locked branches and
+        // iteration indices for those too.
+        const subflowParse = parseExpandedSubflowId(selectedJobStep);
+        if (subflowParse && job.raw_flow?.modules) {
+            const top = job.raw_flow.modules.find((m) => m.id === subflowParse.subflowSteps[0]);
+            if (top && top.value.type === 'flow') {
+                const innerPath = [];
+                // Intermediate subflow boundaries: each is itself a Flow{path}, no
+                // branch_or_iteration_n applies.
+                for (const seg of subflowParse.subflowSteps.slice(1)) {
+                    innerPath.push({ step_id: seg });
+                }
+                // Look up the deepest subflow's modules in expandedSubflows. The graph
+                // stores them under the prefixed key (the graph node id used at that
+                // nesting level).
+                const deepestKey = subflowParse.subflowSteps.length === 1
+                    ? subflowParse.subflowSteps[0]
+                    : 'subflow:' + subflowParse.subflowSteps.join(':');
+                const deepestModules = expandedSubflows[deepestKey]?.modules;
+                if (deepestModules) {
+                    const path = findStepPath(deepestModules, subflowParse.leaf);
+                    if (path) {
+                        // Same gating as the parent-flow case, minus the BranchOne
+                        // branch-mismatch check (subflow's flow_status isn't directly
+                        // reachable here; backend will still reject if the branch
+                        // wasn't taken). Parallel and unsupported containers are checked.
+                        const blocked = path.ancestors.some((a) => a.type === 'branchall' || a.type === 'whileloopflow' || a.parallel === true);
+                        if (!blocked) {
+                            // Inside the subflow, the graph state for ForLoop ancestors
+                            // is keyed by the prefixed graph id. Build that key here so
+                            // `selectedForloopIndex` and `flow_jobs.length` lookups land
+                            // on the right entry (avoiding collisions with same-step-id
+                            // loops in the parent flow — e.g. parent has `e` with 4 iters
+                            // and the subflow also has `e` with 1 iter).
+                            const subflowPrefix = 'subflow:' + subflowParse.subflowSteps.join(':') + ':';
+                            const iterationFor = (stepId) => graphModuleStates[subflowPrefix + stepId]?.selectedForloopIndex ?? 0;
+                            const iterCountFor = (stepId) => graphModuleStates[subflowPrefix + stepId]?.flow_jobs?.length ?? 0;
+                            const counts = {};
+                            // Top-level (parent) container is the subflow step `h` —
+                            // not a ForLoop, no count.
+                            for (let i = 0; i < path.ancestors.length; i++) {
+                                const a = path.ancestors[i];
+                                const entry = { step_id: a.stepId };
+                                if (a.type === 'forloopflow') {
+                                    entry.branch_or_iteration_n = iterationFor(a.stepId);
+                                    // Path key: each subflow boundary already contributes an
+                                    // inner-N entry above (subflow steps without iterations).
+                                    // Match the index that FlowRestartButton will use when
+                                    // rendering iteration fields.
+                                    counts[`inner-${innerPath.length}`] = iterCountFor(a.stepId);
+                                }
+                                innerPath.push(entry);
+                            }
+                            const leafEntry = { step_id: subflowParse.leaf };
+                            if (path.target.value.type === 'forloopflow') {
+                                leafEntry.branch_or_iteration_n = iterationFor(subflowParse.leaf);
+                                counts[`inner-${innerPath.length}`] = iterCountFor(subflowParse.leaf);
+                            }
+                            innerPath.push(leafEntry);
+                            nestedRestartTopStepId = top.id;
+                            nestedRestartPath = innerPath;
+                            nestedPathIterationCounts = counts;
+                            nestedRestartSupported = true;
+                            return;
+                        }
+                    }
+                }
+                // Fallback: subflow's modules not yet loaded (user clicked a step
+                // without expanding the subflow first), or leaf not found / blocked.
+                // Send a flat path; the backend will reject if the leaf is nested
+                // inside an unsupported container.
+                innerPath.push({ step_id: subflowParse.leaf });
+                nestedRestartTopStepId = top.id;
+                nestedRestartPath = innerPath;
+                nestedRestartSupported = true;
+                return;
+            }
+        }
+        // BranchOne / sequential ForLoop within the parent's own flow_value. Walk
+        // the tree to find the path; supported when ancestors are BranchOne /
+        // sequential ForLoop only — and only when each BranchOne ancestor's chosen
+        // branch in the original run actually contains the leaf, otherwise the
+        // step never executed and the backend would error.
+        if (!job.raw_flow?.modules)
+            return;
+        const path = findStepPath(job.raw_flow.modules, selectedJobStep);
+        if (!path || path.ancestors.length === 0)
+            return;
+        const blocked = path.ancestors.some((a) => a.type === 'branchall' ||
+            a.type === 'whileloopflow' ||
+            a.parallel === true ||
+            (a.type === 'branchone' && !branchOneAncestorMatchesOriginal(job, a)));
+        if (blocked)
+            return;
+        // For each ForLoop ancestor, default to the user's currently-open iteration
+        // (`selectedForloopIndex`); fall back to 0. The popup surfaces every value
+        // for confirmation/editing before submit, so we never silently send a guess.
+        const iterationFor = (stepId) => graphModuleStates[stepId]?.selectedForloopIndex ?? 0;
+        const iterCountFor = (stepId) => graphModuleStates[stepId]?.flow_jobs?.length ?? 0;
+        const top = path.ancestors[0];
+        const inner = path.ancestors.slice(1);
+        const innerPath = [];
+        const counts = {};
+        for (const a of inner) {
+            const entry = { step_id: a.stepId };
+            if (a.type === 'forloopflow') {
+                entry.branch_or_iteration_n = iterationFor(a.stepId);
+                counts[`inner-${innerPath.length}`] = iterCountFor(a.stepId);
+            }
+            innerPath.push(entry);
+        }
+        // If the SELECTED step is itself a ForLoop, include its iteration too so
+        // the popup exposes a selector for it.
+        const leafEntry = { step_id: selectedJobStep };
+        if (path.target.value.type === 'forloopflow') {
+            leafEntry.branch_or_iteration_n = iterationFor(selectedJobStep);
+            counts[`inner-${innerPath.length}`] = iterCountFor(selectedJobStep);
+        }
+        innerPath.push(leafEntry);
+        nestedRestartTopStepId = top.stepId;
+        if (top.type === 'forloopflow') {
+            nestedRestartTopBranchOrIterationN = iterationFor(top.stepId);
+            counts['top'] = iterCountFor(top.stepId);
+        }
+        nestedRestartPath = innerPath;
+        nestedPathIterationCounts = counts;
+        nestedRestartSupported = true;
+    });
+    const topLevelLoopIteration = $derived.by(() => {
+        const sel = opts.selectedJobStep();
+        if (!sel)
+            return undefined;
+        if (selectedJobStepType !== 'forloop')
+            return undefined;
+        return opts.graphModuleStates()[sel]?.selectedForloopIndex;
+    });
+    // `selectedJobStepIsTopLevel` answers "is this a top-level module structurally";
+    // `topLevelRestartable` answers "AND should the restart button show". The
+    // difference: parallel ForLoop / parallel BranchAll at the top level are
+    // rejected by the backend, so we hide the button preemptively.
+    const topLevelRestartable = $derived.by(() => {
+        if (!selectedJobStepIsTopLevel)
+            return false;
+        const sel = opts.selectedJobStep();
+        const job = opts.job();
+        if (!sel || !job?.raw_flow?.modules)
+            return false;
+        const mod = job.raw_flow.modules.find((m) => m.id === sel);
+        if (!mod)
+            return false;
+        const v = mod.value;
+        if ((v.type === 'forloopflow' || v.type === 'branchall' || v.type === 'whileloopflow') &&
+            v.parallel === true) {
+            return false;
+        }
+        return true;
+    });
+    // Iteration counts indexed by the graph module-state key (i.e. the prefixed
+    // `subflow:...:<step_id>` for in-subflow loops, or the bare `step_id` for
+    // top-level loops). Used by the popup for the SELECTED step's iteration
+    // picker — that step is always at the unprefixed top level (the run page's
+    // graph-state key matches the bare step_id), so the lookup is unambiguous.
+    // For nested-path iteration fields, see `nestedPathIterationCounts` instead,
+    // which is keyed by the popup's field-key ('top' / 'inner-N') and pulled
+    // from the path-aware graph key — avoiding collisions when the same step
+    // id appears at both the parent flow and inside a subflow.
+    const iterationCounts = $derived.by(() => {
+        const out = {};
+        for (const [id, state] of Object.entries(opts.graphModuleStates())) {
+            const n = state.flow_jobs?.length;
+            if (typeof n !== 'number' || n <= 0)
+                continue;
+            out[id] = n;
+        }
+        return out;
+    });
+    return {
+        get selectedJobStepIsTopLevel() {
+            return selectedJobStepIsTopLevel;
+        },
+        get selectedJobStepType() {
+            return selectedJobStepType;
+        },
+        get restartBranchNames() {
+            return restartBranchNames;
+        },
+        get nestedRestartTopStepId() {
+            return nestedRestartTopStepId;
+        },
+        get nestedRestartTopBranchOrIterationN() {
+            return nestedRestartTopBranchOrIterationN;
+        },
+        get nestedRestartPath() {
+            return nestedRestartPath;
+        },
+        get nestedRestartSupported() {
+            return nestedRestartSupported;
+        },
+        get topLevelLoopIteration() {
+            return topLevelLoopIteration;
+        },
+        get topLevelRestartable() {
+            return topLevelRestartable;
+        },
+        get iterationCounts() {
+            return iterationCounts;
+        },
+        get nestedPathIterationCounts() {
+            return nestedPathIterationCounts;
+        }
+    };
+}

package/package/components/workspaceSettings/SharedUiSettings.svelte

@@ -0,0 +1,175 @@
+<script lang="ts">import { onMount } from 'svelte';
+import JSZip from 'jszip';
+import Button from '../common/button/Button.svelte';
+import { workspaceStore, userStore } from '../../stores';
+import { sendUserToast } from '../../toast';
+import { WorkspaceService } from '../../gen';
+import { Download, Upload, RefreshCw } from 'lucide-svelte';
+let listing = $state(undefined);
+let loading = $state(false);
+let uploading = $state(false);
+let fileInput = $state(undefined);
+const isAdmin = $derived(!!$userStore?.is_admin);
+async function loadListing() {
+    if (!$workspaceStore)
+        return;
+    loading = true;
+    try {
+        listing = (await WorkspaceService.listSharedUi({
+            workspace: $workspaceStore
+        }));
+    }
+    catch (e) {
+        sendUserToast(`Failed to load shared UI: ${e}`, true);
+    }
+    finally {
+        loading = false;
+    }
+}
+function humanSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+async function downloadZip() {
+    if (!$workspaceStore)
+        return;
+    try {
+        const got = await WorkspaceService.getSharedUi({ workspace: $workspaceStore });
+        const files = got.files ?? {};
+        const zip = new JSZip();
+        for (const [path, content] of Object.entries(files)) {
+            zip.file(path, content);
+        }
+        const blob = await zip.generateAsync({ type: 'blob' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `${$workspaceStore}-ui.zip`;
+        a.click();
+        URL.revokeObjectURL(url);
+    }
+    catch (e) {
+        sendUserToast(`Failed to download shared UI: ${e}`, true);
+    }
+}
+async function onFileSelected(event) {
+    const target = event.target;
+    const file = target.files?.[0];
+    if (!file || !$workspaceStore)
+        return;
+    uploading = true;
+    try {
+        const zip = await JSZip.loadAsync(await file.arrayBuffer());
+        const files = {};
+        const tasks = [];
+        zip.forEach((relativePath, entry) => {
+            if (entry.dir)
+                return;
+            tasks.push(entry.async('string').then((content) => {
+                files[relativePath] = content;
+            }));
+        });
+        await Promise.all(tasks);
+        await WorkspaceService.updateSharedUi({
+            workspace: $workspaceStore,
+            requestBody: { files }
+        });
+        sendUserToast(`Replaced shared UI folder with ${Object.keys(files).length} file(s)`);
+        await loadListing();
+    }
+    catch (e) {
+        sendUserToast(`Failed to replace shared UI: ${e}`, true);
+    }
+    finally {
+        uploading = false;
+        if (fileInput) {
+            fileInput.value = '';
+        }
+    }
+}
+onMount(() => {
+    loadListing();
+});
+</script>
+
+<div class="mb-6">
+	<h2 class="text-lg font-semibold mb-1">Shared UI folder</h2>
+	<p class="text-sm text-secondary">
+		Workspace-shared frontend files (components, styles, helpers) that the raw app bundler merges
+		under the <code>/ui/</code> path. Raw apps can import shared components with
+		<code>{`import { Button } from '/ui/Button'`}</code>.
+	</p>
+	<p class="text-sm text-secondary mt-2">
+		Editing happens through the Windmill CLI (<code>wmill sync</code> writes/reads the
+		<code>ui/</code> folder at the root of your sync directory). This page lets you inspect or
+		replace the entire folder. Changes do <strong>not</strong> retroactively rebuild deployed raw apps
+		— re-push affected raw apps to pick up updates.
+	</p>
+</div>
+
+<div class="flex items-center gap-2 mb-4">
+	<Button
+		size="xs"
+		variant="default"
+		startIcon={{ icon: RefreshCw }}
+		on:click={loadListing}
+		disabled={loading}
+	>
+		Refresh
+	</Button>
+	<Button
+		size="xs"
+		variant="default"
+		startIcon={{ icon: Download }}
+		on:click={downloadZip}
+		disabled={!listing || listing.paths.length === 0}
+	>
+		Download as zip
+	</Button>
+	{#if isAdmin}
+		<Button
+			size="xs"
+			variant="default"
+			startIcon={{ icon: Upload }}
+			on:click={() => fileInput?.click()}
+			disabled={uploading}
+		>
+			{uploading ? 'Replacing…' : 'Replace from zip'}
+		</Button>
+		<input
+			bind:this={fileInput}
+			type="file"
+			accept=".zip"
+			style="display: none;"
+			onchange={onFileSelected}
+		/>
+	{/if}
+</div>
+
+{#if listing}
+	<div class="text-xs text-secondary mb-2">
+		Version {listing.version}{#if listing.edited_by}
+			· Last edited by <code>{listing.edited_by}</code>
+		{/if}
+	</div>
+	{#if listing.paths.length === 0}
+		<div class="rounded border border-dashed p-6 text-center text-sm text-secondary">
+			The shared UI folder is empty. Create a <code>ui/</code> directory next to your
+			<code>f/</code> and <code>u/</code> folders, add files, then run <code>wmill sync push</code>.
+		</div>
+	{:else}
+		<div class="rounded border divide-y">
+			{#each listing.paths as p (p)}
+				<div class="flex items-center justify-between px-3 py-2 text-sm font-mono">
+					<span class="truncate">{p}</span>
+					<span class="text-xs text-secondary">{humanSize(listing.sizes[p] ?? 0)}</span>
+				</div>
+			{/each}
+		</div>
+	{/if}
+{:else if loading}
+	<div class="text-sm text-secondary">Loading…</div>
+{/if}

package/package/components/workspaceSettings/SharedUiSettings.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const SharedUiSettings: import("svelte").Component<Record<string, never>, {}, "">;
+type SharedUiSettings = ReturnType<typeof SharedUiSettings>;
+export default SharedUiSettings;

package/package/gen/core/OpenAPI.js

@@ -21,7 +21,7 @@ export const OpenAPI = {
     PASSWORD: undefined,
     TOKEN: undefined,
     USERNAME: undefined,
-    VERSION: '1.687.0',
+    VERSION: '1.695.0',
     WITH_CREDENTIALS: false,
     interceptors: {
         request: new Interceptors(),