windmill-components 1.28.7 → 1.34.0

package/components/flows/flowStateUtils.js

@@ -0,0 +1,222 @@
+import { CompletedJob, Job, ScriptService } from '../../gen';
+import { initialCode } from '../../script_helpers';
+import { userStore, workspaceStore } from '../../stores';
+import { buildExtraLib, emptyModule, emptySchema, getScriptByPath, objectToTsType, schemaToObject, schemaToTsType } from '../../utils';
+import { get } from 'svelte/store';
+import { flowStateStore } from './flowState';
+import { flowStore } from './flowStore';
+import { jobsToResults, loadSchemaFromModule } from './utils';
+export function emptyFlowModuleSchema() {
+    return {
+        flowModule: emptyModule(),
+        schema: emptySchema()
+    };
+}
+export async function loadFlowModuleSchema(flowModule) {
+    try {
+        const { input_transform, schema } = await loadSchemaFromModule(flowModule);
+        flowModule.input_transform = input_transform;
+        return { flowModule, schema };
+    }
+    catch (e) {
+        return { flowModule, schema: emptySchema() };
+    }
+}
+export async function pickScript(path) {
+    const flowModule = {
+        value: { type: 'script', path },
+        input_transform: {}
+    };
+    return await loadFlowModuleSchema(flowModule);
+}
+export async function createInlineScriptModule({ language, type }) {
+    const code = initialCode(language, type);
+    const flowModule = {
+        value: { type: 'rawscript', content: code, language },
+        input_transform: {}
+    };
+    return await loadFlowModuleSchema(flowModule);
+}
+export async function createLoop() {
+    const loopFlowModule = {
+        value: {
+            type: 'forloopflow',
+            value: {
+                modules: []
+            },
+            iterator: { type: 'javascript', expr: 'result' },
+            skip_failures: true
+        },
+        input_transform: {}
+    };
+    const { flowModule, schema } = await loadFlowModuleSchema(loopFlowModule);
+    return {
+        flowModule,
+        schema,
+        childFlowModules: [emptyFlowModuleSchema()],
+        previewResult: undefined
+    };
+}
+export async function fork(flowModule) {
+    if (flowModule.value.type !== 'script') {
+        throw new Error('Can only fork a script module');
+    }
+    const fm = await createInlineScriptModuleFromPath(flowModule.value.path ?? '');
+    return await loadFlowModuleSchema(fm);
+}
+export async function createInlineScriptModuleFromPath(path) {
+    const { content, language } = await getScriptByPath(path);
+    return {
+        value: {
+            type: 'rawscript',
+            language: language,
+            content: content,
+            path
+        },
+        input_transform: {}
+    };
+}
+export async function createScriptFromInlineScript({ flowModule, suffix, schema }) {
+    const flow = get(flowStore);
+    const user = get(userStore);
+    if (flowModule.value.type != 'rawscript') {
+        throw new Error("Can't create script from non-inline script");
+    }
+    const originalScriptPath = flowModule.value.path;
+    const wasForked = Boolean(originalScriptPath);
+    if (wasForked && originalScriptPath) {
+        const [first, second, ...others] = originalScriptPath.split('/');
+        suffix = others.join('/');
+    }
+    const path = `${flow.path}/${suffix}`;
+    const forkedDescription = wasForked ? `as a fork of ${originalScriptPath}` : '';
+    const description = `This script was edited in place of flow ${flow.path} ${forkedDescription} by ${user?.username}}.`;
+    const availablePath = await findNextAvailablePath(path);
+    await ScriptService.createScript({
+        workspace: get(workspaceStore),
+        requestBody: {
+            path: availablePath,
+            summary: '',
+            description,
+            content: flowModule.value.content,
+            parent_hash: undefined,
+            schema,
+            is_template: false,
+            language: flowModule.value.language
+        }
+    });
+    return pickScript(availablePath);
+}
+async function findNextAvailablePath(path) {
+    try {
+        await ScriptService.getScriptByPath({
+            workspace: get(workspaceStore),
+            path
+        });
+        const [_, version] = path.split(/.*_([0-9]*)/);
+        if (version.length > 0) {
+            path = path.slice(0, -(version.length + 1));
+        }
+        path = `${path}_${Number(version) + 1}`;
+        return findNextAvailablePath(path);
+    }
+    catch (e) {
+        // Catching an error means the path is available
+        return path;
+    }
+}
+export function isEmptyFlowModule(flowModule) {
+    return flowModule.value.type === 'script' && flowModule.value.path === '';
+}
+export function getStepPropPicker(indexes, flowInputSchema, flowState, args) {
+    const isInsideLoop = indexes.length > 1;
+    const [parentIndex] = indexes;
+    const flowInput = schemaToObject(flowInputSchema, args);
+    const results = getPreviousResults(flowState, parentIndex);
+    const lastResult = results.length > 0 ? results[results.length - 1] : undefined;
+    if (isInsideLoop) {
+        const forLoopFlowInput = {
+            ...flowInput,
+            iter: {
+                value: "Iteration's value",
+                index: "Iteration's index"
+            }
+        };
+        if (Array.isArray(lastResult) && lastResult.length > 0) {
+            const last = lastResult[lastResult.length - 1];
+            forLoopFlowInput.iter = {
+                value: last,
+                index: `Iteration's index (0 to ${lastResult.length - 1})`
+            };
+        }
+        const extraLib = buildExtraLib(objectToTsType(forLoopFlowInput), undefined);
+        return {
+            extraLib,
+            pickableProperties: {
+                flow_input: forLoopFlowInput,
+                step: [],
+                previous_result: {}
+            }
+        };
+    }
+    else {
+        const extraLib = buildExtraLib(schemaToTsType(flowInputSchema), objectToTsType(lastResult));
+        return {
+            extraLib,
+            pickableProperties: {
+                flow_input: flowInput,
+                step: results,
+                previous_result: lastResult
+            }
+        };
+    }
+}
+function getPreviousResults(flowModuleSchemas, target) {
+    if (!Array.isArray(flowModuleSchemas) || target < 1) {
+        return [];
+    }
+    const results = extractPreviewResults(flowModuleSchemas);
+    return results.splice(0, target);
+}
+function extractPreviewResults(flowModuleSchemas) {
+    return flowModuleSchemas.map((fms) => fms.previewResult);
+}
+export function mapJobResultsToFlowState(jobs, config, configIndex) {
+    if (!Array.isArray(jobs.innerJobs) || jobs.innerJobs.length === 0) {
+        return;
+    }
+    if (config === 'justthis') {
+        const job = jobs.job;
+        flowStateStore.update((flowState) => {
+            flowState[configIndex] = job.result;
+            return flowState;
+        });
+    }
+    else {
+        const results = jobs.innerJobs.map(({ job, loopJobs }) => {
+            if (Array.isArray(loopJobs) && loopJobs.length > 0) {
+                return loopJobs.map(({ job }) => {
+                    if (job && 'result' in job) {
+                        return job.result;
+                    }
+                });
+            }
+            else {
+                if (job && 'result' in job) {
+                    return job.result;
+                }
+            }
+        });
+        flowStateStore.update((flowState) => {
+            if (!Array.isArray(flowState)) {
+                return flowState;
+            }
+            return flowState.map((flowModuleSchema, index) => {
+                if (index <= configIndex) {
+                    flowModuleSchema.previewResult = results[index];
+                }
+                return flowModuleSchema;
+            });
+        });
+    }
+}

