windmill-components 1.493.10 → 1.501.5

package/package/components/flows/propPicker/StepHistory.svelte.d.ts

@@ -4,6 +4,16 @@ export type StepHistoryData = {
     created_by: string;
     success: boolean;
 };
+interface Props {
+    selected?: string | undefined;
+    moduleId?: string;
+    getLogs?: boolean;
+    mockValue?: any;
+    mockEnabled?: boolean;
+    path?: string;
+    staticInputs?: undefined | StepHistoryData[];
+    noHistory?: 'isLoop' | 'isInsideLoop' | undefined;
+}
 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;
@@ -17,23 +27,13 @@ interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> =
     };
     z_$$bindings?: Bindings;
 }
-declare const StepHistory: $$__sveltets_2_IsomorphicComponent<{
-    selected?: string | undefined;
-    moduleId?: string;
-    getLogs?: boolean;
-    mockValue?: any;
-    mockEnabled?: boolean;
-    path?: string;
-    staticInputs?: undefined | StepHistoryData[];
-    noHistory?: "isLoop" | "isInsideLoop" | undefined;
-    deselect?: () => void;
-}, {
+declare const StepHistory: $$__sveltets_2_IsomorphicComponent<Props, {
     error: CustomEvent<any>;
     select: CustomEvent<any>;
 } & {
     [evt: string]: CustomEvent<any>;
 }, {}, {
     deselect: () => void;
-}, string>;
+}, "selected">;
 type StepHistory = InstanceType<typeof StepHistory>;
 export default StepHistory;

package/package/components/flows/scheduleUtils.js

@@ -2,6 +2,7 @@ import { ScheduleService } from '../../gen';
 import { writable } from 'svelte/store';
 import { get } from 'svelte/store';
 import { sendUserToast } from '../../utils';
