windmill-components 1.677.0 → 1.687.0

package/package/utils_workspace_deploy.js

@@ -1,9 +1,50 @@
 import { AppService, FlowService, FolderService, ResourceService, ScheduleService, ScriptService, VariableService } from './gen';
-import { getAllModules } from './components/flows/flowExplorer';
 import { existsTrigger, getTriggersDeployData, getTriggerPermissionedAs, getTriggerValue } from './utils_deployable';
-/** Folder diff paths carry the `f/` prefix (e.g. `f/test`), but folder API endpoints expect just the name. */
-function folderName(path) {
-    return path.replace(/^f\//, '');
+import { deployItem as sharedDeployItem, deleteItemInWorkspace as sharedDeleteItem, checkItemExists as sharedCheckItemExists, getOnBehalfOf as sharedGetOnBehalfOf, getItemValue as sharedGetItemValue } from 'windmill-utils-internal';
+// ---------------------------------------------------------------------------
+// Provider adapter — wraps frontend's class-based services
+// ---------------------------------------------------------------------------
+function makeProvider() {
+    return {
+        existsFlowByPath: (p) => FlowService.existsFlowByPath(p),
+        existsScriptByPath: (p) => ScriptService.existsScriptByPath(p),
+        existsApp: (p) => AppService.existsApp(p),
+        existsVariable: (p) => VariableService.existsVariable(p),
+        existsResource: (p) => ResourceService.existsResource(p),
+        existsResourceType: (p) => ResourceService.existsResourceType(p),
+        existsFolder: (p) => FolderService.existsFolder(p),
+        getFlowByPath: (p) => FlowService.getFlowByPath(p),
+        createFlow: (p) => FlowService.createFlow(p),
+        updateFlow: (p) => FlowService.updateFlow(p),
+        archiveFlowByPath: (p) => FlowService.archiveFlowByPath(p),
+        getScriptByPath: (p) => ScriptService.getScriptByPath(p),
+        createScript: (p) => ScriptService.createScript(p),
+        archiveScriptByPath: (p) => ScriptService.archiveScriptByPath(p),
+        getAppByPath: (p) => AppService.getAppByPath(p),
+        createApp: (p) => AppService.createApp(p),
+        updateApp: (p) => AppService.updateApp(p),
+        createAppRaw: (p) => AppService.createAppRaw(p),
+        updateAppRaw: (p) => AppService.updateAppRaw(p),
+        getPublicSecretOfLatestVersionOfApp: (p) => AppService.getPublicSecretOfLatestVersionOfApp(p),
+        getRawAppData: (p) => AppService.getRawAppData(p),
+        deleteApp: (p) => AppService.deleteApp(p),
+        getVariable: (p) => VariableService.getVariable(p),
+        createVariable: (p) => VariableService.createVariable(p),
+        updateVariable: (p) => VariableService.updateVariable(p),
+        deleteVariable: (p) => VariableService.deleteVariable(p),
+        getResource: (p) => ResourceService.getResource(p),
+        createResource: (p) => ResourceService.createResource(p),
+        updateResource: (p) => ResourceService.updateResource(p),
+        deleteResource: (p) => ResourceService.deleteResource(p),
+        getResourceType: (p) => ResourceService.getResourceType(p),
+        createResourceType: (p) => ResourceService.createResourceType(p),
+        updateResourceType: (p) => ResourceService.updateResourceType(p),
+        deleteResourceType: (p) => ResourceService.deleteResourceType(p),
+        getFolder: (p) => FolderService.getFolder(p),
+        createFolder: (p) => FolderService.createFolder(p),
+        updateFolder: (p) => FolderService.updateFolder(p),
+        deleteFolder: (p) => FolderService.deleteFolder(p)
+    };
 }
 /**
  * Deploy an item from one workspace to another.
@@ -11,332 +52,43 @@ function folderName(path) {
  */
 export async function deployItem(params) {
     const { kind, path, workspaceFrom, workspaceTo, additionalInformation, onBehalfOf } = params;
-    // When onBehalfOf is set, we preserve the on_behalf_of setting with the specified value
-    const preserveOnBehalfOf = onBehalfOf !== 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;
-                }
-            });
+    // Triggers are frontend-specific (not in the shared module)
+    if (kind === 'trigger') {
+        if (!additionalInformation?.triggers) {
+            return { success: false, error: 'Missing triggers kind' };
+        }
+        try {
+            const alreadyExists = await checkItemExists(kind, path, workspaceTo, additionalInformation);
+            const { data, createFn, updateFn } = await getTriggersDeployData(additionalInformation.triggers.kind, path, workspaceFrom, onBehalfOf);
             if (alreadyExists) {
-                await FlowService.updateFlow({
-                    workspace: workspaceTo,
-                    path: path,
-                    requestBody: {
-                        ...flow,
-                        preserve_on_behalf_of: preserveOnBehalfOf,
-                        on_behalf_of_email: onBehalfOf
-                    }
-                });
+                await updateFn({ path, workspace: workspaceTo, requestBody: data });
             }
             else {
-                await FlowService.createFlow({
-                    workspace: workspaceTo,
-                    requestBody: {
-                        ...flow,
-                        preserve_on_behalf_of: preserveOnBehalfOf,
-                        on_behalf_of_email: onBehalfOf
-                    }
-                });
+                await createFn({ workspace: workspaceTo, requestBody: data });
             }
+            return { success: true };
         }
-        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: onBehalfOf
-                }
-            });
+        catch (e) {
+            return { success: false, error: e.body || e.message || String(e) };
         }