package/components/flows/flowStore.d.ts

@@ -1,20 +1,5 @@
-import type { Schema } from '../../common';
-import { RawScript, type Flow } from '../../gen';
+import type { Flow } from '../../gen';
 export declare type FlowMode = 'push' | 'pull';
-export declare const mode: import("svelte/store").Writable<FlowMode>;
 export declare const flowStore: import("svelte/store").Writable<Flow>;
-export declare const schemasStore: import("svelte/store").Writable<Schema[]>;
 export declare function initFlow(flow: Flow): void;
-export declare function codeToStaticTemplate(code?: string): string | undefined;
-export declare function flattenForloopFlows(flow: Flow): Flow;
-export declare const isCopyFirstStepSchemaDisabled: import("svelte/store").Readable<boolean>;
-export declare function addModule(i?: number): void;
-export declare function pickScript(path: string, step: number): Promise<void>;
-export declare function createInlineScriptModule(language: RawScript.language, step: number, mode: FlowMode): Promise<void>;
-export declare function loadSchema(step: number): Promise<void>;
-export declare function fork(step: number): Promise<void>;
-export declare function createScriptFromInlineScript(step: number): Promise<void>;
-export declare function removeModule(step: number): void;
 export declare function copyFirstStepSchema(): Promise<void>;
-export declare function findNextAvailablePath(path: string): Promise<string>;
-export declare function shouldPickOrCreateScript(flow: Flow, step: number): boolean;

package/components/flows/flowStore.js