+import { stateSnapshot } from '../../svelte5Utils.svelte';
 // Load the schedule of a flow given its path and the workspace
 export async function loadSchedule(path, workspace) {
     const existsSchedule = await ScheduleService.existsSchedule({
@@ -27,7 +28,7 @@ export async function loadSchedules(forceRefresh, path, isFlow, schedules, prima
     if (!path || path == '') {
         schedules.set([]);
         primarySchedule.update((ps) => (ps === undefined ? false : ps));
-        initialPrimarySchedule.set(structuredClone(get(primarySchedule)));
+        initialPrimarySchedule.set(structuredClone(stateSnapshot(get(primarySchedule))));
         return;
     }
     try {
@@ -56,7 +57,7 @@ export async function loadSchedules(forceRefresh, path, isFlow, schedules, prima
                 : false;
         }
         primarySchedule.update((ps) => (ps === undefined || forceRefresh ? remotePrimarySchedule : ps));
-        initialPrimarySchedule.set(structuredClone(remotePrimarySchedule));
+        initialPrimarySchedule.set(structuredClone(stateSnapshot(remotePrimarySchedule)));
         triggersCount.update((tc) => {
             const primary = get(primarySchedule);
             return {

package/package/components/flows/testSteps.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { FlowModule, OpenFlow } from '../../gen';
+import type { FlowState } from './flowState';
+import { type PickableProperties } from './previousResults';
+import { type ModuleArgs } from './utils';
+export declare class TestSteps {
+    #private;
+    constructor();
+    setStepArgsManually(moduleId: string, args: Record<string, any>): void;
+    getStepArgs(moduleId: string): ModuleArgs | undefined;
+    setStepArgs(moduleId: string, args: Record<string, any>): void;
+    getStepArg(moduleId: string, argName: string): any | undefined;
+    setEvaluatedStepArg(moduleId: string, argName: string, value: any): void;
+    isArgManuallySet(moduleId: string, argName: string): boolean;
+    getManuallyEditedArgs(moduleId: string): string[];
+    evalArg(moduleId: string, argName: string, flowState: FlowState | undefined, flow: OpenFlow | undefined, previewArgs: Record<string, any> | undefined): void;
+    initializeFromSchema(mod: FlowModule, schema: {
+        properties?: Record<string, any>;
+    }, pickableProperties: PickableProperties | undefined): void;
+    updateStepArgs(id: string, flowState: FlowState | undefined, flow: OpenFlow | undefined, previewArgs: Record<string, any> | undefined): void;
+    removeExtraKey(moduleId: string, keys: string[]): void;
+}

package/package/components/flows/testSteps.svelte.js

@@ -0,0 +1,122 @@
+import { dfs, getPreviousModule, getStepPropPicker } from './previousResults';
+import { evalValue } from './utils';
+export class TestSteps {
+    #stepsEvaluated = $state({});
+    #steps = $state({});
+    constructor() { }
+    setStepArgsManually(moduleId, args) {
+        if (!this.#steps[moduleId]) {
+            this.#steps[moduleId] = { value: {} };
+        }
+        this.#steps[moduleId].value = args;
+    }
+    getStepArgs(moduleId) {
+        return this.#steps[moduleId];
+    }
+    setStepArgs(moduleId, args) {
+        if (!this.#steps[moduleId]) {
+            this.#steps[moduleId] = { value: {} };
+        }
+        this.#steps[moduleId].value = args;
+    }
+    getStepArg(moduleId, argName) {
+        return this.#steps[moduleId]?.[argName];
+    }
+    setEvaluatedStepArg(moduleId, argName, value) {
+        if (!this.#steps[moduleId]) {
+            this.#steps[moduleId] = { value: {} };
+        }
+        if (!this.#stepsEvaluated[moduleId]) {
+            this.#stepsEvaluated[moduleId] = { value: {} };
+        }
+        this.#steps[moduleId].value[argName] = $state.snapshot(value);
+        this.#stepsEvaluated[moduleId].value[argName] = $state.snapshot(value);
+    }
+    isArgManuallySet(moduleId, argName) {
+        return (JSON.stringify(this.#steps[moduleId]?.value?.[argName]) !==
+            JSON.stringify(this.#stepsEvaluated[moduleId]?.value?.[argName]));
+    }
+    getManuallyEditedArgs(moduleId) {
+        const manuallyEditedArgs = [];
+        const moduleArgs = this.#steps[moduleId]?.value ?? {};
+        Object.keys(moduleArgs).forEach((argName) => {
+            if (this.isArgManuallySet(moduleId, argName)) {
+                manuallyEditedArgs.push(argName);
+            }
+        });
+        return manuallyEditedArgs;
+    }
+    /*
+        Evaluate the arg value from the flow state and replace the test value.
+    */
+    evalArg(moduleId, argName, flowState, flow, previewArgs) {
+        if (!flowState || !flow) {
+            return;
+        }
+        const modules = dfs(moduleId, flow, true);
+        const previousModule = getPreviousModule(moduleId, flow);
+        if (modules.length < 1) {
+            return;
+        }
+        let parentModule = undefined;
+        if (modules.length > 1) {
+            parentModule = modules[modules.length - 1];
+        }
+        const stepPropPicker = getStepPropPicker(flowState, parentModule, previousModule, moduleId, flow, previewArgs, false);
+        const pickableProperties = stepPropPicker.pickableProperties;
+        const argSnapshot = $state.snapshot(evalValue(argName, modules[0], pickableProperties, false));
+        this.#stepsEvaluated[moduleId].value[argName] = argSnapshot;
+        this.#steps[moduleId].value[argName] = structuredClone(argSnapshot);
+    }
+    initializeFromSchema(mod, schema, pickableProperties) {
+        const args = Object.fromEntries(Object.keys(schema.properties ?? {}).map((k) => [
+            k,
+            evalValue(k, mod, pickableProperties, false)
+        ]));
+        const manuallyEditedArgs = this.getManuallyEditedArgs(mod.id);
+        if (!this.#steps[mod.id]) {
+            this.#steps[mod.id] = { value: {} };
+        }
+        if (!this.#stepsEvaluated[mod.id]) {
+            this.#stepsEvaluated[mod.id] = { value: {} };
+        }
+        this.#stepsEvaluated[mod.id].value = $state.snapshot(args);
+        // Preserve manually edited args
+        const argsSnapshot = $state.snapshot(args);
+        Object.keys(argsSnapshot).forEach((key) => {
+            if (manuallyEditedArgs.includes(key)) {
+                argsSnapshot[key] = this.#steps[mod.id]?.value?.[key];
+            }
+        });
+        this.#steps[mod.id].value = argsSnapshot;
+    }
+    updateStepArgs(id, flowState, flow, previewArgs) {
+        if (!flowState || !flow) {
+            return;
+        }
+        const modules = dfs(id, flow, true);
+        const previousModule = getPreviousModule(id, flow);
+        if (modules.length < 1) {
+            return;
+        }
+        let parentModule = undefined;
+        if (modules.length > 1) {
+            parentModule = modules[modules.length - 1];
+        }
+        const stepPropPicker = getStepPropPicker(flowState, parentModule, previousModule, id, flow, previewArgs, false);
+        const pickableProperties = stepPropPicker.pickableProperties;
+        this.initializeFromSchema(modules[0], flowState[id]?.schema ?? {}, pickableProperties);
+    }
+    removeExtraKey(moduleId, keys) {
+        if (!this.#stepsEvaluated[moduleId]) {
+            return;
+        }
+        const nargs = {};
+        Object.keys(this.#stepsEvaluated[moduleId]?.value ?? {}).forEach((key) => {
+            if (keys.includes(key)) {
+                nargs[key] = this.#stepsEvaluated[moduleId]?.value?.[key];
+            }
+        });
+        this.#stepsEvaluated[moduleId].value = nargs;
+    }
+}

package/package/components/flows/types.d.ts

@@ -1,9 +1,13 @@
-import type { FlowModule, OpenFlow } from '../../gen';
+import type { OpenFlow } from '../../gen';
 import type { History } from '../../history';
 import type { Writable } from 'svelte/store';
 import type ScriptEditorDrawer from './content/ScriptEditorDrawer.svelte';
 import type { FlowState } from './flowState';
 import type { FlowBuilderWhitelabelCustomUi } from '../custom_ui';
+import type Editor from '../Editor.svelte';
+import type SimpleEditor from '../SimpleEditor.svelte';
+import type { StateStore } from '../../utils';
+import type { TestSteps } from './testSteps.svelte';
 export type FlowInput = Record<string, {
     flowStepWarnings?: Record<string, {
         message: string;
@@ -22,20 +26,33 @@ export type FlowInputEditorState = {
     editPanelSize: number | undefined;
     payloadData: Record<string, any> | undefined;
 };
+export type CurrentEditor = (({
+    type: 'script';
+    editor: Editor;
+    showDiffMode: () => void;
+    hideDiffMode: () => void;
+    diffMode: boolean;
+    lastDeployedCode: string | undefined;
+} | {
+    type: 'iterator';
+    editor: SimpleEditor;
+}) & {
+    stepId: string;
+}) | undefined;
 export type FlowEditorContext = {
     selectedId: Writable<string>;
+    currentEditor: Writable<CurrentEditor>;
     moving: Writable<{
-        module: FlowModule;
-        modules: FlowModule[];
+        id: string;
     } | undefined>;
-    previewArgs: Writable<Record<string, any>>;
+    previewArgs: StateStore<Record<string, any>>;
     scriptEditorDrawer: Writable<ScriptEditorDrawer | undefined>;
     history: History<OpenFlow>;
     pathStore: Writable<string>;
-    flowStore: Writable<ExtendedOpenFlow>;
+    flowStore: StateStore<ExtendedOpenFlow>;
     flowInputEditorState: Writable<FlowInputEditorState>;
     flowStateStore: Writable<FlowState>;
-    testStepStore: Writable<Record<string, any>>;
+    testSteps: TestSteps;
     saveDraft: () => void;
     initialPathStore: Writable<string>;
     fakeInitialPath: string;

package/package/components/flows/utils.d.ts

@@ -1,9 +1,11 @@
-import { type FlowModule, type InputTransform, type Job, type RestartedFrom, type OpenFlow, type FlowModuleValue } from '../../gen';
+import { type FlowModule, type Job, type RestartedFrom, type OpenFlow } from '../../gen';
 import type { FlowModuleState } from './flowState';
 import { type PickableProperties } from './previousResults';
-import type { Schema } from '../../common';
 import type { ExtendedOpenFlow } from './types';
-export declare function evalValue(k: string, mod: FlowModule, testStepStore: Record<string, any>, pickableProperties: PickableProperties | undefined, showError: boolean): any;
+export type ModuleArgs = {
+    value: Record<string, any>;
+};
+export declare function evalValue(k: string, mod: FlowModule, pickableProperties: PickableProperties | undefined, showError: boolean): any;
 export declare function filteredContentForExport(flow: ExtendedOpenFlow): {
     summary: string;
     description: string | undefined;
@@ -26,18 +28,6 @@ export declare function runFlowPreview(args: Record<string, any>, flow: OpenFlow
 }, path: string, restartedFrom: RestartedFrom | undefined): Promise<string>;
 export declare function codeToStaticTemplate(code?: string): string | undefined;
 export declare function emptyFlowModuleState(): FlowModuleState;
-export declare function isInputFilled(inputTransforms: Record<string, InputTransform>, key: string, schema: Schema | undefined): boolean;
-export declare function computeFlowStepWarning(argName: string, flowModuleValue: FlowModuleValue, messages: Record<string, {
-    message: string;
-    type: 'error' | 'warning';
-}>, schema: Schema | undefined, moduleIds?: string[]): Promise<Record<string, {
-    message: string;
-    type: "error" | "warning";
-}>>;
-export declare function initFlowStepWarnings(flowModuleValue: FlowModuleValue, schema: Schema | undefined, moduleIds?: string[]): Promise<Record<string, {
-    message: string;
-    type: "error" | "warning";
-}>>;
 export declare function checkIfParentLoop(flowStore: ExtendedOpenFlow, modId: string): {
     id: string;
     type: 'forloopflow' | 'whileloopflow';

package/package/components/flows/utils.js

@@ -5,7 +5,6 @@ import { get } from 'svelte/store';
 import { dfs } from './previousResults';
 import { NEVER_TESTED_THIS_FAR } from './models';
 import { sendUserToast } from '../../toast';
-import { parseOutputs } from '../../infer';
 function create_context_function_template(eval_string, context) {
     return `
 return function (context) {
@@ -21,33 +20,28 @@ function make_context_evaluator(eval_string, context) {
     let functor = Function(template);
     return functor();
 }
-export function evalValue(k, mod, testStepStore, pickableProperties, showError) {
+export function evalValue(k, mod, pickableProperties, showError) {
     let inputTransforms = (mod.value['input_transforms'] ?? {});
-    let v = testStepStore[mod.id]?.[k];
+    let v;
     let t = inputTransforms?.[k];
-    if (!v) {
-        if (t.type == 'static') {
-            v = t.value;
+    if (t.type == 'static') {
+        v = t.value;
+    }
+    else {
+        try {
+            let context = {
+                flow_input: pickableProperties?.flow_input,
+                results: pickableProperties?.priorIds
+            };
+            v = make_context_evaluator(t.expr, context)(context);
         }
-        else {
-            try {
-                let context = {
-                    flow_input: pickableProperties?.flow_input,
-                    results: pickableProperties?.priorIds
-                };
-                v = make_context_evaluator(t.expr, context)(context);
-            }
-            catch (e) {
-                if (showError) {
-                    sendUserToast(`Error evaluating ${k}: ${e.message}`, true);
-                }
-                v = undefined;
+        catch (e) {
+            if (showError) {
+                sendUserToast(`Error evaluating ${k}: ${e.message}`, true);
             }
+            v = undefined;
         }
     }
-    if (v == NEVER_TESTED_THIS_FAR) {
-        return undefined;
-    }
     return v;
 }
 export function filteredContentForExport(flow) {
@@ -144,86 +138,6 @@ export function emptyFlowModuleState() {
         previewResult: NEVER_TESTED_THIS_FAR
     };
 }
-export function isInputFilled(inputTransforms, key, schema) {
-    const required = schema?.required?.includes(key) ?? false;
-    if (!required) {
-        return true;
-    }
-    if (inputTransforms.hasOwnProperty(key)) {
-        const transform = inputTransforms[key];
-        if (transform?.type === 'static' &&
-            (transform?.value === undefined || transform?.value === '' || transform?.value === null)) {
-            return false;
-        }
-        else if (transform?.type === 'javascript' &&
-            (transform?.expr === undefined || transform?.expr === '' || transform?.expr === null)) {
-            return false;
-        }
-    }
-    return true;
-}
-async function isConnectedToMissingModule(argName, flowModuleValue, moduleIds) {
-    const type = flowModuleValue.type;
-    if (type === 'rawscript' || type === 'script' || type === 'flow') {
-        const input = flowModuleValue?.input_transforms[argName];
-        const val = input.type === 'static' ? String(input.value) : input.expr;
-        try {
-            const outputs = await parseOutputs(val, true);
-            let error = '';
-            outputs?.forEach(([componentId, id]) => {
-                if (componentId === 'results') {
-                    if (!moduleIds.includes(id)) {
-                        error += `Input ${argName} is connected to a missing module with id ${id}\n`;
-                    }
-                }
-            });
-            return error;
-        }
-        catch (e) {
-            return `Input ${argName} expression is invalid`;
-        }
-    }
-    return;
-}
-export async function computeFlowStepWarning(argName, flowModuleValue, messages, schema, moduleIds = []) {
-    if (messages[argName]) {
-        delete messages[argName];
-    }
-    const type = flowModuleValue.type;
-    if (type == 'rawscript' || type == 'script' || type == 'flow') {
-        if (!isInputFilled(flowModuleValue.input_transforms, argName, schema)) {
-            messages[argName] = {
-                message: `Input ${argName} is required but not filled`,
-                type: 'warning'
-            };
-        }
-        const errorMessage = await isConnectedToMissingModule(argName, flowModuleValue, moduleIds);
-        if (errorMessage) {
-            messages[argName] = {
-                message: errorMessage,
-                type: 'error'
-            };
-        }
-        else {
-            if (messages[argName]?.type === 'error') {
-                delete messages[argName];
-            }
-        }
-    }
-    return messages;
-}
-export async function initFlowStepWarnings(flowModuleValue, schema, moduleIds = []) {
-    const messages = {};
-    const type = flowModuleValue.type;
-    if (type == 'rawscript' || type == 'script' || type == 'flow') {
-        const keys = Object.keys(flowModuleValue.input_transforms ?? {});
-        const promises = keys.map(async (key) => {
-            await computeFlowStepWarning(key, flowModuleValue, messages, schema, moduleIds);
-        });
-        await Promise.all(promises);
-    }
-    return messages;
-}
 export function checkIfParentLoop(flowStore, modId) {
     const flow = JSON.parse(JSON.stringify(flowStore));
     const parents = dfs(modId, flow, true);