windmill-components 1.447.7 → 1.448.1

package/package/components/flows/flowStateUtils.d.ts

@@ -11,7 +11,7 @@ export declare function pickScript(path: string, summary: string, id: string, ha
 export declare function pickFlow(path: string, summary: string, id: string): Promise<[FlowModule & {
     value: PathFlow;
 }, FlowModuleState]>;
-export declare function createInlineScriptModule(language: RawScript['language'], kind: Script['kind'], subkind: 'pgsql' | 'flow' | 'preprocessor', id: string, summary?: string): Promise<[FlowModule, FlowModuleState]>;
+export declare function createInlineScriptModule(language: RawScript['language'], kind: Script['kind'], subkind: 'pgsql' | 'flow' | undefined, id: string, summary?: string): Promise<[FlowModule, FlowModuleState]>;
 export declare function createLoop(id: string, enabledAi: boolean): Promise<[FlowModule, FlowModuleState]>;
 export declare function createWhileLoop(id: string): Promise<[FlowModule, FlowModuleState]>;
 export declare function createBranches(id: string): Promise<[FlowModule, FlowModuleState]>;
@@ -28,7 +28,6 @@ export declare function deleteFlowStateById(id: string, flowStateStore: Writable
 export declare function sliceModules(modules: FlowModule[], upTo: number, idOrders: string[]): FlowModule[];
 export declare function insertNewPreprocessorModule(flowStore: Writable<ExtendedOpenFlow>, flowStateStore: Writable<FlowState>, inlineScript?: {
     language: RawScript['language'];
-    subkind: 'preprocessor';
 }, wsScript?: {
     path: string;
     summary: string;

package/package/components/flows/flowStateUtils.js

@@ -219,7 +219,7 @@ export async function insertNewPreprocessorModule(flowStore, flowStateStore, inl
     var state = emptyFlowModuleState();
     if (inlineScript) {
         ;
-        [module, state] = await createInlineScriptModule(inlineScript.language, 'script', inlineScript.subkind, 'preprocessor');
+        [module, state] = await createInlineScriptModule(inlineScript.language, 'preprocessor', undefined, 'preprocessor');
     }
     else if (wsScript) {
         ;

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

@@ -1,7 +1,7 @@
 import { SvelteComponent } from "svelte";
 declare const __propDef: {
     props: {
-        kind?: "script" | "failure" | "trigger" | "approval" | "flow" | "preprocessor" | undefined;
+        kind?: "script" | "failure" | "trigger" | "approval" | "preprocessor" | "flow" | undefined;
         isTemplate?: boolean | undefined;
         selected?: number | undefined;
         displayPath?: boolean | undefined;

package/package/components/meltComponents/SideBarTab.svelte

@@ -0,0 +1,60 @@
+<script>export let dropdownItems = [];
+export let fullMenu = false;
+let open = false;
+let timeout = null;
+function handleMouseEnter() {
+    if (!fullMenu)
+        return;
+    timeout = setTimeout(() => {
+        open = true;
+    }, 500);
+}
+function handleMouseLeave() {
+    if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+    }
+    open = false;
+}
+</script>
+
+<!-- svelte-ignore a11y-no-static-element-interactions -->
+<div
+	class="flex flex-col relative !overflow-visible"
+	on:mouseenter={handleMouseEnter}
+	on:mouseleave={handleMouseLeave}
+>
+	<slot name="close button" />
+
+	{#if fullMenu}
+		<div
+			class="absolute flex-col top-[30px] left-0 z-50 bg-surface border-l border-b {open
+				? 'rounded-md rounded-tl-none overflow-hidden shadow-md'
+				: 'rounded-bl-md'}"
+		>
+			{#each dropdownItems as item}
+				<button
+					class="hover:bg-surface-hover p-2 transition-colors duration-150 w-full {item.selected
+						? 'bg-surface-selected'
+						: 'text-secondary'}"
+					on:click={() => {
+						item.onClick()
+						open = false
+					}}
+				>
+					<div class="flex flex-row items-center gap-2 min-h-[20px]">
+						{#if item.icon}
+							<svelte:component this={item.icon} size={14} />
+						{/if}
+
+						{#if open}
+							<p class="text-xs text-secondary whitespace-nowrap text-left">
+								{item.label}
+							</p>
+						{/if}
+					</div>
+				</button>
+			{/each}
+		</div>
+	{/if}
+</div>

package/package/components/meltComponents/SideBarTab.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        dropdownItems?: {
+            label: string;
+            onClick: () => void;
+            icon?: any;
+            selected?: boolean | undefined;
+        }[] | undefined;
+        fullMenu?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        'close button': {};
+    };
+};
+export type SideBarTabProps = typeof __propDef.props;
+export type SideBarTabEvents = typeof __propDef.events;
+export type SideBarTabSlots = typeof __propDef.slots;
+export default class SideBarTab extends SvelteComponent<SideBarTabProps, SideBarTabEvents, SideBarTabSlots> {
+}
+export {};

package/package/components/runs/NoWorkerWithTagWarning.svelte

@@ -5,13 +5,16 @@ import { onDestroy } from 'svelte';
 export let tag;
 let noWorkerWithTag = false;
 let timeout = undefined;
+let visible = true;
 async function lookForTag() {
     try {
         const existsWorkerWithTag = await WorkerService.existsWorkerWithTag({ tag });
         noWorkerWithTag = !existsWorkerWithTag;
         if (noWorkerWithTag) {
             timeout = setTimeout(() => {
-                lookForTag();
+                if (visible) {
+                    lookForTag();
+                }
             }, 1000);
         }
     }
@@ -21,6 +24,7 @@ async function lookForTag() {
 }
 lookForTag();
 onDestroy(() => {
+    visible = false;
     if (timeout) {
         clearTimeout(timeout);
     }

package/package/components/schema/AddProperty.svelte

@@ -112,7 +112,9 @@ export function handleDeleteArgument(argPath) {
         });
         if (Object.keys(modifiedProperties).includes(argName)) {
             delete modifiedProperties[argName];
-            modifiedObject.required = schema.required.filter((arg) => arg !== argName);
+            if (modifiedObject.required) {
+                modifiedObject.required = schema.required.filter((arg) => arg !== argName);
+            }
             if (modifiedObject.order) {
                 modifiedObject.order = modifiedObject.order.filter((arg) => arg !== argName);
             }

package/package/components/schema/AddPropertyV2.svelte

@@ -1,7 +1,6 @@
 <script>import { modalToSchema } from '../../common';
 import { emptySchema, sendUserToast } from '../../utils';
 import { createEventDispatcher } from 'svelte';
-import SimpleEditor from '../SimpleEditor.svelte';
 import AddPropertyFormV2 from './AddPropertyFormV2.svelte';
 export let schema = emptySchema();
 export const DEFAULT_PROPERTY = {
@@ -14,12 +13,10 @@ const dispatch = createEventDispatcher();
 if (!schema) {
     schema = emptySchema();
 }
-let schemaString = '';
 // Internal state: bound to args builder modal
 let argError = '';
 let editing = false;
 let oldArgName; // when editing argument and changing name
-let jsonEditor;
 reorder();
 function reorder() {
     if (schema.order && Array.isArray(schema.order)) {
@@ -42,7 +39,7 @@ function syncOrders() {
         schema.order = Object.keys(schema.properties ?? {});
     }
 }
-function handleAddOrEditArgument(modalProperty) {
+export function handleAddOrEditArgument(modalProperty) {
     // If editing the arg's name, oldName containing the old argument name must be provided
     argError = '';
     modalProperty.name = modalProperty.name.trim();
@@ -89,8 +86,6 @@ function handleAddOrEditArgument(modalProperty) {
         oldArgName = undefined;
     }
     schema = schema;
-    schemaString = JSON.stringify(schema, null, '\t');
-    jsonEditor?.setCode(schemaString);
     if (argError !== '') {
         sendUserToast(argError, true);
     }
@@ -112,12 +107,13 @@ export function handleDeleteArgument(argPath) {
         });
         if (Object.keys(modifiedProperties).includes(argName)) {
             delete modifiedProperties[argName];
-            modifiedObject.required = schema.required.filter((arg) => arg !== argName);
+            if (modifiedObject.required) {
+                modifiedObject.required = schema.required.filter((arg) => arg !== argName);
+            }
             if (modifiedObject.order) {
                 modifiedObject.order = modifiedObject.order.filter((arg) => arg !== argName);
             }
             schema = schema;
-            schemaString = JSON.stringify(schema, null, '\t');
             dispatch('change', schema);
         }
         else {
@@ -140,6 +136,7 @@ export function handleDeleteArgument(argPath) {
 				selectedType: 'string',
 				name: e.detail.name
 			})
+			dispatch('addNew', e.detail.name)
 		} catch (err) {
 			sendUserToast(`Could not add argument: ${err}`, true)
 		}

package/package/components/schema/AddPropertyV2.svelte.d.ts

@@ -4,9 +4,11 @@ declare const __propDef: {
     props: {
         schema?: Schema | any;
         DEFAULT_PROPERTY?: ModalSchemaProperty | undefined;
+        handleAddOrEditArgument?: ((modalProperty: ModalSchemaProperty) => void) | undefined;
         handleDeleteArgument?: ((argPath: string[]) => void) | undefined;
     };
     events: {
+        addNew: CustomEvent<any>;
         change: CustomEvent<any>;
     } & {
         [evt: string]: CustomEvent<any>;
@@ -20,6 +22,7 @@ export type AddPropertyV2Events = typeof __propDef.events;
 export type AddPropertyV2Slots = typeof __propDef.slots;
 export default class AddPropertyV2 extends SvelteComponent<AddPropertyV2Props, AddPropertyV2Events, AddPropertyV2Slots> {
     get DEFAULT_PROPERTY(): ModalSchemaProperty;
+    get handleAddOrEditArgument(): (modalProperty: ModalSchemaProperty) => void;
     get handleDeleteArgument(): (argPath: string[]) => void;
 }
 export {};

package/package/components/schema/EditableSchemaDrawer.svelte

@@ -135,8 +135,11 @@ let error = undefined;
 							<div class="flex flex-col w-full mt-2">
 								<Label label="Nested properties">
 									<svelte:self
-										on:change={() => (schema = schema)}
-										schema={schema.properties[item.value]}
+										on:change={() => {
+											schema = schema
+											dispatch('change', schema)
+										}}
+										bind:schema={schema.properties[item.value]}
 										parentId={item.value}
 									/>
 								</Label>
@@ -168,7 +171,13 @@ let error = undefined;
 				editTab="inputEditor"
 			>
 				<svelte:fragment slot="addProperty">
-					<AddPropertyV2 bind:schema on:change>
+					<AddPropertyV2
+						bind:schema
+						on:change
+						on:addNew={(e) => {
+							editableSchemaForm?.openField(e.detail)
+						}}
+					>
 						<svelte:fragment slot="trigger">
 							<div
 								class="w-full py-2 flex justify-center items-center border border-dashed rounded-md hover:bg-surface-hover"

package/package/components/schema/EditableSchemaWrapper.svelte

@@ -15,6 +15,7 @@ export let lightweightMode = false;
 export let formatExtension = undefined;
 let resourceIsTextFile = false;
 let addProperty = undefined;
+let editableSchemaForm = undefined;
 const dispatch = createEventDispatcher();
 $: !resourceIsTextFile && (formatExtension = undefined);
 $: invalidExtension =
@@ -80,6 +81,9 @@ let autocompleteExtension = true;
 				bind:schema
 				bind:this={addProperty}
 				on:change={() => dispatch('change', schema)}
+				on:addNew={(e) => {
+					editableSchemaForm?.openField(e.detail)
+				}}
 			>
 				<svelte:fragment slot="trigger">
 					<div
@@ -91,6 +95,7 @@ let autocompleteExtension = true;
 			</AddPropertyV2>
 		{/if}
 		<EditableSchemaForm
+			bind:this={editableSchemaForm}
 			bind:schema
 			on:change={() => dispatch('change', schema)}
 			isFlowInput

package/package/components/schema/SchemaFormDND.svelte

@@ -12,6 +12,11 @@ export let onlyMaskPassword = false;
 export let disablePortal = false;
 export let disabled = false;
 export let schemaSkippedValues = [];
+export let nestedParent = undefined;
+export let disableDnd = false;
+export let shouldDispatchChanges = false;
+export let diff = {};
+export let nestedClasses = '';
 const dispatch = createEventDispatcher();
 const flipDurationMs = 200;
 let items = computeItems();
@@ -48,12 +53,16 @@ function handleFinalize(e) {
 <!-- svelte-ignore a11y-no-static-element-interactions -->
 <!-- svelte-ignore a11y-no-noninteractive-tabindex -->
 <SchemaForm
+	{nestedClasses}
 	{schemaSkippedValues}
 	on:click
 	on:change
 	on:reorder
 	on:consider={handleConsider}
 	on:finalize={handleFinalize}
+	on:acceptChange
+	on:rejectChange
+	on:nestedChange
 	{lightweightMode}
 	bind:args
 	{prettifyHeader}
@@ -61,17 +70,24 @@ function handleFinalize(e) {
 	{disablePortal}
 	{disabled}
 	bind:schema
-	dndConfig={{
-		items,
-		flipDurationMs,
-		dropTargetStyle: {},
-		type: dndType ?? 'top-level'
-	}}
+	dndConfig={disableDnd
+		? undefined
+		: {
+				items,
+				flipDurationMs,
+				dropTargetStyle: {},
+				type: dndType ?? 'top-level'
+		  }}
 	{items}
+	{diff}
+	{nestedParent}
+	{shouldDispatchChanges}
 >
 	<svelte:fragment slot="actions">
-		<div class="w-4 h-8 cursor-move ml-2 handle" aria-label="drag-handle" use:dragHandle>
-			<GripVertical size={16} />
-		</div>
+		{#if !disableDnd}
+			<div class="w-4 h-8 cursor-move ml-2 handle" aria-label="drag-handle" use:dragHandle>
+				<GripVertical size={16} />
+			</div>
+		{/if}
 	</svelte:fragment>
 </SchemaForm>

package/package/components/schema/SchemaFormDND.svelte.d.ts

@@ -1,5 +1,6 @@
 import { SvelteComponent } from "svelte";
 import type { Schema } from '../../common';
+import type { SchemaDiff } from './schemaUtils';
 declare const __propDef: {
     props: {
         dndType?: string | undefined;
@@ -11,11 +12,22 @@ declare const __propDef: {
         disablePortal?: boolean | undefined;
         disabled?: boolean | undefined;
         schemaSkippedValues?: string[] | undefined;
+        nestedParent?: {
+            label: string;
+            nestedParent: any | undefined;
+        } | undefined;
+        disableDnd?: boolean | undefined;
+        shouldDispatchChanges?: boolean | undefined;
+        diff?: Record<string, SchemaDiff> | undefined;
+        nestedClasses?: string | undefined;
     };
     events: {
         click: CustomEvent<any>;
         change: CustomEvent<any>;
         reorder: CustomEvent<any>;
+        acceptChange: CustomEvent<any>;
+        rejectChange: CustomEvent<any>;
+        nestedChange: CustomEvent<any>;
     } & {
         [evt: string]: CustomEvent<any>;
     };

package/package/components/schema/schemaUtils.d.ts

@@ -0,0 +1,26 @@
+export type SchemaDiff = {
+    diff: 'same' | 'added' | 'removed' | 'modified' | Record<string, SchemaDiff>;
+    fullSchema: {
+        [key: string]: any;
+    } | undefined;
+    oldSchema?: {
+        [key: string]: any;
+    } | undefined;
+};
+export declare function computeDiff(previewSchema: {
+    [key: string]: any;
+} | undefined, currentSchema: {
+    [key: string]: any;
+} | undefined): Record<string, SchemaDiff>;
+export declare function schemaFromDiff(diff: Record<string, SchemaDiff>, schema: {
+    [key: string]: any;
+} | undefined): {
+    [key: string]: any;
+} | undefined;
+export declare function getFullPath(arg: {
+    label: string;
+    nestedParent: any | undefined;
+}): string[];
+export declare function getNestedProperty(obj: any, path: string[], field?: string): any;
+export declare function setNestedProperty(obj: any, path: string[], value: any, field?: string): void;
+export declare function applyDiff(schema: Record<string, any> | undefined, diff: Record<string, SchemaDiff> | undefined): Record<string, any> | undefined;

package/package/components/schema/schemaUtils.js

@@ -0,0 +1,185 @@
+function isCompatible(diff) {
+    let compatible = true;
+    Object.values(diff).forEach((diff) => {
+        if (diff.diff === 'added' || diff.diff === 'modified' || diff.diff === 'removed') {
+            compatible = false;
+        }
+        else if (isRecordSchemaDiff(diff.diff)) {
+            compatible = isCompatible(diff.diff);
+        }
+    });
+    return compatible;
+}
+function isCompatibleObject(a, b) {
+    if (!a || !b) {
+        return false;
+    }
+    if (a.type === 'null' || b.type === 'null') {
+        return true;
+    }
+    if (a.type !== b.type) {
+        if ((a.type === 'number' || a.type === 'integer') &&
+            (b.type === 'number' || b.type === 'integer')) {
+            return true;
+        }
+        return false;
+    }
+    switch (a.type) {
+        case 'object':
+            if (a.oneOf || b.oneOf) {
+                //TODO: handle oneOf compatibility. here we assume that only b is oneOf
+                return true;
+            }
+            return a.format === b.format;
+        case 'array':
+            return !a.items || !b.items || a.items?.type === b.items?.type;
+        case 'string':
+            return a.format === b.format;
+        case 'boolean':
+        case 'number':
+        case 'integer':
+            return true;
+        default:
+            return false;
+    }
+}
+export function computeDiff(previewSchema, currentSchema) {
+    if (!previewSchema || !currentSchema) {
+        return {};
+    }
+    const diff = {};
+    if (previewSchema?.properties) {
+        Object.keys(previewSchema.properties).forEach((key) => {
+            if (!currentSchema?.properties?.[key]) {
+                diff[key] = {
+                    diff: 'added',
+                    fullSchema: previewSchema.properties[key]
+                };
+            }
+            else {
+                const previewProp = previewSchema.properties[key];
+                const currentProp = currentSchema.properties[key];
+                if (previewProp.type === 'object' && currentProp.type === 'object') {
+                    if (JSON.stringify(previewProp) === JSON.stringify(currentProp)) {
+                        diff[key] = { diff: 'same', fullSchema: undefined };
+                    }
+                    else if (previewProp.oneOf || currentProp.oneOf) {
+                        if (isCompatibleObject(previewProp, currentProp)) {
+                            diff[key] = { diff: 'same', fullSchema: undefined };
+                        }
+                        else {
+                            diff[key] = { diff: 'modified', fullSchema: previewProp, oldSchema: currentProp };
+                        }
+                    }
+                    else if (previewProp.format || currentProp.format) {
+                        //TODO: handle s3 object compatibility
+                        diff[key] = { diff: 'modified', fullSchema: previewProp, oldSchema: currentProp };
+                    }
+                    else {
+                        const diffProp = computeDiff(previewProp, currentProp);
+                        const checkIfSame = isCompatible(diffProp);
+                        if (checkIfSame) {
+                            diff[key] = { diff: 'same', fullSchema: undefined };
+                        }
+                        else {
+                            diff[key] = {
+                                diff: diffProp,
+                                fullSchema: previewProp,
+                                oldSchema: currentProp
+                            };
+                        }
+                    }
+                }
+                else if (isCompatibleObject(previewProp, currentProp)) {
+                    diff[key] = { diff: 'same', fullSchema: undefined };
+                }
+                else {
+                    diff[key] = { diff: 'modified', fullSchema: previewProp, oldSchema: currentProp };
+                }
+            }
+        });
+    }
+    if (currentSchema?.properties) {
+        Object.keys(currentSchema.properties).forEach((key) => {
+            if (!previewSchema?.properties?.[key]) {
+                diff[key] = { diff: 'removed', fullSchema: undefined };
+            }
+        });
+    }
+    return diff;
+}
+export function schemaFromDiff(diff, schema) {
+    if (!schema) {
+        return undefined;
+    }
+    const newSchema = structuredClone(schema);
+    Object.keys(diff).forEach((key) => {
+        const diffValue = diff[key].diff;
+        if (diffValue === 'added' || diffValue === 'modified') {
+            newSchema.properties[key] = diff[key].fullSchema;
+            if (newSchema.order && !newSchema.order.includes(key)) {
+                newSchema.order.push(key);
+            }
+        }
+        else if (isRecordSchemaDiff(diffValue)) {
+            // Handle nested diffs
+            newSchema.properties[key] = schemaFromDiff(diffValue, schema.properties[key]);
+        }
+    });
+    return newSchema;
+}
+export function getFullPath(arg) {
+    const getPath = (current) => {
+        if (!current.nestedParent) {
+            return [current.label];
+        }
+        return [...getPath(current.nestedParent), current.label];
+    };
+    return getPath(arg);
+}
+export function getNestedProperty(obj, path, field = 'properties') {
+    return path.reduce((curr, key) => curr?.[field]?.[key], obj);
+}
+export function setNestedProperty(obj, path, value, field = 'properties') {
+    const pathCopy = [...path];
+    const lastKey = pathCopy.pop();
+    const target = pathCopy.reduce((curr, key) => {
+        if (!(key in curr[field])) {
+            curr[field][key] = { [field]: {} };
+        }
+        return curr[field][key];
+    }, obj);
+    if (lastKey && value) {
+        const newValue = structuredClone(value);
+        target[field][lastKey] = newValue;
+        return;
+    }
+    else if (lastKey && !value) {
+        delete target[field][lastKey];
+    }
+}
+function isRecordSchemaDiff(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function applyDiff(schema, diff) {
+    if (!diff || !schema) {
+        return;
+    }
+    let newSchema = structuredClone(schema);
+    Object.keys(diff).forEach((key) => {
+        const diffValue = diff[key].diff;
+        if (diffValue === 'removed') {
+            delete newSchema.properties[key];
+            if (newSchema.order) {
+                newSchema.order = newSchema.order.filter((x) => x !== key);
+            }
+        }
+        else if (diffValue === 'added' || diffValue === 'modified' || isRecordSchemaDiff(diffValue)) {
+            newSchema.properties[key] = diff[key].fullSchema;
+            if (newSchema.order && !newSchema.order.includes(key)) {
+                newSchema.order.push(key);
+            }
+        }
+    });
+    return newSchema;
+}