windmill-components 1.695.1 → 1.698.0

package/package/utils_deployable.js

@@ -64,8 +64,13 @@ export async function existsTrigger(data, triggerKind) {
  * changes without flipping the target's enabled/disabled state. Schedules'
  * `EditSchedule` already lacks `enabled` on the backend, but stripping keeps
  * the intent explicit and matches the YAML/CLI round-trip behavior.
+ *
+ * Used by the legacy `kind === 'trigger'` path in `utils_workspace_deploy.ts`
+ * (the cross-workspace deploy UI). The merge-UI deploy goes through the
+ * shared `deployItem` in `windmill-utils-internal`, which applies its own
+ * `stripOperationalStateOnUpdate` at the dispatch layer.
  */
-function stripOperationalState(payload) {
+export function stripOperationalState(payload) {
     const { mode: _mode, enabled: _enabled, ...rest } = payload;
     return rest;
 }
@@ -82,7 +87,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(sqsTrigger),
+                ...sqsTrigger,
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
             },
@@ -97,7 +102,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(kafkaTrigger),
+                ...kafkaTrigger,
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
             },
@@ -112,7 +117,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(mqttTrigger),
+                ...mqttTrigger,
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
             },
@@ -127,7 +132,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(natsTrigger),
+                ...natsTrigger,
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
             },
@@ -146,7 +151,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
             gcpTrigger.delivery_config.audience = '';
         }
         const data = {
-            ...stripOperationalState(gcpTrigger),
+            ...gcpTrigger,
             delivery_config: gcpTrigger.delivery_config ?? undefined,
             base_endpoint: gcpTrigger.delivery_type === 'push' ? `${window.location.origin}${base}` : undefined,
             permissioned_as: onBehalfOf,
@@ -165,7 +170,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(postgresTrigger),
+                ...postgresTrigger,
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
             },
@@ -180,7 +185,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(websocketTrigger),
+                ...websocketTrigger,
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
             },
@@ -195,7 +200,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(httpTrigger),
+                ...httpTrigger,
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
             },
@@ -210,7 +215,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(azureTrigger),
+                ...azureTrigger,
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
             },
@@ -225,7 +230,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(emailTrigger),
+                ...emailTrigger,
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
             },