@@ -1,217 +1,16 @@
-import { RawScript, ScriptService } from '../../gen';
-import { initialCode } from '../../script_helpers';
-import { userStore, workspaceStore } from '../../stores';
-import { emptySchema } from '../../utils';
-import { derived, get, writable } from 'svelte/store';
-import { createInlineScriptModuleFromPath, getFirstStepSchema, loadSchemaFromModule, scrollIntoView } from './utils';
-export const mode = writable('push');
+import { get, writable } from 'svelte/store';
+import { flowStateStore, initFlowState } from './flowState';
 export const flowStore = writable(undefined);
-export const schemasStore = writable([]);
 export function initFlow(flow) {
-    const newMode = flow.value.modules[1]?.value.type === 'forloopflow' ? 'pull' : 'push';
-    mode.set(newMode);
-    flow = flattenForloopFlows(flow);
-    flow.value.modules.forEach((mod) => {
-        Object.values(mod.input_transform).forEach((inp) => {
-            if (inp.type == 'javascript') {
-                // for now we use the value for dynamic expression when done in the static editor so we have to resort to this
-                //@ts-ignore
-                inp.value = codeToStaticTemplate(inp.expr);
-            }
-        });
-    });
-    schemasStore.set([]);
     flowStore.set(flow);
-    // For each module in flow, we should load the corresponding schema
-    flow.value.modules.forEach((_, index) => {
-        loadSchema(index);
-    });
-}
-export function codeToStaticTemplate(code) {
-    if (!code)
-        return undefined;
-    const lines = code
-        .split('\n')
-        .slice(1)
-        .filter((x) => x != '');
-    if (lines.length == 1) {
-        const line = lines[0].trim();
-        if (line[0] == '`' && line.charAt(line.length - 1) == '`') {
-            return line.slice(1, line.length - 1);
-        }
-    }
-    return undefined;
-}
-export function flattenForloopFlows(flow) {
-    let newFlow = JSON.parse(JSON.stringify(flow));
-    const mod = newFlow.value.modules[1]?.value;
-    if (mod?.type === 'forloopflow') {
-        const oldModules = mod.value?.modules ?? [];
-        newFlow.value.modules = newFlow.value.modules.slice(0, 1);
-        newFlow.value.modules.push(...oldModules);
-    }
-    return newFlow;
-}
-export const isCopyFirstStepSchemaDisabled = derived(flowStore, (flow) => {
-    if (flow) {
-        const modules = flow.value.modules;
-        const [firstModule] = modules;
-        return (modules.length === 0 || (firstModule.value.type === 'script' && firstModule.value.path === ''));
-    }
-    else {
-        return true;
-    }
-});
-export function addModule(i) {
-    const newModule = {
-        value: { type: 'script', path: '' },
-        input_transform: {}
-    };
-    flowStore.update((flow) => {
-        const insertAt = i ?? flow.value.modules.length;
-        flow.value.modules.splice(insertAt, 0, newModule);
-        flow.value.modules = flow.value.modules;
-        setTimeout(() => scrollIntoView(document.querySelector(`#module-${insertAt}`)), 100);
-        return flow;
-    });
-    schemasStore.update((schemas) => {
-        if (typeof i !== 'undefined') {
-            const previousSchema = schemas[i];
-            const hadSchema = Boolean(previousSchema);
-            if (hadSchema) {
-                schemas[i] = emptySchema();
-                schemas[i + 1] = previousSchema;
-            }
-        }
-        return schemas;
-    });
-}
-export async function pickScript(path, step) {
-    flowStore.update((flow) => {
-        if (flow.value.modules[step]) {
-            flow.value.modules[step].value = { type: 'script', path };
-        }
-        return flow;
-    });
-    await loadSchema(step);
-}
-export async function createInlineScriptModule(language, step, mode) {
-    const code = initialCode(language, mode === 'pull' && step == 0);
-    flowStore.update((flow) => {
-        flow.value.modules[step].value = {
-            type: 'rawscript',
-            content: code,
-            language
-        };
-        return flow;
-    });
-    await loadSchema(step);
-}
-export async function loadSchema(step) {
-    const flow = get(flowStore);
-    const module = flow.value.modules[step];
-    const { input_transform, schema } = await loadSchemaFromModule(module);
-    flowStore.update((flow) => {
-        flow.value.modules[step].input_transform = input_transform;
-        return flow;
-    });
-    schemasStore.update((schemas) => {
-        schemas[step] = schema;
-        return schemas;
-    });
-}
-export async function fork(step) {
-    const flow = get(flowStore);
-    const flowModuleValue = flow.value.modules[step].value;
-    if (flowModuleValue.type !== 'script') {
-        throw new Error('Can only fork a script module');
-    }
-    if (flowModuleValue.path) {
-        const moduleValue = await createInlineScriptModuleFromPath(flowModuleValue.path);
-        flowStore.update((flow) => {
-            flow.value.modules[step].value = moduleValue;
-            return flow;
-        });
-    }
-}
-export async function createScriptFromInlineScript(step) {
-    const flow = get(flowStore);
-    const schemas = get(schemasStore);
-    const user = get(userStore);
-    const flowModuleValue = flow.value.modules[step].value;
-    if (flowModuleValue.type != 'rawscript') {
-        throw new Error("Can't create script from non-inline script");
-    }
-    const originalScriptPath = flowModuleValue.path;
-    const wasForked = Boolean(originalScriptPath);
-    let suffix = `step-${step}`;
-    if (wasForked && originalScriptPath) {
-        const [first, second, ...others] = originalScriptPath.split('/');
-        suffix = others.join('/');
-    }
-    const path = `${flow.path}/${suffix}`;
-    const forkedDescription = wasForked ? `as a fork of ${originalScriptPath}` : '';
-    const description = `This script was edited in place of flow ${flow.path} ${forkedDescription} by ${user?.username} at step ${step}.`;
-    const availablePath = await findNextAvailablePath(path);
-    await ScriptService.createScript({
-        workspace: get(workspaceStore),
-        requestBody: {
-            path: availablePath,
-            summary: '',
-            description,
-            content: flowModuleValue.content,
-            parent_hash: undefined,
-            schema: schemas[step],
-            is_template: false,
-            language: flowModuleValue.language
-        }
-    });
-    flowStore.update((flow) => {
-        flow.value.modules[step].value = {
-            type: 'script',
-            path: availablePath
-        };
-        return flow;
-    });
-    await loadSchema(step);
-}
-export function removeModule(step) {
-    flowStore.update((flow) => {
-        flow.value.modules.splice(step, 1);
-        return flow;
-    });
-    schemasStore.update((schemas) => {
-        schemas.splice(step, 1);
-        return schemas;
-    });
+    initFlowState(flow);
 }
 export async function copyFirstStepSchema() {
-    const flow = get(flowStore);
-    const flowSchema = await getFirstStepSchema(flow);
+    const flowState = get(flowStateStore);
     flowStore.update((flow) => {
-        flow.schema = flowSchema;
+        if (flowState[0].schema) {
+            flow.schema = flowState[0].schema;
+        }
         return flow;
     });
 }
