windmill-components 1.103.2 → 1.109.1

package/package/components/propertyPicker/PropPicker.svelte

@@ -26,6 +26,9 @@ $: resultByIdFiltered =
     search === EMPTY_STRING
         ? pickableProperties.priorIds
         : keepByKey(pickableProperties.priorIds, search);
+$: suggestedPropsFiltered = $propPickerConfig
+    ? keepByKey(pickableProperties.priorIds, $propPickerConfig.propName)
+    : undefined;
 async function loadVariables() {
     variables = Object.fromEntries((await VariableService.listVariable({
         workspace: $workspaceStore ?? ''
@@ -131,6 +134,21 @@ async function loadResources() {
 				</div>
 			{/if}
 			{#if Object.keys(pickableProperties.priorIds).length > 0}
+				{#if suggestedPropsFiltered && Object.keys(suggestedPropsFiltered).length > 0}
+					<span class="font-bold text-sm">Suggested Results</span>
+					<div class="overflow-y-auto mb-2">
+						<ObjectViewer
+							allowCopy={false}
+							topLevelNode
+							pureViewer={!$propPickerConfig}
+							collapsed={false}
+							json={suggestedPropsFiltered}
+							on:select={(e) => {
+								dispatch('select', `results.${e.detail}`)
+							}}
+						/>
+					</div>
+				{/if}
 				<span class="font-bold text-sm">All Results</span>
 				<div class="overflow-y-auto mb-2">
 					<ObjectViewer

package/package/components/sidebar/MultiplayerMenu.svelte

@@ -0,0 +1,123 @@
+<script>import { enterpriseLicense, userStore, workspaceStore, awarenessStore } from '../../stores';
+import { classNames } from '../../utils';
+import { Users } from 'lucide-svelte';
+import { BROWSER } from 'esm-env';
+import Menu from '../common/menu/Menu.svelte';
+import { WebsocketProvider } from 'y-websocket';
+import * as Y from 'yjs';
+import { page } from '$app/stores';
+export let isCollapsed = false;
+const wsProtocol = BROWSER && window.location.protocol == 'https:' ? 'wss' : 'ws';
+let awareness = undefined;
+let wsProvider = undefined;
+let connected = false;
+function connectWorkspace(workspace) {
+    const ydoc = new Y.Doc();
+    wsProvider = new WebsocketProvider(`${wsProtocol}://${window.location.host}/ws_mp/`, workspace, ydoc);
+    wsProvider.on('sync', (isSynced) => {
+        connected = true;
+    });
+    awareness = wsProvider.awareness;
+    awareness?.setLocalState({
+        name: $userStore?.username,
+        url: $page.url.pathname
+    });
+    function setPeers() {
+        if (!awareness)
+            return;
+        $awarenessStore = Object.fromEntries(Array.from(awareness.getStates().values()).map((x) => [x.name, x.url]));
+    }
+    setPeers();
+    // You can observe when a user updates their awareness information
+    awareness.on('change', (changes) => {
+        setPeers();
+    });
+}
+$: awareness?.setLocalState({
+    name: $userStore?.username,
+    url: $page.url.pathname
+});
+$: $enterpriseLicense && $workspaceStore && connectWorkspace($workspaceStore);
+function showActivity(url) {
+    if (url.startsWith('/scripts/add')) {
+        return 'Creating a script';
+    }
+    else if (url.startsWith('/scripts/edit')) {
+        return 'Editing a script';
+    }
+    else if (url.startsWith('/scripts/get')) {
+        return 'Viewing a script';
+    }
+    else if (url.startsWith('/flows/add')) {
+        return 'Creating a flow';
+    }
+    else if (url.startsWith('/flows/edit')) {
+        return 'Editing a flow';
+    }
+    else if (url.startsWith('/flows/get')) {
+        return 'Viewing a flow';
+    }
+    else if (url.startsWith('/apps/add')) {
+        return 'Creating an app';
+    }
+    else if (url.startsWith('/apps/edit')) {
+        return 'Editing an app';
+    }
+    else if (url.startsWith('/runs')) {
+        return 'Exploring runs';
+    }
+    else if (url.startsWith('/variables')) {
+        return 'Exploring variables';
+    }
+    else if (url.startsWith('/resources')) {
+        return 'Exploring runs';
+    }
+    else if (url == '/') {
+        return 'On the home page';
+    }
+    else {
+        return '';
+    }
+}
+</script>
+
+{#if connected}
+	<Menu placement="bottom-start">
+		<button
+			slot="trigger"
+			type="button"
+			class={classNames(
+				'group w-full flex items-center text-white hover:bg-gray-50 hover:text-gray-900 focus:ring-4 focus:outline-none focus:ring-gray-300 px-2 py-2 text-sm font-medium rounded-md h-8 '
+			)}
+		>
+			<div class="center-center mr-2">
+				<Users size={16} />
+			</div>
+
+			{#if !isCollapsed}
+				<span class={classNames('whitespace-pre truncate')}>Live</span>
+			{/if}
+		</button>
+
+		<div class="divide-y divide-gray-100" role="none">
+			<div class="py-1 flex flex-col gap-y-1">
+				{#each Object.entries($awarenessStore ?? {}) as [user, url]}
+					<div class="inline-flex gap-2 px-2 items-center">
+						<span
+							class="inline-flex h-6 w-6 px-1 items-center justify-center rounded-full ring-2 ring-white bg-gray-600"
+							title={user}
+						>
+							<span class="text-sm font-medium leading-none text-white"
+								>{user.substring(0, 2).toLocaleUpperCase()}</span
+							>
+						</span>
+						<div class="flex flex-col">
+							<span class="text-sm text-gray-900 truncate">{user}</span>
+							<span class="text-xs text-gray-500 truncate">{showActivity(url)}</span>
+						</div>
+					</div>
+				{/each}
+			</div>
+		</div>
+	</Menu>
+{/if}

package/package/components/sidebar/MultiplayerMenu.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        isCollapsed?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type MultiplayerMenuProps = typeof __propDef.props;
+export type MultiplayerMenuEvents = typeof __propDef.events;
+export type MultiplayerMenuSlots = typeof __propDef.slots;
+export default class MultiplayerMenu extends SvelteComponentTyped<MultiplayerMenuProps, MultiplayerMenuEvents, MultiplayerMenuSlots> {
+}
+export {};

package/package/components/sidebar/WorkspaceMenu.svelte

@@ -28,7 +28,7 @@ export let isCollapsed = false;
 		<div class="py-1">
 			{#each $userWorkspaces as workspace}
 				<button
-					class="text-xs min-w-0 w-full flex flex-col py-1.5
+					class="text-xs min-w-0 w-full overflow-hidden flex flex-col py-1.5
 						{$workspaceStore === workspace.id
 						? 'cursor-default bg-blue-50'
 						: 'cursor-pointer hover:bg-gray-100'}"

package/package/gen/core/CancelablePromise.d.ts

@@ -9,15 +9,9 @@ export interface OnCancel {
     (cancelHandler: () => void): void;
 }
 export declare class CancelablePromise<T> implements Promise<T> {
-    readonly [Symbol.toStringTag]: string;
-    private _isResolved;
-    private _isRejected;
-    private _isCancelled;
-    private readonly _cancelHandlers;
-    private readonly _promise;
-    private _resolve?;
-    private _reject?;
+    #private;
     constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
     then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
     catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
     finally(onFinally?: (() => void) | null): Promise<T>;

package/package/gen/core/CancelablePromise.js

@@ -11,71 +11,73 @@ export class CancelError extends Error {
     }
 }
 export class CancelablePromise {
-    [Symbol.toStringTag];
-    _isResolved;
-    _isRejected;
-    _isCancelled;
-    _cancelHandlers;
-    _promise;
-    _resolve;
-    _reject;
+    #isResolved;
+    #isRejected;
+    #isCancelled;
+    #cancelHandlers;
+    #promise;
+    #resolve;
+    #reject;
     constructor(executor) {
-        this._isResolved = false;
-        this._isRejected = false;
-        this._isCancelled = false;
-        this._cancelHandlers = [];
-        this._promise = new Promise((resolve, reject) => {
-            this._resolve = resolve;
-            this._reject = reject;
+        this.#isResolved = false;
+        this.#isRejected = false;
+        this.#isCancelled = false;
+        this.#cancelHandlers = [];
+        this.#promise = new Promise((resolve, reject) => {
+            this.#resolve = resolve;
+            this.#reject = reject;
             const onResolve = (value) => {
-                if (this._isResolved || this._isRejected || this._isCancelled) {
+                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
                     return;
                 }
-                this._isResolved = true;
-                this._resolve?.(value);
+                this.#isResolved = true;
+                this.#resolve?.(value);
             };
             const onReject = (reason) => {
-                if (this._isResolved || this._isRejected || this._isCancelled) {
+                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
                     return;
                 }
-                this._isRejected = true;
-                this._reject?.(reason);
+                this.#isRejected = true;
+                this.#reject?.(reason);
             };
             const onCancel = (cancelHandler) => {
-                if (this._isResolved || this._isRejected || this._isCancelled) {
+                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
                     return;
                 }
-                this._cancelHandlers.push(cancelHandler);
+                this.#cancelHandlers.push(cancelHandler);
             };
             Object.defineProperty(onCancel, 'isResolved', {
-                get: () => this._isResolved,
+                get: () => this.#isResolved,
             });
             Object.defineProperty(onCancel, 'isRejected', {
-                get: () => this._isRejected,
+                get: () => this.#isRejected,
             });
             Object.defineProperty(onCancel, 'isCancelled', {
-                get: () => this._isCancelled,
+                get: () => this.#isCancelled,
             });
             return executor(onResolve, onReject, onCancel);
         });
     }
+    get [Symbol.toStringTag]() {
+        return "Cancellable Promise";
+    }
     then(onFulfilled, onRejected) {
-        return this._promise.then(onFulfilled, onRejected);
+        return this.#promise.then(onFulfilled, onRejected);
     }
     catch(onRejected) {
-        return this._promise.catch(onRejected);
+        return this.#promise.catch(onRejected);
     }
     finally(onFinally) {
-        return this._promise.finally(onFinally);
+        return this.#promise.finally(onFinally);
     }
     cancel() {
-        if (this._isResolved || this._isRejected || this._isCancelled) {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
             return;
         }
-        this._isCancelled = true;
-        if (this._cancelHandlers.length) {
+        this.#isCancelled = true;
+        if (this.#cancelHandlers.length) {
             try {
-                for (const cancelHandler of this._cancelHandlers) {
+                for (const cancelHandler of this.#cancelHandlers) {
                     cancelHandler();
                 }
             }
@@ -84,10 +86,10 @@ export class CancelablePromise {
                 return;
             }
         }
-        this._cancelHandlers.length = 0;
-        this._reject?.(new CancelError('Request aborted'));
+        this.#cancelHandlers.length = 0;
+        this.#reject?.(new CancelError('Request aborted'));
     }
     get isCancelled() {
-        return this._isCancelled;
+        return this.#isCancelled;
     }
 }

package/package/gen/core/OpenAPI.js

@@ -1,6 +1,6 @@
 export const OpenAPI = {
     BASE: '/api',
-    VERSION: '1.103.0',
+    VERSION: '1.109.1',
     WITH_CREDENTIALS: false,
     CREDENTIALS: 'include',
     TOKEN: undefined,

package/package/gen/core/request.js

@@ -150,7 +150,7 @@ const getHeaders = async (config, options) => {
     return new Headers(headers);
 };
 const getRequestBody = (options) => {
-    if (options.body) {
+    if (options.body !== undefined) {
         if (options.mediaType?.includes('/json')) {
             return JSON.stringify(options.body);
         }
@@ -192,7 +192,8 @@ const getResponseBody = async (response) => {
         try {
             const contentType = response.headers.get('Content-Type');
             if (contentType) {
-                const isJSON = contentType.toLowerCase().startsWith('application/json');
+                const jsonTypes = ['application/json', 'application/problem+json'];
+                const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type));
                 if (isJSON) {
                     return await response.json();
                 }

package/package/gen/models/AuditLog.d.ts

@@ -5,7 +5,7 @@ export type AuditLog = {
     operation: AuditLog.operation;
     action_kind: AuditLog.action_kind;
     resource?: string;
-    parameters?: any;
+    parameters?: Record<string, any>;
 };
 export declare namespace AuditLog {
     enum operation {

package/package/gen/models/CreateInput.d.ts

@@ -1,4 +1,4 @@
 export type CreateInput = {
     name: string;
-    args: any;
+    args: Record<string, any>;
 };

package/package/gen/models/FlowMetadata.d.ts

@@ -4,7 +4,7 @@ export type FlowMetadata = {
     edited_by: string;
     edited_at: string;
     archived: boolean;
-    extra_perms: any;
+    extra_perms: Record<string, any>;
     additionalProperties?: boolean;
     starred?: boolean;
     draft_only?: boolean;

package/package/gen/models/FlowModule.d.ts

@@ -9,6 +9,7 @@ export type FlowModule = {
         expr: string;
     };
     sleep?: InputTransform;
+    cache_ttl?: number;
     summary?: string;
     suspend?: {
         required_events?: number;

package/package/gen/models/Input.d.ts

@@ -1,7 +1,7 @@
 export type Input = {
     id: string;
     name: string;
-    args: any;
+    args: Record<string, any>;
     created_by: string;
     created_at: string;
     is_public: boolean;

package/package/gen/models/NewScript.d.ts

@@ -4,13 +4,14 @@ export type NewScript = {
     summary: string;
     description: string;
     content: string;
-    schema?: any;
+    schema?: Record<string, any>;
     is_template?: boolean;
     lock?: Array<string>;
     language: NewScript.language;
     kind?: NewScript.kind;
     tag?: string;
     draft_only?: boolean;
+    envs?: Array<string>;
 };
 export declare namespace NewScript {
     enum language {

package/package/gen/models/NewToken.d.ts

@@ -1,4 +1,5 @@
 export type NewToken = {
     label?: string;
     expiration?: string;
+    scopes?: Array<string>;
 };

package/package/gen/models/OpenFlow.d.ts

@@ -3,5 +3,5 @@ export type OpenFlow = {
     summary: string;
     description?: string;
     value: FlowValue;
-    schema?: any;
+    schema?: Record<string, any>;
 };

package/package/gen/models/Policy.d.ts

@@ -1,5 +1,5 @@
 export type Policy = {
-    triggerables?: Record<string, any>;
+    triggerables?: Record<string, Record<string, any>>;
     execution_mode?: Policy.execution_mode;
     on_behalf_of?: string;
     on_behalf_of_email?: string;

package/package/gen/models/Script.d.ts

@@ -13,7 +13,7 @@ export type Script = {
     created_by: string;
     created_at: string;
     archived: boolean;
-    schema?: any;
+    schema?: Record<string, any>;
     deleted: boolean;
     is_template: boolean;
     extra_perms: Record<string, boolean>;
@@ -25,6 +25,7 @@ export type Script = {
     tag?: string;
     has_draft?: boolean;
     draft_only?: boolean;
+    envs?: Array<string>;
 };
 export declare namespace Script {
     enum language {

package/package/gen/models/TruncatedToken.d.ts

@@ -4,4 +4,5 @@ export type TruncatedToken = {
     token_prefix: string;
     created_at: string;
     last_used_at: string;
+    scopes?: Array<string>;
 };

package/package/gen/services/AppService.d.ts

@@ -189,7 +189,7 @@ export declare class AppService {
                 language: string;
                 path?: string;
             };
-            force_viewer_static_fields?: any;
+            force_viewer_static_fields?: Record<string, any>;
         };
     }): CancelablePromise<string>;
 }

package/package/gen/services/JobService.d.ts

@@ -39,6 +39,38 @@ export declare class JobService {
          */
         invisibleToOwner?: boolean;
     }): CancelablePromise<string>;
+    /**
+     * run script by path in openai format
+     * @returns any job result
+     * @throws ApiError
+     */
+    static openaiSyncScriptByPath({ workspace, path, requestBody, parentJob, jobId, includeHeader, queueLimit, }: {
+        workspace: string;
+        path: string;
+        /**
+         * script args
+         */
+        requestBody: ScriptArgs;
+        /**
+         * The parent job that is at the origin and responsible for the execution of this script if any
+         */
+        parentJob?: string;
+        /**
+         * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
+         */
+        jobId?: string;
+        /**
+         * List of headers's keys (separated with ',') whove value are added to the args
+         * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
+         *
+         */
+        includeHeader?: string;
+        /**
+         * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
+         *
+         */
+        queueLimit?: string;
+    }): CancelablePromise<any>;
     /**
      * run script by path
      * @returns any job result
@@ -105,6 +137,34 @@ export declare class JobService {
          */
         payload?: string;
     }): CancelablePromise<any>;
+    /**
+     * run flow by path and wait until completion in openai format
+     * @returns any job result
+     * @throws ApiError
+     */
+    static openaiSyncFlowByPath({ workspace, path, requestBody, includeHeader, queueLimit, jobId, }: {
+        workspace: string;
+        path: string;
+        /**
+         * script args
+         */
+        requestBody: ScriptArgs;
+        /**
+         * List of headers's keys (separated with ',') whove value are added to the args
+         * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
+         *
+         */
+        includeHeader?: string;
+        /**
+         * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
+         *
+         */
+        queueLimit?: string;
+        /**
+         * The job id to assign to the created job. if missing, job is chosen randomly using the ULID scheme. If a job id already exists in the queue or as a completed job, the request to create one will fail (Bad Request)
+         */
+        jobId?: string;
+    }): CancelablePromise<any>;
     /**
      * run flow by path and wait until completion
      * @returns any job result
@@ -193,7 +253,7 @@ export declare class JobService {
         /**
          * Partially filled args
          */
-        requestBody: any;
+        requestBody: Record<string, any>;
         /**
          * when to schedule this job (leave empty for immediate run)
          */
@@ -621,7 +681,7 @@ export declare class JobService {
         id: string;
         resumeId: number;
         signature: string;
-        requestBody: any;
+        requestBody: Record<string, any>;
         approver?: string;
     }): CancelablePromise<string>;
     /**
@@ -632,7 +692,7 @@ export declare class JobService {
     static resumeSuspendedFlowAsOwner({ workspace, id, requestBody, }: {
         workspace: string;
         id: string;
-        requestBody: any;
+        requestBody: Record<string, any>;
     }): CancelablePromise<string>;
     /**
      * cancel a job for a suspended flow
@@ -656,7 +716,7 @@ export declare class JobService {
         id: string;
         resumeId: number;
         signature: string;
-        requestBody: any;
+        requestBody: Record<string, any>;
         approver?: string;
     }): CancelablePromise<string>;
     /**

package/package/gen/services/JobService.js

@@ -25,6 +25,29 @@ export class JobService {
             mediaType: 'application/json',
         });
     }
+    /**
+     * run script by path in openai format
+     * @returns any job result
+     * @throws ApiError
+     */
+    static openaiSyncScriptByPath({ workspace, path, requestBody, parentJob, jobId, includeHeader, queueLimit, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/openai_sync/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'parent_job': parentJob,
+                'job_id': jobId,
+                'include_header': includeHeader,
+                'queue_limit': queueLimit,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
     /**
      * run script by path
      * @returns any job result
@@ -70,6 +93,28 @@ export class JobService {
             },
         });
     }
+    /**
+     * run flow by path and wait until completion in openai format
+     * @returns any job result
+     * @throws ApiError
+     */
+    static openaiSyncFlowByPath({ workspace, path, requestBody, includeHeader, queueLimit, jobId, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/openai_sync/f/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'include_header': includeHeader,
+                'queue_limit': queueLimit,
+                'job_id': jobId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
     /**
      * run flow by path and wait until completion
      * @returns any job result

package/package/gen/services/ResourceService.d.ts

@@ -11,12 +11,13 @@ export declare class ResourceService {
      * @returns string resource created
      * @throws ApiError
      */
-    static createResource({ workspace, requestBody, }: {
+    static createResource({ workspace, requestBody, updateIfExists, }: {
         workspace: string;
         /**
          * new resource
          */
         requestBody: CreateResource;
+        updateIfExists?: boolean;
     }): CancelablePromise<string>;
     /**
      * delete resource