-        else if (kind === 'app' || kind === 'raw_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') {
-            const name = folderName(path);
-            const folder = await FolderService.getFolder({
-                workspace: workspaceFrom,
-                name
-            });
-            if (alreadyExists) {
-                await FolderService.updateFolder({
-                    workspace: workspaceTo,
-                    name,
-                    requestBody: {
-                        owners: folder.owners,
-                        extra_perms: folder.extra_perms,
-                        summary: folder.summary ?? undefined
-                    }
-                });
-            }
-            else {
-                await FolderService.createFolder({
-                    workspace: workspaceTo,
-                    requestBody: {
-                        name,
-                        owners: folder.owners,
-                        extra_perms: folder.extra_perms,
-                        summary: folder.summary ?? undefined
-                    }
-                });
-            }
-        }
-        else if (kind === 'trigger') {
-            if (additionalInformation?.triggers) {
-                const { data, createFn, updateFn } = await getTriggersDeployData(additionalInformation.triggers.kind, path, workspaceFrom, onBehalfOf);
-                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 };
     }
+    return sharedDeployItem(makeProvider(), kind, path, workspaceFrom, workspaceTo, onBehalfOf);
+}
+/**
+ * Delete/archive an item in a workspace.
+ * Used when deploying a deletion from one workspace to another.
+ * Scripts and flows are archived (reversible). Other types are deleted.
+ */
+export async function deleteItemInWorkspace(kind, path, workspace) {
+    return sharedDeleteItem(makeProvider(), kind, path, workspace);
 }
 /**
  * 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' || kind === 'raw_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: folderName(path)
-        });
+    // Triggers and schedules are frontend-specific
+    if (kind === 'schedule') {
+        return ScheduleService.existsSchedule({ workspace, path });
     }
     else if (kind === 'trigger') {
         const triggersKind = [
@@ -352,130 +104,44 @@ export async function checkItemExists(kind, path, workspace, additionalInformati
         ];
         if (additionalInformation?.triggers &&
             triggersKind.includes(additionalInformation.triggers.kind)) {
-            return await existsTrigger({ workspace: workspace, path }, additionalInformation.triggers.kind);
+            return existsTrigger({ 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}`);
-    }
+    return sharedCheckItemExists(makeProvider(), kind, path, workspace);
 }
 /**
  * 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' || kind === 'raw_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: folderName(path)
-            });
-            return {
-                name: folder.name,
-                owners: folder.owners,
-                extra_perms: folder.extra_perms,
-                summary: folder.summary
-            };
-        }
-        else if (kind === 'trigger') {
-            if (additionalInformation?.triggers) {
+    // Triggers are frontend-specific
+    if (kind === 'trigger') {
+        if (additionalInformation?.triggers) {
+            try {
                 return await getTriggerValue(additionalInformation.triggers.kind, path, workspace);
             }
-            else {
-                throw new Error(`Missing trigger information`);
+            catch {
+                return {};
             }
         }
-        else {
-            throw new Error(`Unknown kind ${kind}`);
-        }
-    }
-    catch {
         return {};
     }
+    return sharedGetItemValue(makeProvider(), kind, path, workspace);
 }
 /**
  * Get the on_behalf_of value for a deployable item.
- *
- * Return type varies by item kind:
- * - For flows/scripts/apps: returns on_behalf_of_email (an email address)
- * - For triggers/schedules: returns permissioned_as (u/username or g/group format)
  */
 export async function getOnBehalfOf(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' || kind === 'raw_app') {
-            const app = await AppService.getAppByPath({ workspace, path });
-            return app.policy.on_behalf_of_email;
-        }
-        else if (kind === 'trigger' && additionalInformation?.triggers) {
+    // Triggers are frontend-specific
+    if (kind === 'trigger' && additionalInformation?.triggers) {
+        try {
             return await getTriggerPermissionedAs(additionalInformation.triggers.kind, path, workspace);
         }
+        catch {
+            return undefined;
+        }
     }
-    catch {
-        // Item may not exist in the workspace
-    }
-    return undefined;
+    return sharedGetOnBehalfOf(makeProvider(), kind, path, workspace);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "windmill-components",
-	"version": "1.677.0",
+	"version": "1.687.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",
@@ -71,7 +71,7 @@
 		"tslib": "^2.6.1",
 		"typescript": "^5.5.0",
 		"vite": "^8.0.0",
-		"vite-plugin-mkcert": "^1.17.5",
+		"vite-plugin-mkcert": "^2.0.0",
 		"vitest": "^4.1.0",
 		"vitest-browser-svelte": "^2.0.1"
 	},
@@ -163,7 +163,7 @@
 		"windmill-parser-wasm-wac": "1.668.6",
 		"windmill-parser-wasm-yaml": "1.593.0",
 		"windmill-sql-datatype-parser-wasm": "1.512.0",
-		"windmill-utils-internal": "^1.3.4",
+		"windmill-utils-internal": "^1.3.8",
 		"xterm": "^5.3.0",
 		"xterm-readline": "^1.1.2",
 		"y-monaco": "^0.1.4",
@@ -592,4 +592,4 @@
 		"@rollup/rollup-linux-x64-gnu": "^4.35.0",
 		"fsevents": "^2.3.3"
 	}
-}
+}