windmill-components 1.687.0 → 1.695.0

package/package/components/raw_apps/RawAppSharedUiDrawer.svelte

@@ -0,0 +1,129 @@
+<script lang="ts">import { workspaceStore } from '../../stores';
+import { WorkspaceService } from '../../gen';
+import { sendUserToast } from '../../toast';
+import Drawer from '../common/drawer/Drawer.svelte';
+import DrawerContent from '../common/drawer/DrawerContent.svelte';
+import Editor from '../Editor.svelte';
+import { Pane, Splitpanes } from 'svelte-splitpanes';
+let open = $state(false);
+let files = $state({});
+let version = $state(0);
+let editedBy = $state('');
+let selected = $state(undefined);
+let loading = $state(false);
+export async function openDrawer() {
+    open = true;
+    await load();
+}
+async function load() {
+    if (!$workspaceStore)
+        return;
+    loading = true;
+    try {
+        const res = (await WorkspaceService.getSharedUi({ workspace: $workspaceStore }));
+        files = res.files ?? {};
+        version = res.version ?? 0;
+        editedBy = res.edited_by ?? '';
+        const keys = Object.keys(files).sort();
+        if (selected === undefined || !(selected in files)) {
+            selected = keys[0];
+        }
+    }
+    catch (e) {
+        sendUserToast(`Failed to load shared UI: ${e}`, true);
+    }
+    finally {
+        loading = false;
+    }
+}
+const sortedPaths = $derived(Object.keys(files).sort());
+function langFromPath(p) {
+    const ext = (p.split('.').pop() ?? '').toLowerCase();
+    if (ext === 'ts')
+        return 'bun';
+    if (ext === 'tsx')
+        return 'tsx';
+    if (ext === 'js')
+        return 'bun';
+    if (ext === 'jsx')
+        return 'jsx';
+    if (ext === 'css')
+        return undefined;
+    if (ext === 'json')
+        return 'json';
+    if (ext === 'html')
+        return undefined;
+    if (ext === 'md')
+        return undefined;
+    return undefined;
+}
+</script>
+
+<Drawer bind:open size="900px">
+	<DrawerContent
+		title="Shared UI folder ({sortedPaths.length} file{sortedPaths.length === 1 ? '' : 's'})"
+		on:close={() => (open = false)}
+		noPadding
+	>
+		<div class="px-3 py-2 text-xs text-tertiary border-b">
+			Read-only view of the workspace's <code>ui/</code> folder. Imports of
+			<code>/ui/&lt;path&gt;</code> are bundled in when you push this raw app. Edits happen via
+			<code>wmill sync</code>.
+			{#if version}
+				Version {version}{#if editedBy}, by <code>{editedBy}</code>{/if}.
+			{/if}
+		</div>
+
+		{#if loading}
+			<div class="flex items-center justify-center h-full text-tertiary">Loading…</div>
+		{:else if sortedPaths.length === 0}
+			<div class="flex flex-col items-center justify-center h-full p-6 text-center text-tertiary">
+				<div class="font-semibold mb-1">No shared UI files yet</div>
+				<div class="text-sm">
+					Create a <code>ui/</code> folder at the root of your sync directory, add files, then run
+					<code>wmill sync push</code>.
+				</div>
+			</div>
+		{:else}
+			<Splitpanes class="!h-full">
+				<Pane size={28} minSize={15}>
+					<div class="overflow-auto h-full divide-y border-r">
+						{#each sortedPaths as p (p)}
+							<button
+								class="w-full text-left px-3 py-2 text-sm font-mono hover:bg-surface-hover {selected ===
+								p
+									? 'bg-surface-selected'
+									: ''}"
+								onclick={() => (selected = p)}
+							>
+								<div class="truncate">{p}</div>
+								<div class="text-2xs text-tertiary">
+									{(files[p]?.length ?? 0).toLocaleString()} chars
+								</div>
+							</button>
+						{/each}
+					</div>
+				</Pane>
+				<Pane size={72}>
+					{#if selected}
+						{#key selected}
+							<Editor
+								class="flex flex-1 grow h-full"
+								path={`/ui/${selected}`}
+								code={files[selected] ?? ''}
+								scriptLang={langFromPath(selected)}
+								disabled={true}
+								automaticLayout
+								fixedOverflowWidgets
+							/>
+						{/key}
+					{:else}
+						<div class="flex items-center justify-center h-full text-tertiary">
+							Select a file to view
+						</div>
+					{/if}
+				</Pane>
+			</Splitpanes>
+		{/if}
+	</DrawerContent>
+</Drawer>

package/package/components/raw_apps/RawAppSharedUiDrawer.svelte.d.ts

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

package/package/components/raw_apps/RawAppSidebar.svelte

@@ -7,9 +7,11 @@ import RawAppHistoryList from './RawAppHistoryList.svelte';
 import Button from '../common/button/Button.svelte';
 import RawAppDataTableList from './RawAppDataTableList.svelte';
 import RawAppDataTableDrawer from './RawAppDataTableDrawer.svelte';
+import RawAppSharedUiDrawer from './RawAppSharedUiDrawer.svelte';
 let { runnables, selectedRunnable = $bindable(), files = $bindable({}), modules, onSelectFile, selectedDocument = $bindable(), historyManager, historySelectedId, onHistorySelect, onHistorySelectCurrent, onManualSnapshot, dataTableRefs = [], onDataTableRefsChange, defaultDatatable = undefined, defaultSchema = undefined, onDefaultChange } = $props();
 let dataTableDrawer = $state();
 let selectedDataTableIndex = $state(undefined);
+let sharedUiDrawer = $state();
 function handleAddDataTable(ref) {
     onDataTableRefsChange?.([...dataTableRefs, ref]);
 }
@@ -57,6 +59,15 @@ function handleSelectPath(path) {
 				<Plus size={12} />
 				<Folder size={12} />
 			</Button>
+			<Button
+				onClick={() => sharedUiDrawer?.openDrawer()}
+				title="Browse the workspace shared ui/ folder"
+				unifiedSize="xs"
+				variant="subtle"
+				btnClasses="px-1 gap-0.5 text-xs"
+			>
+				ui/
+			</Button>
 		</div>
 	{/snippet}
 	<FileExplorer
@@ -96,6 +107,7 @@ function handleSelectPath(path) {
 	onAdd={handleAddDataTable}
 	existingRefs={dataTableRefs}
 />
+<RawAppSharedUiDrawer bind:this={sharedUiDrawer} />
 
 {#if historyManager && onHistorySelect && onManualSnapshot}
 	<div class="py-4"></div>

package/package/components/raw_apps/dataTableRefUtils.d.ts

@@ -18,6 +18,13 @@ export interface RawAppData {
 }
 /** Default data configuration */
 export declare const DEFAULT_DATA: RawAppData;
+export type DataTableWhitelist = {
+    datatables: Set<string>;
+    allTablesDatatables: Set<string>;
+    tables: Map<string, Map<string, Set<string>>>;
+};
+export declare function buildDataTableWhitelist(refs: DataTableRef[]): DataTableWhitelist;
+export declare function isDatatableTableAllowed(whitelist: DataTableWhitelist, datatableName: string, schemaName: string, tableName: string): boolean;
 /**
  * Parse a string ref into a DataTableRef object
  * Format: <datatableName>/<schema>:<table> or <datatableName>/<table> (for public schema)

package/package/components/raw_apps/dataTableRefUtils.js

@@ -4,6 +4,40 @@ export const DEFAULT_DATA = {
     datatable: undefined,
     schema: undefined
 };
+export function buildDataTableWhitelist(refs) {
+    const datatables = new Set();
+    const allTablesDatatables = new Set();
+    const tables = new Map();
+    for (const ref of refs) {
+        datatables.add(ref.datatable);
+        if (!ref.table) {
+            allTablesDatatables.add(ref.datatable);
+            continue;
+        }
+        if (!tables.has(ref.datatable)) {
+            tables.set(ref.datatable, new Map());
+        }
+        const schemaKey = ref.schema ?? 'public';
+        const schemaMap = tables.get(ref.datatable);
+        if (!schemaMap.has(schemaKey)) {
+            schemaMap.set(schemaKey, new Set());
+        }
+        schemaMap.get(schemaKey).add(ref.table);
+    }
+    return { datatables, allTablesDatatables, tables };
+}
+export function isDatatableTableAllowed(whitelist, datatableName, schemaName, tableName) {
+    if (whitelist.datatables.size === 0) {
+        return true;
+    }
+    if (!whitelist.datatables.has(datatableName)) {
+        return false;
+    }
+    if (whitelist.allTablesDatatables.has(datatableName)) {
+        return true;
+    }
+    return whitelist.tables.get(datatableName)?.get(schemaName ?? 'public')?.has(tableName) ?? false;
+}
 /**
  * Parse a string ref into a DataTableRef object
  * Format: <datatableName>/<schema>:<table> or <datatableName>/<table> (for public schema)

package/package/components/raw_apps/dataTableRefUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package/components/raw_apps/dataTableRefUtils.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { buildDataTableWhitelist, isDatatableTableAllowed } from './dataTableRefUtils';
+describe('datatable whitelist helpers', () => {
+    it('allows every datatable table when no refs are configured', () => {
+        const whitelist = buildDataTableWhitelist([]);
+        expect(isDatatableTableAllowed(whitelist, 'main', 'public', 'users')).toBe(true);
+        expect(isDatatableTableAllowed(whitelist, 'analytics', 'events', 'clicks')).toBe(true);
+    });
+    it('treats datatable-level refs as all tables in that datatable', () => {
+        const whitelist = buildDataTableWhitelist([{ datatable: 'main' }]);
+        expect(isDatatableTableAllowed(whitelist, 'main', 'public', 'users')).toBe(true);
+        expect(isDatatableTableAllowed(whitelist, 'main', 'analytics', 'events')).toBe(true);
+        expect(isDatatableTableAllowed(whitelist, 'other', 'public', 'users')).toBe(false);
+    });
+    it('allows only explicitly listed tables for table-level refs', () => {
+        const whitelist = buildDataTableWhitelist([
+            { datatable: 'main', schema: 'public', table: 'users' },
+            { datatable: 'main', schema: 'analytics', table: 'events' }
+        ]);
+        expect(isDatatableTableAllowed(whitelist, 'main', 'public', 'users')).toBe(true);
+        expect(isDatatableTableAllowed(whitelist, 'main', 'analytics', 'events')).toBe(true);
+        expect(isDatatableTableAllowed(whitelist, 'main', 'public', 'orders')).toBe(false);
+    });
+    it('does not treat an explicit empty schema as public', () => {
+        const whitelist = buildDataTableWhitelist([{ datatable: 'main', schema: '', table: 'users' }]);
+        expect(isDatatableTableAllowed(whitelist, 'main', '', 'users')).toBe(true);
+        expect(isDatatableTableAllowed(whitelist, 'main', 'public', 'users')).toBe(false);
+    });
+});

package/package/components/raw_apps/rawAppPolicy.d.ts

@@ -5,6 +5,7 @@ type RunnableWithInlineScript = RunnableWithFields & {
     inlineScript?: InlineScript & {
         language: ScriptLang;
     };
+    delete_after_secs?: number;
 };
 export type Runnable = RunnableWithInlineScript | undefined;
 export {};

package/package/components/raw_apps/rawAppPolicy.js

@@ -10,6 +10,19 @@ export async function updateRawAppPolicy(runnables, currentPolicy) {
         triggerables_v2
     };
 }
+function extraFields(runnable, fields) {
+    const out = {};
+    if (typeof runnable.delete_after_secs === 'number' && runnable.delete_after_secs >= 0)
+        out.delete_after_secs = runnable.delete_after_secs;
+    const sensitive_inputs = Object.entries(fields)
+        .map(([k, v]) => (v['sensitive'] ? k : undefined))
+        .filter(Boolean);
+    if (sensitive_inputs.length > 0)
+        out.sensitive_inputs = sensitive_inputs;
+    if (runnable.inlineScript?.tag)
+        out.tag = runnable.inlineScript.tag;
+    return out;
+}
 async function processRunnable(id, runnable, fields) {
     const staticInputs = collectStaticFields(fields);
     const allowUserResources = Object.entries(fields)
@@ -25,7 +38,8 @@ async function processRunnable(id, runnable, fields) {
             {
                 static_inputs: staticInputs,
                 one_of_inputs: {},
-                allow_user_resources: allowUserResources
+                allow_user_resources: allowUserResources,
+                ...extraFields(runnable, fields)
             }
         ];
     }
@@ -36,7 +50,8 @@ async function processRunnable(id, runnable, fields) {
             {
                 static_inputs: staticInputs,
                 one_of_inputs: {},
-                allow_user_resources: allowUserResources
+                allow_user_resources: allowUserResources,
+                ...extraFields(runnable, fields)
             }
         ];
     }

package/package/components/resources/resourceTypesFilter.d.ts

@@ -0,0 +1,19 @@
+import { Boxes, FileText } from 'lucide-svelte';
+export declare function buildResourceTypesFilterSchema(): {
+    _default_: {
+        type: "string";
+        hidden: true;
+    };
+    name: {
+        type: "string";
+        label: string;
+        icon: typeof Boxes;
+        description: string;
+    };
+    description: {
+        type: "string";
+        label: string;
+        icon: typeof FileText;
+        description: string;
+    };
+};

package/package/components/resources/resourceTypesFilter.js

@@ -0,0 +1,21 @@
+import { Boxes, FileText } from 'lucide-svelte';
+export function buildResourceTypesFilterSchema() {
+    return {
+        _default_: {
+            type: 'string',
+            hidden: true
+        },
+        name: {
+            type: 'string',
+            label: 'Name',
+            icon: Boxes,
+            description: 'Search in resource type name'
+        },
+        description: {
+            type: 'string',
+            label: 'Description',
+            icon: FileText,
+            description: 'Search in resource type description'
+        }
+    };
+}

package/package/components/restartFromStepPath.d.ts

@@ -0,0 +1,39 @@
+import type { FlowModule } from '../gen';
+export type ContainerType = 'branchone' | 'forloopflow' | 'flow' | 'whileloopflow' | 'branchall';
+export type AncestorEntry = {
+    stepId: string;
+    type: ContainerType;
+    /** For BranchOne: -1 means default branch, 0..N-1 means branches[i] */
+    branchIndex?: number;
+    /** True for parallel ForLoop / BranchAll — backend rejects nested restart
+     * inside parallel containers, so the caller should hide the restart button. */
+    parallel?: boolean;
+};
+export type StepPath = {
+    target: FlowModule;
+    ancestors: AncestorEntry[];
+};
+/**
+ * Walks the flow value tree to locate `targetId`. Returns the target module and
+ * the chain of containers from the root down to (but not including) the target.
+ * Returns `undefined` if the step is not found in this flow value.
+ *
+ * Subflow boundaries are NOT crossed: if the target sits inside a `Flow{path}`
+ * step's referenced flow, this returns `undefined` because we don't have that
+ * subflow's value here.
+ */
+export declare function findStepPath(modules: FlowModule[], targetId: string): StepPath | undefined;
+/**
+ * Inline-expanded subflows produce step IDs like
+ * `subflow:<outer_subflow_step>:[<nested_subflow_step>:...]<leaf>`. Each `:`-separated
+ * segment after the `subflow:` marker is a step ID; the last segment is the leaf
+ * (the user's selected step) and the preceding segments are subflow steps along
+ * the way (each one a `Flow{path}` module).
+ *
+ * Returns the parsed segments + leaf, or `undefined` if `id` is not a subflow-prefixed
+ * step.
+ */
+export declare function parseExpandedSubflowId(id: string): {
+    subflowSteps: string[];
+    leaf: string;
+} | undefined;

package/package/components/restartFromStepPath.js

@@ -0,0 +1,89 @@
+/**
+ * Walks the flow value tree to locate `targetId`. Returns the target module and
+ * the chain of containers from the root down to (but not including) the target.
+ * Returns `undefined` if the step is not found in this flow value.
+ *
+ * Subflow boundaries are NOT crossed: if the target sits inside a `Flow{path}`
+ * step's referenced flow, this returns `undefined` because we don't have that
+ * subflow's value here.
+ */
+export function findStepPath(modules, targetId) {
+    for (const mod of modules) {
+        if (mod.id === targetId) {
+            return { target: mod, ancestors: [] };
+        }
+        const value = mod.value;
+        if (value.type === 'forloopflow' || value.type === 'whileloopflow') {
+            const sub = findStepPath(value.modules, targetId);
+            if (sub) {
+                return {
+                    target: sub.target,
+                    ancestors: [
+                        { stepId: mod.id, type: value.type, parallel: value.parallel === true },
+                        ...sub.ancestors
+                    ]
+                };
+            }
+        }
+        else if (value.type === 'branchone') {
+            const allBranches = [
+                { idx: -1, modules: value.default }
+            ];
+            value.branches.forEach((b, i) => allBranches.push({ idx: i, modules: b.modules }));
+            for (const { idx, modules: bm } of allBranches) {
+                const sub = findStepPath(bm, targetId);
+                if (sub) {
+                    return {
+                        target: sub.target,
+                        ancestors: [{ stepId: mod.id, type: 'branchone', branchIndex: idx }, ...sub.ancestors]
+                    };
+                }
+            }
+        }
+        else if (value.type === 'branchall') {
+            for (let i = 0; i < value.branches.length; i++) {
+                const sub = findStepPath(value.branches[i].modules, targetId);
+                if (sub) {
+                    return {
+                        target: sub.target,
+                        ancestors: [
+                            {
+                                stepId: mod.id,
+                                type: 'branchall',
+                                branchIndex: i,
+                                parallel: value.parallel === true
+                            },
+                            ...sub.ancestors
+                        ]
+                    };
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Inline-expanded subflows produce step IDs like
+ * `subflow:<outer_subflow_step>:[<nested_subflow_step>:...]<leaf>`. Each `:`-separated
+ * segment after the `subflow:` marker is a step ID; the last segment is the leaf
+ * (the user's selected step) and the preceding segments are subflow steps along
+ * the way (each one a `Flow{path}` module).
+ *
+ * Returns the parsed segments + leaf, or `undefined` if `id` is not a subflow-prefixed
+ * step.
+ */
+export function parseExpandedSubflowId(id) {
+    if (!id.startsWith('subflow:')) {
+        return undefined;
+    }
+    const parts = id
+        .slice('subflow:'.length)
+        .split(':')
+        .filter((p) => p.length > 0);
+    if (parts.length < 2) {
+        return undefined;
+    }
+    const leaf = parts[parts.length - 1];
+    const subflowSteps = parts.slice(0, -1);
+    return { subflowSteps, leaf };
+}

package/package/components/runs/JobDetailFieldConfig.d.ts

@@ -24,6 +24,7 @@ export type FieldPresenceConfig = Record<JobCategory, Record<JobField, boolean>>
  * Categorizes a job based on its job_kind
  */
 export declare function getJobCategory(job: Job): JobCategory;
+export declare function isFlowVersionHash(job: Job): boolean;
 /**
  * Gets trigger information from a job
  */

package/package/components/runs/JobDetailFieldConfig.js

@@ -37,6 +37,21 @@ export function getJobCategory(job) {
             return 'script'; // Default fallback
     }
 }
+// For flow/app-shaped jobs `script_hash` is a flow_version/app_version id
+// (i64) serialized as zero-padded 16-char hex.
+export function isFlowVersionHash(job) {
+    switch (job.job_kind) {
+        case 'flow':
+        case 'flowpreview':
+        case 'singlestepflow':
+        case 'flownode':
+        case 'flowdependencies':
+        case 'appdependencies':
+            return true;
+        default:
+            return false;
+    }
+}
 /**
  * Gets trigger information from a job
  */
@@ -158,10 +173,44 @@ export const fieldConfigs = {
     script_hash: {
         field: 'script_hash',
         label: 'Hash',
-        getValue: (job) => job.script_hash?.toString() || null,
-        getHref: (job, workspaceId) => job.script_hash && job.job_kind === 'script'
-            ? `/scripts/get/${job.script_hash}?workspace=${workspaceId}`
-            : null
+        getValue: (job) => {
+            if (!job.script_hash)
+                return null;
+            // Decode hex → decimal for flow/app version ids.
+            if (isFlowVersionHash(job)) {
+                try {
+                    return BigInt('0x' + job.script_hash).toString();
+                }
+                catch {
+                    return job.script_hash.toString();
+                }
+            }
+            return job.script_hash.toString();
+        },
+        getHref: (job, workspaceId) => {
+            if (!job.script_hash)
+                return null;
+            if (job.job_kind === 'script' || job.job_kind === 'dependencies') {
+                return `/scripts/get/${job.script_hash}?workspace=${workspaceId}`;
+            }
+            // Only flow-shaped jobs have a pinned-version viewer; app dep stays unlinked.
+            const isFlowKind = job.job_kind === 'flow' ||
+                job.job_kind === 'flowpreview' ||
+                job.job_kind === 'singlestepflow' ||
+                job.job_kind === 'flownode' ||
+                job.job_kind === 'flowdependencies';
+            if (isFlowKind && job.script_path) {
+                let version;
+                try {
+                    version = BigInt('0x' + job.script_hash).toString();
+                }
+                catch {
+                    return null;
+                }
+                return `/flows/get/${job.script_path}?workspace=${workspaceId}&version=${version}`;
+            }
+            return null;
+        }
     },
     script_path: {
         field: 'script_path',
@@ -171,9 +220,7 @@ export const fieldConfigs = {
             if (!job.script_path)
                 return null;
             const isScript = job.job_kind === 'script';
-            return isScript
-                ? `/scripts/get/${job.script_hash}`
-                : flowPathToHref(job.script_path);
+            return isScript ? `/scripts/get/${job.script_hash}` : flowPathToHref(job.script_path);
         }
     },
     worker: {
@@ -266,6 +313,7 @@ export const categoryFieldPresence = {
         worker: true,
         run_id: true,
         script_path: true,
+        script_hash: true,
         flow_status: false,
         duration: false,
         // Optional fields
@@ -273,7 +321,6 @@ export const categoryFieldPresence = {
         trigger_info: false,
         parent_job: false,
         schedule_path: false,
-        script_hash: false,
         language: false,
         step_info: false,
         priority: false,
@@ -286,14 +333,14 @@ export const categoryFieldPresence = {
         worker: true,
         run_id: true,
         started_at: true,
+        script_hash: true,
+        script_path: true,
         duration: false,
         // Optional fields
         memory_peak: false,
         trigger_info: false,
         parent_job: false,
         schedule_path: false,
-        script_hash: false,
-        script_path: false,
         language: false,
         step_info: false,
         flow_status: false,