windmill-components 1.35.42 → 1.36.0

package/components/flows/content/FlowRetries.svelte

@@ -0,0 +1,80 @@
+<script>import Toggle from '../../Toggle.svelte';
+export let flowModule;
+function setConstantRetries() {
+    flowModule.retry = {
+        ...flowModule.retry,
+        constant: {
+            attempts: 0,
+            seconds: 0
+        }
+    };
+}
+function setExpoentialRetries() {
+    flowModule.retry = {
+        ...flowModule.retry,
+        exponential: {
+            attempts: 0,
+            multiplier: 1,
+            seconds: 0
+        }
+    };
+}
+$: isConstantRetryEnabled = Boolean(flowModule.retry?.constant);
+$: isExponentialRetryEnabled = Boolean(flowModule.retry?.exponential);
+</script>
+
+<div class="flex flex-col items-start space-y-1">
+	<Toggle
+		checked={isConstantRetryEnabled}
+		on:change={() => {
+			if (isConstantRetryEnabled && flowModule.retry?.constant) {
+				flowModule.retry.constant = undefined
+			} else {
+				setConstantRetries()
+			}
+		}}
+		options={{
+			right: 'Constant retry enabled'
+		}}
+	/>
+	{#if flowModule.retry?.constant}
+		<span class="text-xs font-bold">Attempts</span>
+		<input bind:value={flowModule.retry.constant.attempts} type="number" />
+		<span class="text-xs font-bold">Delay (seconds)</span>
+		<input bind:value={flowModule.retry.constant.seconds} type="number" />
+	{:else}
+		<span class="text-xs font-bold">Attempts</span>
+		<input type="number" disabled />
+		<span class="text-xs font-bold">Delay (seconds)</span>
+		<input type="number" disabled />
+	{/if}
+
+	<Toggle
+		checked={isExponentialRetryEnabled}
+		on:change={() => {
+			if (isExponentialRetryEnabled && flowModule.retry?.exponential) {
+				flowModule.retry.exponential = undefined
+			} else {
+				setExpoentialRetries()
+			}
+		}}
+		options={{
+			right: 'Exponential retry enabled'
+		}}
+	/>
+	{#if flowModule.retry?.exponential}
+		<span class="text-xs font-bold">Attempts</span>
+		<input bind:value={flowModule.retry.exponential.attempts} type="number" />
+		<span class="text-xs font-bold">Mulitplier</span>
+		<input bind:value={flowModule.retry.exponential.multiplier} type="number" />
+		<span class="text-xs font-bold">Initial delay (seconds)</span>
+		<input bind:value={flowModule.retry.exponential.seconds} type="number" />
+	{:else}
+		<span class="text-xs font-bold">Attempts</span>
+		<input type="number" disabled />
+		<span class="text-xs font-bold">Mulitplier</span>
+		<input type="number" disabled />
+		<span class="text-xs font-bold">Initial delay (seconds)</span>
+		<input type="number" disabled />
+	{/if}
+</div>

package/components/flows/content/FlowRetries.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponentTyped } from "svelte";
+import type { FlowModule } from '../../../gen';
+declare const __propDef: {
+    props: {
+        flowModule: FlowModule;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type FlowRetriesProps = typeof __propDef.props;
+export declare type FlowRetriesEvents = typeof __propDef.events;
+export declare type FlowRetriesSlots = typeof __propDef.slots;
+export default class FlowRetries extends SvelteComponentTyped<FlowRetriesProps, FlowRetriesEvents, FlowRetriesSlots> {
+}
+export {};

package/components/flows/content/FlowSchedules.svelte

@@ -0,0 +1,18 @@
+<script>import CronInput from '../../CronInput.svelte';
+import SchemaForm from '../../SchemaForm.svelte';
+import Toggle from '../../Toggle.svelte';
+import { getContext } from 'svelte';
+import { flowStore } from '../flowStore';
+const { schedule } = getContext('FlowEditorContext');
+</script>
+
+<CronInput bind:schedule={$schedule.cron} />
+
+<SchemaForm schema={$flowStore.schema} bind:args={$schedule.args} />
+
+<Toggle
+	bind:checked={$schedule.enabled}
+	options={{
+		right: 'Schedule enabled'
+	}}
+/>

package/components/flows/content/FlowSchedules.svelte.d.ts

@@ -0,0 +1,14 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {};
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type FlowSchedulesProps = typeof __propDef.props;
+export declare type FlowSchedulesEvents = typeof __propDef.events;
+export declare type FlowSchedulesSlots = typeof __propDef.slots;
+export default class FlowSchedules extends SvelteComponentTyped<FlowSchedulesProps, FlowSchedulesEvents, FlowSchedulesSlots> {
+}
+export {};

package/components/flows/content/FlowSettings.svelte

@@ -0,0 +1,78 @@
+<script>import Tabs from '../../common/tabs/Tabs.svelte';
+import Tab from '../../common/tabs/Tab.svelte';
+import TabContent from '../../common/tabs/TabContent.svelte';
+import { flowStore } from '../flowStore';
+import Path from '../../Path.svelte';
+import Required from '../../Required.svelte';
+import FlowCard from '../common/FlowCard.svelte';
+import FlowSchedules from './FlowSchedules.svelte';
+import SvelteMarkdown from 'svelte-markdown';
+export let initialPath;
+export let defaultTab = 'metadata';
+</script>
+
+<FlowCard title="Settings">
+	<Tabs selected={defaultTab}>
+		<Tab value="metadata">Metadata</Tab>
+		<Tab value="schedule">Schedule</Tab>
+
+		<svelte:fragment slot="content">
+			<TabContent value="metadata" class="p-4">
+				<Path bind:path={$flowStore.path} {initialPath} namePlaceholder="my_flow" kind="flow">
+					<div slot="ownerToolkit">
+						Flow permissions depend on their path. Select the group <span class="font-mono"
+							>all</span
+						>
+						to share your flow, and <span class="font-mono">user</span> to keep it private.
+						<a href="https://docs.windmill.dev/docs/reference/namespaces">docs</a>
+					</div>
+				</Path>
+
+				<label class="block my-4">
+					<span class="text-gray-700">Summary <Required required={false} /></span>
+					<textarea
+						bind:value={$flowStore.summary}
+						class="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-indigo-300 focus:ring focus:ring-indigo-200 focus:ring-opacity-50"
+						placeholder="A very short summary of the flow displayed when the flow is listed"
+						rows="1"
+						id="flow-summary"
+					/>
+				</label>
+
+				<label class="block my-4" for="inp">
+					<span class="text-gray-700"
+						>Description<Required required={false} detail="accept markdown formatting" />
+						<textarea
+							id="inp"
+							bind:value={$flowStore.description}
+							class="
+					mt-1
+					block
+					w-full
+					rounded-md
+					border-gray-300
+					shadow-sm
+					focus:border-indigo-300 focus:ring focus:ring-indigo-200 focus:ring-opacity-50
+					"
+							placeholder="A description to help users understand what this script does and how to use it."
+							rows="3"
+						/>
+					</span>
+				</label>
+
+				<div>
+					<h3 class="text-gray-700 ">Description rendered</h3>
+					<div
+						class="prose mt-5 text-xs shadow-inner shadow-blue p-4 overflow-auto"
+						style="max-height: 200px;"
+					>
+						<SvelteMarkdown source={$flowStore.description ?? ''} />
+					</div>
+				</div>
+			</TabContent>
+			<TabContent value="schedule" class="p-4">
+				<FlowSchedules />
+			</TabContent>
+		</svelte:fragment>
+	</Tabs>
+</FlowCard>

package/components/flows/{FlowSettings.svelte.d.ts → content/FlowSettings.svelte.d.ts}

@@ -1,12 +1,8 @@
 import { SvelteComponentTyped } from "svelte";
 declare const __propDef: {
     props: {
-        pathError?: string | undefined;
-        initialPath?: string | undefined;
-        previewArgs?: Record<string, any> | undefined;
-        scheduleArgs?: Record<string, any> | undefined;
-        scheduleEnabled?: boolean | undefined;
-        scheduleCron?: string | undefined;
+        initialPath: string;
+        defaultTab?: string | undefined;
     };
     events: {
         [evt: string]: CustomEvent<any>;

package/components/flows/content/RemoveStepConfirmationModal.svelte

@@ -0,0 +1,32 @@
+<script>import Alert from '../../common/alert/Alert.svelte';
+import Badge from '../../common/badge/Badge.svelte';
+import ConfirmationModal from '../../common/confirmationModal/ConfirmationModal.svelte';
+import { createEventDispatcher } from 'svelte';
+export let open;
+const dispatch = createEventDispatcher();
+</script>
+
+<ConfirmationModal
+	{open}
+	title="Remove step"
+	confirmationText="Remove"
+	on:canceled={() => {
+		open = false
+		dispatch('canceled')
+	}}
+	on:confirmed={() => {
+		open = false
+		dispatch('confirmed')
+	}}
+>
+	<div class="flex flex-col w-full space-y-4">
+		<span>Are you sure you want to remove this step?</span>
+		<Alert type="info" title="Bypass confirmation">
+			<div>
+				You can press
+				<kbd color="dark-gray">SHIFT</kbd>
+				while removing a step to bypass confirmation.
+			</div>
+		</Alert>
+	</div>
+</ConfirmationModal>

package/components/flows/content/RemoveStepConfirmationModal.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        open: boolean;
+    };
+    events: {
+        canceled: CustomEvent<any>;
+        confirmed: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type RemoveStepConfirmationModalProps = typeof __propDef.props;
+export declare type RemoveStepConfirmationModalEvents = typeof __propDef.events;
+export declare type RemoveStepConfirmationModalSlots = typeof __propDef.slots;
+export default class RemoveStepConfirmationModal extends SvelteComponentTyped<RemoveStepConfirmationModalProps, RemoveStepConfirmationModalEvents, RemoveStepConfirmationModalSlots> {
+}
+export {};

package/components/flows/flowState.d.ts

@@ -1,14 +1,15 @@
 import type { Schema } from '../../common';
 import type { Flow, FlowModule } from '../../gen';
-export declare type FlowModuleSchema = {
-    flowModule: FlowModule;
+export declare type FlowModuleState = {
     schema: Schema;
-    childFlowModules?: FlowModuleSchema[];
+    childFlowModules?: FlowModuleState[];
+    previewArgs?: any;
     previewResult?: any;
 };
-export declare type FlowState = FlowModuleSchema[];
+export declare type FlowState = {
+    modules: FlowModuleState[];
+    failureModule: FlowModuleState;
+};
 export declare const flowStateStore: import("svelte/store").Writable<FlowState>;
 export declare function initFlowState(flow: Flow): Promise<void>;
-export declare const isCopyFirstStepSchemaDisabled: import("svelte/store").Readable<boolean>;
-export declare function flowModulesToFlowState(flowModules: FlowModule[]): Promise<FlowState>;
-export declare function flowStateToFlow(flowState: FlowState, flow: Flow): Flow;
+export declare function mapFlowModules(flowModules: FlowModule[]): Promise<FlowModuleState[]>;

package/components/flows/flowState.js

@@ -1,52 +1,31 @@
-import { derived, writable } from 'svelte/store';
-import { emptyFlowModuleSchema, isEmptyFlowModule, loadFlowModuleSchema } from './flowStateUtils';
-export const flowStateStore = writable(undefined);
+import { writable } from 'svelte/store';
+import { emptyFlowModuleState, isEmptyFlowModule, loadFlowModuleSchema } from './flowStateUtils';
+export const flowStateStore = writable({ modules: [], failureModule: emptyFlowModuleState() });
 export async function initFlowState(flow) {
-    const flowState = await flowModulesToFlowState(flow.value.modules);
-    flowStateStore.set(flowState);
+    const modules = await mapFlowModules(flow.value.modules);
+    const failureModule = flow.value.failure_module
+        ? await mapFlowModule(flow.value.failure_module)
+        : emptyFlowModuleState();
+    flowStateStore.set({
+        modules,
+        failureModule
+    });
 }
-export const isCopyFirstStepSchemaDisabled = derived(flowStateStore, (flowState) => {
-    if (flowState) {
-        const firstModule = flowState[0];
-        if (!firstModule) {
-            return true;
-        }
-        const fm = firstModule.flowModule;
-        return flowState.length === 0 || isEmptyFlowModule(fm);
+async function mapFlowModule(flowModule) {
+    const value = flowModule.value;
+    if (value.type === 'forloopflow') {
+        const childFlowModules = await Promise.all(value.modules.map(async (module) => loadFlowModuleSchema(module)));
+        const loopFlowModule = await loadFlowModuleSchema(flowModule);
+        return {
+            ...loopFlowModule,
+            childFlowModules
+        };
     }
-    else {
-        return true;
+    if (isEmptyFlowModule(flowModule)) {
+        return emptyFlowModuleState();
     }
-});
-export async function flowModulesToFlowState(flowModules) {
-    return Promise.all(flowModules.map(async (flowModule) => {
-        const value = flowModule.value;
-        if (value.type === 'forloopflow') {
-            const childFlowModules = await Promise.all(value.modules.map(async (module) => loadFlowModuleSchema(module)));
-            const loopFlowModule = await loadFlowModuleSchema(flowModule);
-            return {
-                ...loopFlowModule,
-                childFlowModules
-            };
-        }
-        if (isEmptyFlowModule(flowModule)) {
-            return emptyFlowModuleSchema();
-        }
-        return loadFlowModuleSchema(flowModule);
-    }));
+    return loadFlowModuleSchema(flowModule);
 }
-export function flowStateToFlow(flowState, flow) {
-    if (!flowState || !flow) {
-        return flow;
-    }
-    const modules = flowState.map(({ flowModule, childFlowModules }) => {
-        const fmv = flowModule.value;
-        if (fmv.type === 'forloopflow' && childFlowModules && Array.isArray(childFlowModules)) {
-            fmv.modules = childFlowModules.map((cfm) => cfm.flowModule);
-            flowModule.value = fmv;
-        }
-        return flowModule;
-    });
-    flow.value.modules = modules;
-    return flow;
+export async function mapFlowModules(flowModules) {
+    return Promise.all(flowModules.map(async (flowModule) => mapFlowModule(flowModule)));
 }

package/components/flows/flowStateUtils.d.ts

@@ -1,37 +1,39 @@
 import type { Schema } from '../../common';
-import { Job, type FlowModule, type RawScript } from '../../gen';
-import { type FlowModuleSchema, type FlowState } from './flowState';
-export declare function emptyFlowModuleSchema(): FlowModuleSchema;
-export declare function loadFlowModuleSchema(flowModule: FlowModule): Promise<FlowModuleSchema>;
-export declare function pickScript(path: string): Promise<FlowModuleSchema>;
-export declare function createInlineScriptModule({ language, type }: {
+import { Job, Script, type FlowModule, type RawScript } from '../../gen';
+import { type FlowModuleState, type FlowState } from './flowState';
+export declare function emptyFlowModuleState(): FlowModuleState;
+export declare function loadFlowModuleSchema(flowModule: FlowModule): Promise<FlowModuleState>;
+export declare function pickScript(path: string): Promise<[FlowModule, FlowModuleState]>;
+export declare function createInlineScriptModule({ language, kind, subkind }: {
     language: RawScript.language;
-    type: 'trigger' | 'flow' | 'pgsql';
-}): Promise<FlowModuleSchema>;
-export declare function createLoop(): Promise<FlowModuleSchema>;
-export declare function fork(flowModule: FlowModule): Promise<FlowModuleSchema>;
+    kind: Script.kind;
+    subkind: 'pgsql' | 'flow';
+}): Promise<[FlowModule, FlowModuleState]>;
+export declare function createLoop(): Promise<[FlowModule, FlowModuleState]>;
+export declare function fork(flowModule: FlowModule): Promise<[FlowModule, FlowModuleState]>;
 export declare function createInlineScriptModuleFromPath(path: string): Promise<FlowModule>;
 export declare function createScriptFromInlineScript({ flowModule, suffix, schema }: {
     flowModule: FlowModule;
     suffix: string;
     schema: Schema;
-}): Promise<FlowModuleSchema>;
+}): Promise<[FlowModule, FlowModuleState]>;
 export declare function isEmptyFlowModule(flowModule: FlowModule): boolean;
 declare type Result = any;
 declare type PickableProperties = {
     flow_input?: Object;
     previous_result: Result | undefined;
-    step: Result[];
+    step?: Result[];
 };
 declare type StepPropPicker = {
     pickableProperties: PickableProperties;
     extraLib: string;
 };
+export declare const NEVER_TESTED_THIS_FAR = "never tested this far";
 export declare function getStepPropPicker(indexes: number[], flowInputSchema: Schema, flowState: FlowState, args: Record<string, any>): StepPropPicker;
 export declare type JobResult = {
     job?: Job;
-    innerJobs?: JobResult[];
+    innerJobs: JobResult[];
     loopJobs?: JobResult[];
 };
-export declare function mapJobResultsToFlowState(jobs: JobResult, config: 'upto' | 'justthis', configIndex: number): void;
+export declare function mapJobResultsToFlowState(jobs: JobResult, upto: number): void;
 export {};