windmill-components 1.642.0 → 1.655.0

package/package/utils_workspace_deploy.js

@@ -0,0 +1,449 @@
+import { AppService, FlowService, FolderService, ResourceService, ScheduleService, ScriptService, VariableService } from './gen';
+import { getAllModules } from './components/flows/flowExplorer';
+import { existsTrigger, getTriggersDeployData, getTriggerEmail, getTriggerValue } from './utils_deployable';
+/**
+ * Deploy an item from one workspace to another.
+ * Handles all item kinds: flow, script, app, variable, resource, resource_type, folder, trigger.
+ */
+export async function deployItem(params) {
+    const { kind, path, workspaceFrom, workspaceTo, additionalInformation, onBehalfOfEmail } = params;
+    // When onBehalfOfEmail is set, we preserve the on_behalf_of setting with the specified email
+    const preserveOnBehalfOf = onBehalfOfEmail !== undefined;
+    try {
+        const alreadyExists = await checkItemExists(kind, path, workspaceTo, additionalInformation);
+        if (kind === 'flow') {
+            const flow = await FlowService.getFlowByPath({
+                workspace: workspaceFrom,
+                path: path
+            });
+            getAllModules(flow.value.modules).forEach((x) => {
+                if (x.value.type === 'script' && x.value.hash != undefined) {
+                    x.value.hash = undefined;
+                }
+            });
+            if (alreadyExists) {
+                await FlowService.updateFlow({
+                    workspace: workspaceTo,
+                    path: path,
+                    requestBody: {
+                        ...flow,
+                        preserve_on_behalf_of: preserveOnBehalfOf,
+                        on_behalf_of_email: onBehalfOfEmail
+                    }
+                });
+            }
+            else {
+                await FlowService.createFlow({
+                    workspace: workspaceTo,
+                    requestBody: {
+                        ...flow,
+                        preserve_on_behalf_of: preserveOnBehalfOf,
+                        on_behalf_of_email: onBehalfOfEmail
+                    }
+                });
+            }
+        }
+        else if (kind === 'script') {
+            const script = await ScriptService.getScriptByPath({
+                workspace: workspaceFrom,
+                path: path
+            });
+            await ScriptService.createScript({
+                workspace: workspaceTo,
+                requestBody: {
+                    ...script,
+                    lock: script.lock,
+                    parent_hash: alreadyExists
+                        ? (await ScriptService.getScriptByPath({
+                            workspace: workspaceTo,
+                            path: path
+                        })).hash
+                        : undefined,
+                    preserve_on_behalf_of: preserveOnBehalfOf,
+                    on_behalf_of_email: onBehalfOfEmail
+                }
+            });
+        }
+        else if (kind === 'app') {
+            const app = await AppService.getAppByPath({
+                workspace: workspaceFrom,
+                path: path
+            });
+            if (alreadyExists) {
+                if (app.raw_app) {
+                    const secret = await AppService.getPublicSecretOfLatestVersionOfApp({
+                        workspace: workspaceFrom,
+                        path: app.path
+                    });
+                    const js = await AppService.getRawAppData({
+                        secretWithExtension: `${secret}.js`,
+                        workspace: workspaceFrom
+                    });
+                    const css = await AppService.getRawAppData({
+                        secretWithExtension: `${secret}.css`,
+                        workspace: workspaceFrom
+                    });
+                    await AppService.updateAppRaw({
+                        workspace: workspaceTo,
+                        path: path,
+                        formData: {
+                            app: { ...app, preserve_on_behalf_of: preserveOnBehalfOf },
+                            css,
+                            js
+                        }
+                    });
+                }
+                else {
+                    await AppService.updateApp({
+                        workspace: workspaceTo,
+                        path: path,
+                        requestBody: {
+                            ...app,
+                            preserve_on_behalf_of: preserveOnBehalfOf
+                        }
+                    });
+                }
+            }
+            else {
+                if (app.raw_app) {
+                    const secret = await AppService.getPublicSecretOfLatestVersionOfApp({
+                        workspace: workspaceFrom,
+                        path: app.path
+                    });
+                    const js = await AppService.getRawAppData({
+                        secretWithExtension: `${secret}.js`,
+                        workspace: workspaceFrom
+                    });
+                    const css = await AppService.getRawAppData({
+                        secretWithExtension: `${secret}.css`,
+                        workspace: workspaceFrom
+                    });
+                    await AppService.createAppRaw({
+                        workspace: workspaceTo,
+                        formData: {
+                            app: { ...app, preserve_on_behalf_of: preserveOnBehalfOf },
+                            css,
+                            js
+                        }
+                    });
+                }
+                else {
+                    await AppService.createApp({
+                        workspace: workspaceTo,
+                        requestBody: {
+                            ...app,
+                            preserve_on_behalf_of: preserveOnBehalfOf
+                        }
+                    });
+                }
+            }
+        }
+        else if (kind === 'variable') {
+            const variable = await VariableService.getVariable({
+                workspace: workspaceFrom,
+                path: path,
+                decryptSecret: true
+            });
+            if (alreadyExists) {
+                await VariableService.updateVariable({
+                    workspace: workspaceTo,
+                    path: path,
+                    requestBody: {
+                        path: path,
+                        value: variable.value ?? '',
+                        is_secret: variable.is_secret,
+                        description: variable.description ?? ''
+                    },
+                    alreadyEncrypted: false
+                });
+            }
+            else {
+                await VariableService.createVariable({
+                    workspace: workspaceTo,
+                    requestBody: {
+                        path: path,
+                        value: variable.value ?? '',
+                        is_secret: variable.is_secret,
+                        description: variable.description ?? ''
+                    }
+                });
+            }
+        }
+        else if (kind === 'resource') {
+            const resource = await ResourceService.getResource({
+                workspace: workspaceFrom,
+                path: path
+            });
+            if (alreadyExists) {
+                await ResourceService.updateResource({
+                    workspace: workspaceTo,
+                    path: path,
+                    requestBody: {
+                        path: path,
+                        value: resource.value ?? '',
+                        description: resource.description ?? ''
+                    }
+                });
+            }
+            else {
+                await ResourceService.createResource({
+                    workspace: workspaceTo,
+                    requestBody: {
+                        path: path,
+                        value: resource.value ?? '',
+                        resource_type: resource.resource_type,
+                        description: resource.description ?? ''
+                    }
+                });
+            }
+        }
+        else if (kind === 'resource_type') {
+            const resource = await ResourceService.getResourceType({
+                workspace: workspaceFrom,
+                path: path
+            });
+            if (alreadyExists) {
+                await ResourceService.updateResourceType({
+                    workspace: workspaceTo,
+                    path: path,
+                    requestBody: {
+                        schema: resource.schema,
+                        description: resource.description ?? ''
+                    }
+                });
+            }
+            else {
+                await ResourceService.createResourceType({
+                    workspace: workspaceTo,
+                    requestBody: {
+                        description: resource.description ?? '',
+                        schema: resource.schema,
+                        name: resource.name
+                    }
+                });
+            }
+        }
+        else if (kind === 'folder') {
+            await FolderService.createFolder({
+                workspace: workspaceTo,
+                requestBody: {
+                    name: path
+                }
+            });
+        }
+        else if (kind === 'trigger') {
+            if (additionalInformation?.triggers) {
+                const { data, createFn, updateFn } = await getTriggersDeployData(additionalInformation.triggers.kind, path, workspaceFrom, onBehalfOfEmail);
+                if (alreadyExists) {
+                    await updateFn({
+                        path,
+                        workspace: workspaceTo,
+                        requestBody: data
+                    });
+                }
+                else {
+                    await createFn({
+                        workspace: workspaceTo,
+                        requestBody: data
+                    });
+                }
+            }
+            else {
+                throw new Error('Missing triggers kind');
+            }
+        }
+        else {
+            throw new Error(`Unknown kind ${kind}`);
+        }
+        return { success: true };
+    }
+    catch (e) {
+        return { success: false, error: e.body || e.message };
+    }
+}
+/**
+ * Check if an item already exists in the target workspace.
+ */
+export async function checkItemExists(kind, path, workspace, additionalInformation) {
+    if (kind === 'flow') {
+        return await FlowService.existsFlowByPath({
+            workspace: workspace,
+            path: path
+        });
+    }
+    else if (kind === 'script') {
+        return await ScriptService.existsScriptByPath({
+            workspace: workspace,
+            path: path
+        });
+    }
+    else if (kind === 'app') {
+        return await AppService.existsApp({
+            workspace: workspace,
+            path: path
+        });
+    }
+    else if (kind === 'variable') {
+        return await VariableService.existsVariable({
+            workspace: workspace,
+            path: path
+        });
+    }
+    else if (kind === 'resource') {
+        return await ResourceService.existsResource({
+            workspace: workspace,
+            path: path
+        });
+    }
+    else if (kind === 'schedule') {
+        return await ScheduleService.existsSchedule({
+            workspace: workspace,
+            path: path
+        });
+    }
+    else if (kind === 'resource_type') {
+        return await ResourceService.existsResourceType({
+            workspace: workspace,
+            path: path
+        });
+    }
+    else if (kind === 'folder') {
+        return await FolderService.existsFolder({
+            workspace: workspace,
+            name: path
+        });
+    }
+    else if (kind === 'trigger') {
+        const triggersKind = [
+            'kafka',
+            'mqtt',
+            'nats',
+            'postgres',
+            'routes',
+            'schedules',
+            'sqs',
+            'websockets',
+            'gcp'
+        ];
+        if (additionalInformation?.triggers &&
+            triggersKind.includes(additionalInformation.triggers.kind)) {
+            return await existsTrigger({ workspace: workspace, path }, additionalInformation.triggers.kind);
+        }
+        else {
+            throw new Error(`Unexpected triggers kind, expected one of: '${triggersKind.join(', ')}' got: ${additionalInformation?.triggers?.kind}`);
+        }
+    }
+    else {
+        throw new Error(`Unknown kind ${kind}`);
+    }
+}
+/**
+ * Get the value of an item for diff comparison.
+ */
+export async function getItemValue(kind, path, workspace, additionalInformation) {
+    try {
+        if (kind === 'flow') {
+            const flow = await FlowService.getFlowByPath({
+                workspace: workspace,
+                path: path
+            });
+            getAllModules(flow.value.modules).forEach((x) => {
+                if (x.value.type === 'script' && x.value.hash != undefined) {
+                    x.value.hash = undefined;
+                }
+            });
+            return { summary: flow.summary, description: flow.description, value: flow.value };
+        }
+        else if (kind === 'script') {
+            const script = await ScriptService.getScriptByPath({
+                workspace: workspace,
+                path: path
+            });
+            return {
+                content: script.content,
+                lock: script.lock,
+                schema: script.schema,
+                summary: script.summary,
+                language: script.language
+            };
+        }
+        else if (kind === 'app') {
+            const app = await AppService.getAppByPath({
+                workspace: workspace,
+                path: path
+            });
+            return app;
+        }
+        else if (kind === 'variable') {
+            const variable = await VariableService.getVariable({
+                workspace: workspace,
+                path: path,
+                decryptSecret: true
+            });
+            return variable.value;
+        }
+        else if (kind === 'resource') {
+            const resource = await ResourceService.getResource({
+                workspace: workspace,
+                path: path
+            });
+            return resource.value;
+        }
+        else if (kind === 'resource_type') {
+            const resource = await ResourceService.getResourceType({
+                workspace: workspace,
+                path: path
+            });
+            return resource.schema;
+        }
+        else if (kind === 'folder') {
+            const folder = await FolderService.getFolder({
+                workspace: workspace,
+                name: path
+            });
+            return {
+                name: folder.name
+            };
+        }
+        else if (kind === 'trigger') {
+            if (additionalInformation?.triggers) {
+                return await getTriggerValue(additionalInformation.triggers.kind, path, workspace);
+            }
+            else {
+                throw new Error(`Missing trigger information`);
+            }
+        }
+        else {
+            throw new Error(`Unknown kind ${kind}`);
+        }
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Get the on_behalf_of_email for a flow, script, app, or trigger (including schedule).
+ */
+export async function getOnBehalfOfEmail(kind, path, workspace, additionalInformation) {
+    try {
+        if (kind === 'flow') {
+            const flow = await FlowService.getFlowByPath({ workspace, path });
+            return flow.on_behalf_of_email;
+        }
+        else if (kind === 'script') {
+            const script = await ScriptService.getScriptByPath({ workspace, path });
+            return script.on_behalf_of_email;
+        }
+        else if (kind === 'app') {
+            const app = await AppService.getAppByPath({ workspace, path });
+            return app.policy.on_behalf_of_email;
+        }
+        else if (kind === 'trigger' && additionalInformation?.triggers) {
+            return await getTriggerEmail(additionalInformation.triggers.kind, path, workspace);
+        }
+    }
+    catch {
+        // Item may not exist in the workspace
+    }
+    return undefined;
+}

package/package/workspace_settings.d.ts

@@ -1,5 +1,5 @@
 import type { GetSettingsResponse, LargeFileStorage } from './gen';
-type S3type = 's3' | 'azure_blob' | 's3_aws_oidc' | 'azure_workload_identity' | 'gcloud_storage';
+type S3type = 's3' | 'azure_blob' | 's3_aws_oidc' | 'azure_workload_identity' | 'gcloud_storage' | 'filesystem';
 export type S3ResourceSettingsItem = {
     resourceType: S3type;
     resourcePath: string | undefined;
@@ -11,6 +11,7 @@ export type S3ResourceSettingsItem = {
 };
 export type S3ResourceSettings = S3ResourceSettingsItem & {
     secondaryStorage: [string, S3ResourceSettingsItem][] | undefined;
+    volumeStorage: string | undefined;
 };
 export declare function convertBackendSettingsToFrontendSettings(large_file_storage: GetSettingsResponse['large_file_storage'], isEnterprise: boolean): S3ResourceSettings;
 export declare function convertBackendSettingsToFrontendSettingsItem(large_file_storage: GetSettingsResponse['large_file_storage'], isEnterprise: boolean): S3ResourceSettingsItem;

package/package/workspace_settings.js

@@ -2,6 +2,7 @@ import { emptyString } from './utils';
 export function convertBackendSettingsToFrontendSettings(large_file_storage, isEnterprise) {
     let settings = convertBackendSettingsToFrontendSettingsItem(large_file_storage, isEnterprise);
     settings.secondaryStorage = Object.entries(large_file_storage?.secondary_storage ?? {}).map(([key, value]) => [key, convertBackendSettingsToFrontendSettingsItem(value, isEnterprise)]);
+    settings.volumeStorage = large_file_storage?.volume_storage ?? undefined;
     return settings;
 }
 export function convertBackendSettingsToFrontendSettingsItem(large_file_storage, isEnterprise) {
@@ -54,6 +55,14 @@ export function convertBackendSettingsToFrontendSettingsItem(large_file_storage,
             advancedPermissions
         };
     }
+    else if (large_file_storage?.type === 'FilesystemStorage') {
+        return {
+            resourceType: 'filesystem',
+            resourcePath: large_file_storage?.root_path,
+            publicResource: large_file_storage?.public_resource,
+            advancedPermissions
+        };
+    }
     else {
         return {
             resourceType: 's3',
@@ -69,11 +78,30 @@ export function convertFrontendToBackendSetting(s3ResourceSettings) {
         settings.secondary_storage = Object.fromEntries((s3ResourceSettings.secondaryStorage ?? [])
             .map(([key, value]) => [key, convertFrontendToBackendettingsItem(value)])
             .filter(([, value]) => value !== undefined));
+        if (s3ResourceSettings.volumeStorage) {
+            ;
+            settings.volume_storage = s3ResourceSettings.volumeStorage;
+        }
     }
     return settings;
 }
 export function convertFrontendToBackendettingsItem(s3ResourceSettings) {
     if (!emptyString(s3ResourceSettings.resourcePath)) {
+        if (s3ResourceSettings.resourceType === 'filesystem') {
+            return {
+                type: 'FilesystemStorage',
+                root_path: s3ResourceSettings.resourcePath,
+                public_resource: s3ResourceSettings.publicResource,
+                ...(s3ResourceSettings.advancedPermissions
+                    ? {
+                        advanced_permissions: s3ResourceSettings.advancedPermissions.map((rule) => ({
+                            ...rule,
+                            allow: rule.allow.join(',')
+                        }))
+                    }
+                    : {})
+            };
+        }
         let resourcePathWithPrefix = `$res:${s3ResourceSettings.resourcePath}`;
         let params = {
             public_resource: s3ResourceSettings.publicResource,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "windmill-components",
-	"version": "1.642.0",
+	"version": "1.655.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",
@@ -27,9 +27,9 @@
 		"@melt-ui/svelte": "^0.86.2",
 		"@playwright/test": "^1.57.0",
 		"@sveltejs/adapter-static": "^3.0.6",
-		"@sveltejs/kit": "^2.49.2",
-		"@sveltejs/package": "^2.3.7",
-		"@sveltejs/vite-plugin-svelte": "^6.2.1",
+		"@sveltejs/kit": "^2.53.4",
+		"@sveltejs/package": "^2.5.7",
+		"@sveltejs/vite-plugin-svelte": "^7.0.0",
 		"@tailwindcss/forms": "^0.5.3",
 		"@tailwindcss/typography": "^0.5.8",
 		"@types/d3": "^7.4.0",
@@ -56,9 +56,9 @@
 		"prettier-plugin-svelte": "^3.3.3",
 		"style-to-object": "^0.4.1",
 		"stylelint-config-recommended": "^13.0.0",
-		"svelte": "^5.38.0",
+		"svelte": "^5.53.5",
 		"svelte-awesome-color-picker": "^3.0.4",
-		"svelte-check": "^4.0.0",
+		"svelte-check": "^4.4.3",
 		"svelte-fast-check": "^0.4.5",
 		"svelte-floating-ui": "^1.5.8",
 		"svelte-highlight": "^7.6.0",
@@ -67,18 +67,19 @@
 		"svelte-range-slider-pips": "^2.3.1",
 		"svelte-splitpanes": "^8.0.9",
 		"tailwindcss": "^3.4.1",
-		"tar": "^7.4.3",
+		"tar": "^7.5.4",
 		"tslib": "^2.6.1",
 		"typescript": "^5.5.0",
-		"vite": "npm:rolldown-vite@7.3.0",
+		"vite": "^8.0.0-beta.16",
 		"vite-plugin-mkcert": "^1.17.5",
-		"vitest": "^4.0.10",
+		"vitest": "^4.1.0-beta.5",
 		"vitest-browser-svelte": "^2.0.1"
 	},
 	"overrides": {
 		"monaco-graphql": {
 			"monaco-editor": "$monaco-editor"
-		}
+		},
+		"tar": "$tar"
 	},
 	"type": "module",
 	"dependencies": {
@@ -93,6 +94,7 @@
 		"@codingame/monaco-vscode-standalone-typescript-language-features": "=25.0.0",
 		"@json2csv/plainjs": "^7.0.6",
 		"@leeoniya/ufuzzy": "^1.0.8",
+		"@popperjs/core": "^2.11.8",
 		"@redocly/json-to-json-schema": "^0.0.1",
 		"@scalar/openapi-parser": "^0.15.0",
 		"@tanstack/svelte-table": "npm:tanstack-table-8-svelte-5@^0.1",
@@ -146,16 +148,17 @@
 		"vscode-languageclient": "~9.0.1",
 		"vscode-uri": "~3.1.0",
 		"vscode-ws-jsonrpc": "~3.5.0",
+		"windmill-parser-wasm-asset": "1.653.0",
 		"windmill-parser-wasm-csharp": "1.510.1",
 		"windmill-parser-wasm-go": "1.510.1",
 		"windmill-parser-wasm-java": "1.510.1",
 		"windmill-parser-wasm-nu": "1.510.1",
-		"windmill-parser-wasm-php": "1.574.1",
-		"windmill-parser-wasm-py": "^1.628.3",
-		"windmill-parser-wasm-regex": "1.639.0",
+		"windmill-parser-wasm-php": "1.647.1",
+		"windmill-parser-wasm-py": "1.653.0",
+		"windmill-parser-wasm-regex": "1.653.0",
 		"windmill-parser-wasm-ruby": "1.526.1",
-		"windmill-parser-wasm-rust": "1.558.1",
-		"windmill-parser-wasm-ts": "1.623.1",
+		"windmill-parser-wasm-rust": "1.647.1",
+		"windmill-parser-wasm-ts": "1.653.0",
 		"windmill-parser-wasm-yaml": "1.593.0",
 		"windmill-sql-datatype-parser-wasm": "1.512.0",
 		"windmill-utils-internal": "^1.3.4",
@@ -281,6 +284,16 @@
 			"svelte": "./package/components/FlowStatusViewer.svelte",
 			"default": "./package/components/FlowStatusViewer.svelte"
 		},
+		"./components/FlowRecordingReplay.svelte": {
+			"types": "./package/components/recording/FlowRecordingReplay.svelte.d.ts",
+			"svelte": "./package/components/recording/FlowRecordingReplay.svelte",
+			"default": "./package/components/recording/FlowRecordingReplay.svelte"
+		},
+		"./components/ScriptRecordingReplay.svelte": {
+			"types": "./package/components/recording/ScriptRecordingReplay.svelte.d.ts",
+			"svelte": "./package/components/recording/ScriptRecordingReplay.svelte",
+			"default": "./package/components/recording/ScriptRecordingReplay.svelte"
+		},
 		"./components/FlowWrapper.svelte": {
 			"types": "./package/components/FlowWrapper.svelte.d.ts",
 			"svelte": "./package/components/FlowWrapper.svelte",
@@ -480,6 +493,12 @@
 			"components/FlowStatusViewer.svelte": [
 				"./package/components/FlowStatusViewer.svelte.d.ts"
 			],
+			"components/FlowRecordingReplay.svelte": [
+				"./package/components/recording/FlowRecordingReplay.svelte.d.ts"
+			],
+			"components/ScriptRecordingReplay.svelte": [
+				"./package/components/recording/ScriptRecordingReplay.svelte.d.ts"
+			],
 			"components/FlowBuilder.svelte": [
 				"./package/components/FlowBuilder.svelte.d.ts"
 			],

package/dist/sharedUtils/components/assets/lib.d.ts

@@ -1,25 +0,0 @@
-import type { AssetKind as _AssetKind, Asset as _Asset, ListAssetsResponse, AssetUsageAccessType, FlowModule, ScriptArgs } from '$lib/gen';
-export type Asset = _Asset;
-export type AssetKind = _AssetKind;
-export type AssetWithAccessType = Asset & {
-    access_type?: AssetUsageAccessType;
-};
-export type AssetWithAltAccessType = AssetWithAccessType & {
-    alt_access_type?: AssetUsageAccessType;
-};
-export declare function formatAsset(asset: Asset): string;
-export declare function formatShortAssetPath(asset: Asset): string;
-export declare function getAssetUsagePageUri(usage: ListAssetsResponse[number]['usages'][number]): string | undefined;
-export declare function assetEq(a: Asset | undefined, b: Asset | undefined): boolean;
-export declare function assetsEq(a: Asset[], b: Asset[]): boolean;
-export declare function parseAssetFromString(s: string): Asset | undefined;
-export declare function formatAssetKind(asset: {
-    kind: AssetKind;
-    metadata?: {
-        resource_type?: string;
-    };
-}): string;
-export declare function formatAssetAccessType(accessType: AssetUsageAccessType | undefined): "?" | "Read" | "Write" | "R/W";
-export declare function getAccessType(asset: AssetWithAltAccessType): AssetUsageAccessType | undefined;
-export declare function getFlowModuleAssets(flowModuleValue: FlowModule, additionalAssetsMap?: Record<string, AssetWithAccessType[]>): AssetWithAccessType[] | undefined;
-export declare function parseInputArgsAssets(args: ScriptArgs): AssetWithAccessType[];