-export async function findNextAvailablePath(path) {
-    try {
-        await ScriptService.getScriptByPath({
-            workspace: get(workspaceStore),
-            path
-        });
-        const [_, version] = path.split(/.*_([0-9]*)/);
-        if (version.length > 0) {
-            path = path.slice(0, -(version.length + 1));
-        }
-        path = `${path}_${Number(version) + 1}`;
-        return findNextAvailablePath(path);
-    }
-    catch (e) {
-        // Catching an error means the path is available
-        return path;
-    }
-}
-export function shouldPickOrCreateScript(flow, step) {
-    const module = flow.value.modules[step];
-    return module.value.type === 'script' && module.value.path === '';
-}

package/components/flows/pickers/FlowScriptPicker.svelte

@@ -1,16 +1,12 @@
-<script>import { Tooltip } from 'flowbite-svelte';
+<script>import { Button } from 'flowbite-svelte';
 import Icon from 'svelte-awesome';
 export let disabled = false;
 export let icon;
 export let label;
 export let iconColor;
-export let tooltip = undefined;
 </script>
 
-<button {disabled} type="button" on:click class="default-secondary-button-v2 mb-2 w-full">
-	<Icon data={icon} class={`w-4 h-4 mr-2 -ml-2 ${iconColor}`} />
-	{label}
-	{#if tooltip}
-		<Tooltip placement="bottom" content={tooltip}>(?)</Tooltip>
-	{/if}
-</button>
+<Button {disabled} on:click size="md" class="text-left" color="alternative">
+	<Icon data={icon} class={`mr-2 ${iconColor} w-4`} scale={1.5} />
+	<span class="text-sm text-left"> {label} </span>
+</Button>

package/components/flows/pickers/FlowScriptPicker.svelte.d.ts

@@ -6,7 +6,6 @@ declare const __propDef: {
         icon: IconDefinition;
         label: string;
         iconColor: string;
-        tooltip?: string | undefined;
     };
     events: {
         click: MouseEvent;

package/components/flows/pickers/PickHubScript.svelte

@@ -3,7 +3,7 @@ import FlowScriptPicker from './FlowScriptPicker.svelte';
 import ItemPicker from '../../ItemPicker.svelte';
 import { hubScripts } from '../../../stores';
 import { createEventDispatcher } from 'svelte';
-export let isTrigger;
+export let isTrigger = false;
 let items;
 $: items = $hubScripts?.filter((x) => x.is_trigger == isTrigger) ?? [];
 let itemPicker;

package/components/flows/pickers/PickHubScript.svelte.d.ts

@@ -1,7 +1,7 @@
 import { SvelteComponentTyped } from "svelte";
 declare const __propDef: {
     props: {
-        isTrigger: boolean;
+        isTrigger?: boolean | undefined;
     };
     events: {
         pick: CustomEvent<any>;

package/components/flows/pickers/PickScript.svelte

@@ -4,7 +4,7 @@ import { ScriptService } from '../../../gen';
 import { workspaceStore } from '../../../stores';
 import { createEventDispatcher } from 'svelte';
 import FlowScriptPicker from './FlowScriptPicker.svelte';
-export let isTrigger;
+export let isTrigger = false;
 let items = [];
 let itemPicker;
 const dispatch = createEventDispatcher();

package/components/flows/pickers/PickScript.svelte.d.ts

@@ -1,7 +1,7 @@
 import { SvelteComponentTyped } from "svelte";
 declare const __propDef: {
     props: {
-        isTrigger: boolean;
+        isTrigger?: boolean | undefined;
     };
     events: {
         pick: CustomEvent<any>;

package/components/flows/scheduleUtils.d.ts

@@ -0,0 +1,7 @@
+export declare type Schedule = {
+    args: Record<string, any>;
+    cron: string;
+    enabled: boolean;
+    previewArgs: Record<string, any>;
+};
+export declare function loadFlowSchedule(path: string, workspace?: string): Promise<Schedule>;

package/components/flows/scheduleUtils.js

@@ -0,0 +1,21 @@
+import { ScheduleService } from '../../gen';
+// Load the schedule of a flow given its path and the workspace
+export async function loadFlowSchedule(path, workspace = '') {
+    const existsSchedule = await ScheduleService.existsSchedule({
+        workspace,
+        path
+    });
+    if (!existsSchedule) {
+        throw new Error(`Flow at path: ${path} doesn't exit`);
+    }
+    const schedule = await ScheduleService.getSchedule({
+        workspace,
+        path
+    });
+    return {
+        enabled: schedule.enabled,
+        cron: schedule.schedule,
+        args: schedule.args ?? {},
+        previewArgs: JSON.parse(JSON.stringify(schedule.args))
+    };
+}

package/components/flows/stepOpenedStore.d.ts

@@ -0,0 +1 @@
+export declare const stepOpened: import("svelte/store").Writable<string | undefined>;

package/components/flows/stepOpenedStore.js

@@ -0,0 +1,6 @@
+import { writable } from 'svelte/store';
+import { scrollIntoView } from './utils';
+export const stepOpened = writable(undefined);
+stepOpened.subscribe((insertAt) => {
+    setTimeout(() => scrollIntoView(document.querySelector(`#module-${insertAt}`)), 100);
+});

package/components/flows/utils.d.ts

@@ -1,21 +1,14 @@
 import type { Schema } from '../../common';
-import { type Flow, type FlowModule, type FlowModuleValue, type InputTransform, type Job } from '../../gen';
-import { type FlowMode } from './flowStore';
-export declare function flowToMode(flow: Flow | any, mode: FlowMode): Flow;
+import { type Flow, type FlowModule, type InputTransform, type Job } from '../../gen';
+export declare function cleanInputs(flow: Flow | any): Flow;
 export declare function getTypeAsString(arg: any): string;
-export declare function getFirstStepSchema(flow: Flow): Promise<Schema>;
-export declare function createInlineScriptModuleFromPath(path: string): Promise<FlowModuleValue>;
-export declare function scrollIntoView(el: any): void;
+export declare function scrollIntoView(element: any): void;
 export declare function loadSchemaFromModule(module: FlowModule): Promise<{
     input_transform: Record<string, InputTransform>;
     schema: Schema;
 }>;
 export declare function isCodeInjection(expr: string | undefined): boolean;
-export declare function getDefaultExpr(i: number, key?: string, previousExpr?: string): string;
-export declare function getPickableProperties(schema: Schema, args: Record<string, any>, previewResults: Record<number, Object>, mode: FlowMode, i: number): {
-    flow_input: any;
-    previous_result: any;
-    step: any[];
-};
+export declare function getDefaultExpr(importPath?: string | undefined, key?: string, previousExpr?: string): string;
 export declare function jobsToResults(jobs: Job[]): any;
 export declare function runFlowPreview(args: Record<string, any>, flow: Flow): Promise<string>;
+export declare function codeToStaticTemplate(code?: string): string | undefined;