@@ -240,7 +245,7 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
         });
         return {
             data: {
-                ...stripOperationalState(schedulesTrigger),
+                ...schedulesTrigger,
                 // permissioned_as is only set on create, not update
                 permissioned_as: onBehalfOf,
                 preserve_permissioned_as: preservePermissionedAs
@@ -251,156 +256,75 @@ export async function getTriggersDeployData(kind, path, workspace, onBehalfOf) {
     }
     throw new Error(`Unexpected trigger kind got: ${kind}`);
 }
+/**
+ * Runtime fields stripped from the trigger/schedule diff so the drawer mirrors
+ * the backend's `compare_two_trigger_or_schedule` semantics — same set as
+ * `TRIGGER_COMPARE_IGNORE` and `stripTriggerOrScheduleRuntimeFields` in the
+ * shared deploy module.
+ */
+const TRIGGER_RUNTIME_IGNORE = new Set([
+    'workspace_id',
+    'edited_by',
+    'edited_at',
+    'email',
+    'error',
+    'enabled',
+    'mode',
+    'server_id',
+    'last_server_ping',
+    'extra_perms',
+    'permissioned_as',
+    // Server-managed (kept in sync with backend `TRIGGER_COMPARE_IGNORE`).
+    'subscription_id',
+    'push_auth_config'
+]);
+function stripTriggerRuntimeFields(row) {
+    const out = {};
+    for (const [k, v] of Object.entries(row)) {
+        if (!TRIGGER_RUNTIME_IGNORE.has(k))
+            out[k] = v;
+    }
+    return out;
+}
 export async function getTriggerValue(kind, path, workspace) {
+    let trigger;
     if (kind === 'sqs') {
-        const { mode, script_path, is_flow, queue_url, aws_resource_path, message_attributes } = await SqsTriggerService.getSqsTrigger({
-            workspace: workspace,
-            path: path
-        });
-        return {
-            mode,
-            script_path,
-            is_flow,
-            queue_url,
-            aws_resource_path,
-            message_attributes
-        };
+        trigger = await SqsTriggerService.getSqsTrigger({ workspace, path });
     }
     else if (kind === 'kafka') {
-        const { mode, script_path, is_flow, kafka_resource_path, topics, group_id } = await KafkaTriggerService.getKafkaTrigger({
-            workspace: workspace,
-            path: path
-        });
-        return {
-            mode,
-            script_path,
-            is_flow,
-            kafka_resource_path,
-            topics,
-            group_id
-        };
+        trigger = await KafkaTriggerService.getKafkaTrigger({ workspace, path });
     }
     else if (kind === 'mqtt') {
-        const { mode, script_path, is_flow, mqtt_resource_path, v3_config, v5_config, client_id, subscribe_topics, client_version } = await MqttTriggerService.getMqttTrigger({
-            workspace: workspace,
-            path: path
-        });
-        return {
-            mode,
-            script_path,
-            is_flow,
-            mqtt_resource_path,
-            v3_config,
-            v5_config,
-            client_id,
-            subscribe_topics,
-            client_version
-        };
+        trigger = await MqttTriggerService.getMqttTrigger({ workspace, path });
     }
     else if (kind === 'nats') {
-        const { mode, script_path, is_flow, nats_resource_path, use_jetstream, stream_name, consumer_name, subjects } = await NatsTriggerService.getNatsTrigger({
-            workspace: workspace,
-            path: path
-        });
-        return {
-            mode,
-            script_path,
-            is_flow,
-            nats_resource_path,
-            use_jetstream,
-            stream_name,
-            consumer_name,
-            subjects
-        };
+        trigger = await NatsTriggerService.getNatsTrigger({ workspace, path });
     }
     else if (kind === 'postgres') {
-        const { mode, script_path, is_flow, postgres_resource_path, replication_slot_name, publication_name } = await PostgresTriggerService.getPostgresTrigger({
-            workspace: workspace,
-            path: path
-        });
-        return {
-            mode,
-            script_path,
-            is_flow,
-            postgres_resource_path,
-            replication_slot_name,
-            publication_name
-        };
+        trigger = await PostgresTriggerService.getPostgresTrigger({ workspace, path });
     }
     else if (kind === 'gcp') {
-        const { mode, script_path, is_flow, gcp_resource_path } = await GcpTriggerService.getGcpTrigger({
-            workspace: workspace,
-            path: path
-        });
-        return {
-            mode,
-            script_path,
-            is_flow,
-            gcp_resource_path
-        };
+        trigger = await GcpTriggerService.getGcpTrigger({ workspace, path });
     }
     else if (kind === 'websockets') {
-        const { mode, script_path, is_flow, url, url_runnable_args, can_return_message, filters, initial_messages } = await WebsocketTriggerService.getWebsocketTrigger({
-            workspace: workspace,
-            path: path
-        });
-        return {
-            mode,
-            script_path,
-            is_flow,
-            url,
-            url_runnable_args,
-            can_return_message,
-            filters,
-            initial_messages
-        };
+        trigger = await WebsocketTriggerService.getWebsocketTrigger({ workspace, path });
     }
     else if (kind === 'routes') {
-        const { script_path, is_flow, http_method, route_path, static_asset_config, request_type, authentication_method, is_static_website, authentication_resource_path } = await HttpTriggerService.getHttpTrigger({
-            workspace: workspace,
-            path: path
-        });
-        return {
-            script_path,
-            is_flow,
-            http_method,
-            route_path,
-            static_asset_config,
-            request_type,
-            authentication_method,
-            is_static_website,
-            authentication_resource_path
-        };
+        trigger = await HttpTriggerService.getHttpTrigger({ workspace, path });
     }
     else if (kind === 'schedules') {
-        const { script_path, is_flow, on_failure, schedule, timezone, on_failure_times, on_failure_exact, on_failure_extra_args, on_recovery, on_recovery_times, on_recovery_extra_args, on_success, on_success_extra_args, ws_error_handler_muted, retry, summary, no_flow_overlap, tag, paused_until, cron_version } = await ScheduleService.getSchedule({
-            workspace: workspace,
-            path: path
-        });
-        return {
-            script_path,
-            is_flow,
-            on_failure,
-            schedule,
-            timezone,
-            on_failure_times,
-            on_failure_exact,
-            on_failure_extra_args,
-            on_recovery,
-            on_recovery_times,
-            on_recovery_extra_args,
-            on_success,
-            on_success_extra_args,
-            ws_error_handler_muted,
-            retry,
-            summary,
-            no_flow_overlap,
-            tag,
-            paused_until,
-            cron_version
-        };
+        trigger = await ScheduleService.getSchedule({ workspace, path });
     }
-    throw new Error(`Unexpected trigger kind got: ${kind}`);
+    else if (kind === 'azure') {
+        trigger = await AzureTriggerService.getAzureTrigger({ workspace, path });
+    }
+    else if (kind === 'emails') {
+        trigger = await EmailTriggerService.getEmailTrigger({ workspace, path });
+    }
+    else {
+        throw new Error(`Unexpected trigger kind got: ${kind}`);
+    }
+    return stripTriggerRuntimeFields(trigger);
 }
 /**
  * Get the permissioned_as for a trigger (used for on_behalf_of during deployment).
@@ -443,6 +367,14 @@ export async function getTriggerPermissionedAs(kind, path, workspace) {
             const trigger = await ScheduleService.getSchedule({ workspace, path });
             return trigger.permissioned_as;
         }
+        else if (kind === 'azure') {
+            const trigger = await AzureTriggerService.getAzureTrigger({ workspace, path });
+            return trigger.permissioned_as;
+        }
+        else if (kind === 'emails') {
+            const trigger = await EmailTriggerService.getEmailTrigger({ workspace, path });
+            return trigger.permissioned_as;
+        }
     }
     catch {
         // Trigger may not exist in the workspace

package/package/utils_workspace_deploy.d.ts

@@ -1,11 +1,16 @@
 import { type AdditionalInformation, type Kind } from './utils_deployable';
-import { type DeployResult } from 'windmill-utils-internal';
-export type { DeployResult };
+import { type DeployKind, type DeployResult, type TriggerDeployKind } from 'windmill-utils-internal';
+export type { DeployResult, DeployKind, TriggerDeployKind };
 export interface DeployItemParams {
     kind: Kind;
     path: string;
     workspaceFrom: string;
     workspaceTo: string;
+    /**
+     * Carries the trigger sub-kind for the legacy generic `kind: 'trigger'` path
+     * used by `DeployWorkspace.svelte`. Not needed for the new per-kind names
+     * (`http_trigger`, `kafka_trigger`, …) returned by the fork-merge compare API.
+     */
     additionalInformation?: AdditionalInformation;
     /**
      * The value to use for on_behalf_of when deploying.
@@ -18,8 +23,9 @@ export interface DeployItemParams {
     onBehalfOf?: string;
 }
 /**
- * Deploy an item from one workspace to another.
- * Handles all item kinds: flow, script, app, variable, resource, resource_type, folder, trigger.
+ * Deploy an item from one workspace to another. Handles every kind in the shared
+ * `DeployKind` union plus the legacy generic `'trigger'` from `DeployWorkspace.svelte`,
+ * which carries its sub-kind in `additionalInformation`.
  */
 export declare function deployItem(params: DeployItemParams): Promise<DeployResult>;
 /**

package/package/utils_workspace_deploy.js

@@ -1,9 +1,123 @@
-import { AppService, FlowService, FolderService, ResourceService, ScheduleService, ScriptService, VariableService } from './gen';
-import { existsTrigger, getTriggersDeployData, getTriggerPermissionedAs, getTriggerValue } from './utils_deployable';
+import { AppService, AzureTriggerService, EmailTriggerService, FlowService, FolderService, GcpTriggerService, HttpTriggerService, KafkaTriggerService, MqttTriggerService, NatsTriggerService, PostgresTriggerService, ResourceService, ScheduleService, ScriptService, SqsTriggerService, VariableService, WebsocketTriggerService } from './gen';
+import { existsTrigger, getTriggersDeployData, getTriggerPermissionedAs, getTriggerValue, stripOperationalState } from './utils_deployable';
 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
 // ---------------------------------------------------------------------------
+/**
+ * Map a shared `TriggerDeployKind` (e.g. `kafka_trigger`) to the per-kind
+ * service class. Per-kind dispatch lives in the adapter so the shared
+ * `deployItem` only needs to know "trigger" vs "not trigger".
+ */
+function triggerServiceFor(kind) {
+    switch (kind) {
+        case 'http_trigger':
+            return {
+                exists: HttpTriggerService.existsHttpTrigger,
+                get: HttpTriggerService.getHttpTrigger,
+                create: HttpTriggerService.createHttpTrigger,
+                update: HttpTriggerService.updateHttpTrigger,
+                delete: HttpTriggerService.deleteHttpTrigger
+            };
+        case 'websocket_trigger':
+            return {
+                exists: WebsocketTriggerService.existsWebsocketTrigger,
+                get: WebsocketTriggerService.getWebsocketTrigger,
+                create: WebsocketTriggerService.createWebsocketTrigger,
+                update: WebsocketTriggerService.updateWebsocketTrigger,
+                delete: WebsocketTriggerService.deleteWebsocketTrigger
+            };
+        case 'kafka_trigger':
+            return {
+                exists: KafkaTriggerService.existsKafkaTrigger,
+                get: KafkaTriggerService.getKafkaTrigger,
+                create: KafkaTriggerService.createKafkaTrigger,
+                update: KafkaTriggerService.updateKafkaTrigger,
+                delete: KafkaTriggerService.deleteKafkaTrigger
+            };
+        case 'nats_trigger':
+            return {
+                exists: NatsTriggerService.existsNatsTrigger,
+                get: NatsTriggerService.getNatsTrigger,
+                create: NatsTriggerService.createNatsTrigger,
+                update: NatsTriggerService.updateNatsTrigger,
+                delete: NatsTriggerService.deleteNatsTrigger
+            };
+        case 'postgres_trigger':
+            return {
+                exists: PostgresTriggerService.existsPostgresTrigger,
+                get: PostgresTriggerService.getPostgresTrigger,
+                create: PostgresTriggerService.createPostgresTrigger,
+                update: PostgresTriggerService.updatePostgresTrigger,
+                delete: PostgresTriggerService.deletePostgresTrigger
+            };
+        case 'mqtt_trigger':
+            return {
+                exists: MqttTriggerService.existsMqttTrigger,
+                get: MqttTriggerService.getMqttTrigger,
+                create: MqttTriggerService.createMqttTrigger,
+                update: MqttTriggerService.updateMqttTrigger,
+                delete: MqttTriggerService.deleteMqttTrigger
+            };
+        case 'sqs_trigger':
+            return {
+                exists: SqsTriggerService.existsSqsTrigger,
+                get: SqsTriggerService.getSqsTrigger,
+                create: SqsTriggerService.createSqsTrigger,
+                update: SqsTriggerService.updateSqsTrigger,
+                delete: SqsTriggerService.deleteSqsTrigger
+            };
+        case 'gcp_trigger':
+            return {
+                exists: GcpTriggerService.existsGcpTrigger,
+                get: GcpTriggerService.getGcpTrigger,
+                create: GcpTriggerService.createGcpTrigger,
+                update: GcpTriggerService.updateGcpTrigger,
+                delete: GcpTriggerService.deleteGcpTrigger
+            };
+        case 'azure_trigger':
+            return {
+                exists: AzureTriggerService.existsAzureTrigger,
+                get: AzureTriggerService.getAzureTrigger,
+                create: AzureTriggerService.createAzureTrigger,
+                update: AzureTriggerService.updateAzureTrigger,
+                delete: AzureTriggerService.deleteAzureTrigger
+            };
+        case 'email_trigger':
+            return {
+                exists: EmailTriggerService.existsEmailTrigger,
+                get: EmailTriggerService.getEmailTrigger,
+                create: EmailTriggerService.createEmailTrigger,
+                update: EmailTriggerService.updateEmailTrigger,
+                delete: EmailTriggerService.deleteEmailTrigger
+            };
+        default: {
+            // Exhaustiveness guard: extending TriggerDeployKind without a case here
+            // produces a compile error rather than a silent runtime failure.
+            const _exhaustive = kind;
+            throw new Error(`Unhandled trigger kind: ${_exhaustive}`);
+        }
+    }
+}
+/**
+ * Map the shared `TriggerDeployKind` to the legacy frontend `TriggerKind`
+ * used by helpers in `utils_deployable.ts`.
+ */
+function legacyTriggerKind(kind) {
+    const map = {
+        http_trigger: 'routes',
+        websocket_trigger: 'websockets',
+        kafka_trigger: 'kafka',
+        nats_trigger: 'nats',
+        postgres_trigger: 'postgres',
+        mqtt_trigger: 'mqtt',
+        sqs_trigger: 'sqs',
+        gcp_trigger: 'gcp',
+        azure_trigger: 'azure',
+        email_trigger: 'emails'
+    };
+    return map[kind];
+}
 function makeProvider() {
     return {
         existsFlowByPath: (p) => FlowService.existsFlowByPath(p),
@@ -43,27 +157,61 @@ function makeProvider() {
         getFolder: (p) => FolderService.getFolder(p),
         createFolder: (p) => FolderService.createFolder(p),
         updateFolder: (p) => FolderService.updateFolder(p),
-        deleteFolder: (p) => FolderService.deleteFolder(p)
+        deleteFolder: (p) => FolderService.deleteFolder(p),
+        // Triggers
+        existsTriggerByKind: (kind, p) => triggerServiceFor(kind).exists(p),
+        getTriggerForDeploy: async (kind, p) => {
+            // Reuses the existing per-kind transform map (e.g. GCP wipes
+            // subscription_id and computes base_endpoint from window.location).
+            // Operational-state strip is applied by the shared `deployItem`
+            // after this returns.
+            const { data } = await getTriggersDeployData(legacyTriggerKind(kind), p.path, p.workspace, p.onBehalfOf);
+            return data;
+        },
+        createTriggerByKind: (kind, p) => triggerServiceFor(kind).create(p),
+        updateTriggerByKind: (kind, p) => triggerServiceFor(kind).update(p),
+        deleteTriggerByKind: (kind, p) => triggerServiceFor(kind).delete(p),
+        getTriggerValue: (kind, p) => getTriggerValue(legacyTriggerKind(kind), p.path, p.workspace),
+        getTriggerPermissionedAs: async (kind, p) => {
+            const trigger = await triggerServiceFor(kind).get(p);
+            return trigger?.permissioned_as;
+        },
+        // Schedules
+        existsSchedule: (p) => ScheduleService.existsSchedule(p),
+        getSchedule: (p) => ScheduleService.getSchedule(p),
+        createSchedule: (p) => ScheduleService.createSchedule(p),
+        updateSchedule: (p) => ScheduleService.updateSchedule(p),
+        deleteSchedule: (p) => ScheduleService.deleteSchedule(p)
     };
 }
 /**
- * Deploy an item from one workspace to another.
- * Handles all item kinds: flow, script, app, variable, resource, resource_type, folder, trigger.
+ * Deploy an item from one workspace to another. Handles every kind in the shared
+ * `DeployKind` union plus the legacy generic `'trigger'` from `DeployWorkspace.svelte`,
+ * which carries its sub-kind in `additionalInformation`.
  */
 export async function deployItem(params) {
     const { kind, path, workspaceFrom, workspaceTo, additionalInformation, onBehalfOf } = params;
-    // Triggers are frontend-specific (not in the shared module)
     if (kind === 'trigger') {
+        // Legacy path: `DeployWorkspace.svelte` doesn't know the per-kind trigger
+        // name when building dependency graphs, so it passes `kind: 'trigger'` and
+        // the actual sub-kind in `additionalInformation`. Translate to per-kind.
         if (!additionalInformation?.triggers) {
             return { success: false, error: 'Missing triggers kind' };
         }
         try {
-            const alreadyExists = await checkItemExists(kind, path, workspaceTo, additionalInformation);
+            const alreadyExists = await existsTrigger({ workspace: workspaceTo, path }, additionalInformation.triggers.kind);
             const { data, createFn, updateFn } = await getTriggersDeployData(additionalInformation.triggers.kind, path, workspaceFrom, onBehalfOf);
             if (alreadyExists) {
-                await updateFn({ path, workspace: workspaceTo, requestBody: data });
+                // Strip operational state so the update doesn't flip the target's
+                // existing enabled/mode flag — preserved via `is_mode_unspecified()`
+                // on the backend. Mirrors the shared `stripOperationalStateOnUpdate`
+                // in the merge-deploy path.
+                const stripped = stripOperationalState(data);
+                await updateFn({ path, workspace: workspaceTo, requestBody: stripped });
             }
             else {
+                // Create — pass source's `mode`/`enabled` through so a new
+                // trigger lands with the state the source workspace had.
                 await createFn({ workspace: workspaceTo, requestBody: data });
             }
             return { success: true };
@@ -86,31 +234,11 @@ export async function deleteItemInWorkspace(kind, path, workspace) {
  * Check if an item already exists in the target workspace.
  */
 export async function checkItemExists(kind, path, workspace, additionalInformation) {
-    // Triggers and schedules are frontend-specific
-    if (kind === 'schedule') {
-        return ScheduleService.existsSchedule({ workspace, path });
-    }
-    else if (kind === 'trigger') {
-        const triggersKind = [
-            'kafka',
-            'mqtt',
-            'nats',
-            'postgres',
-            'routes',
-            'schedules',
-            'sqs',
-            'websockets',
-            'gcp',
-            'azure',
-            'emails'
-        ];
-        if (additionalInformation?.triggers &&
-            triggersKind.includes(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}`);
+    if (kind === 'trigger') {
+        if (!additionalInformation?.triggers) {
+            throw new Error('Missing triggers kind for legacy trigger deploy');
         }
+        return existsTrigger({ workspace, path }, additionalInformation.triggers.kind);
     }
     return sharedCheckItemExists(makeProvider(), kind, path, workspace);
 }
@@ -118,17 +246,15 @@ export async function checkItemExists(kind, path, workspace, additionalInformati
  * Get the value of an item for diff comparison.
  */
 export async function getItemValue(kind, path, workspace, additionalInformation) {
-    // Triggers are frontend-specific
     if (kind === 'trigger') {
-        if (additionalInformation?.triggers) {
-            try {
-                return await getTriggerValue(additionalInformation.triggers.kind, path, workspace);
-            }
-            catch {
-                return {};
-            }
+        if (!additionalInformation?.triggers)
+            return {};
+        try {
+            return await getTriggerValue(additionalInformation.triggers.kind, path, workspace);
+        }
+        catch {
+            return {};
         }
-        return {};
     }
     return sharedGetItemValue(makeProvider(), kind, path, workspace);
 }
@@ -136,7 +262,6 @@ export async function getItemValue(kind, path, workspace, additionalInformation)
  * Get the on_behalf_of value for a deployable item.
  */
 export async function getOnBehalfOf(kind, path, workspace, additionalInformation) {
-    // Triggers are frontend-specific
     if (kind === 'trigger' && additionalInformation?.triggers) {
         try {
             return await getTriggerPermissionedAs(additionalInformation.triggers.kind, path, workspace);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "windmill-components",
-	"version": "1.695.1",
+	"version": "1.698.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build",
@@ -159,11 +159,11 @@
 		"windmill-parser-wasm-regex": "1.692.0",
 		"windmill-parser-wasm-ruby": "1.526.1",
 		"windmill-parser-wasm-rust": "1.647.1",
-		"windmill-parser-wasm-ts": "1.693.1",
+		"windmill-parser-wasm-ts": "1.695.0",
 		"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.4.0",
+		"windmill-utils-internal": "^1.7.0",
 		"xterm": "^5.3.0",
 		"xterm-readline": "^1.1.2",
 		"y-monaco": "^0.1.4",
@@ -379,6 +379,10 @@
 			"types": "./package/stores.d.ts",
 			"default": "./package/stores.js"
 		},
+		"./externalDomain": {
+			"types": "./package/externalDomain.d.ts",
+			"default": "./package/externalDomain.js"
+		},
 		"./gen": {
 			"types": "./package/gen/index.d.ts",
 			"default": "./package/gen/index.js"