windmill-components 1.687.0 → 1.695.0

package/package/components/ArgInput.svelte

@@ -586,6 +586,8 @@ onDestroy(() => {
 				{appPath}
 				{computeS3ForceViewerPolicies}
 				bottom={innerBottomSnippet}
+				hideCatalogPicker={extra?.['hideCatalogPicker'] ?? false}
+				hideRawInput={extra?.['hideRawInput'] ?? false}
 			/>
 		{:else if inputCat == 'object' && format == 'json-schema'}
 			{#await import('./EditableSchemaForm.svelte')}

package/package/components/AutoscalingConfigEditor.svelte

@@ -13,6 +13,7 @@ import { ConfigService } from '../gen';
 import Select from './select/Select.svelte';
 import ScriptPicker from './ScriptPicker.svelte';
 import Badge from './common/badge/Badge.svelte';
+import { sendUserToast } from '../toast';
 let { config = $bindable(), worker_tags, disabled, eeOnly = false } = $props();
 let test_input = $state(3);
 let healthCheckLoading = $state(false);
@@ -206,13 +207,13 @@ let collapsed = $state(true);
 								id="custom_tag_select"
 								disabled={!config || !config.integration || disabled}
 								bind:value={
-									() => config?.integration?.['tags'] ?? undefined,
+									() => config?.integration?.['tag'] ?? undefined,
 									(v) => {
 										if (!config || !config.integration) return
 										if (!v || v === '') {
-											delete config.integration['tags']
+											delete config.integration['tag']
 										} else {
-											config.integration['tags'] = v
+											config.integration['tag'] = v
 										}
 									}
 								}
@@ -220,7 +221,20 @@ let collapsed = $state(true);
 							/>
 
 							<div class="flex flex-row gap-2 justify-end mt-4">
-								<Button variant="default" unifiedSize="md">Test scaling</Button>
+								<Button
+									variant="default"
+									unifiedSize="md"
+									onclick={() => {
+										if (!config?.integration?.['path']) {
+											sendUserToast('Please select a script before testing scaling', true)
+											return
+										}
+										if (!config?.integration?.['tag']) {
+											sendUserToast('Please select a custom tag before testing scaling', true)
+											return
+										}
+									}}>Test scaling</Button
+								>
 								<div class="flex text-xs flex-row gap-2 items-center">
 									<input class="!w-16" type="number" bind:value={test_input} />
 									workers

package/package/components/CompareWorkspaces.svelte

@@ -1,26 +1,19 @@
-<script lang="ts">import { AlertTriangle, ArrowDown, ArrowDownRight, ArrowRight, ArrowUp, ArrowUpRight, Building, CircleCheck, CircleX, DiffIcon, Eye, FileJson, FlaskConical, GitFork, Loader2, Trash2, UserPlus } from 'lucide-svelte';
+<script lang="ts">import { AlertTriangle, ArrowDown, ArrowDownRight, ArrowRight, ArrowUp, ArrowUpRight, Building, CircleCheck, CircleX, DiffIcon, FileJson, FlaskConical, GitFork, Loader2, UserPlus } from 'lucide-svelte';
 import { Alert, Badge } from './common';
-import { AppService, EmailTriggerService, FlowService, FolderService, GcpTriggerService, HttpTriggerService, KafkaTriggerService, MqttTriggerService, NatsTriggerService, PostgresTriggerService, ScheduleService, ScriptService, SqsTriggerService, UserService, WebsocketTriggerService, WorkspaceService } from '../gen';
+import { AppService, EmailTriggerService, FlowService, FolderService, AzureTriggerService, GcpTriggerService, HttpTriggerService, KafkaTriggerService, MqttTriggerService, NatsTriggerService, PostgresTriggerService, ScheduleService, ScriptService, SqsTriggerService, UserService, WebsocketTriggerService, WorkspaceService } from '../gen';
 import Button from './common/button/Button.svelte';
-import ConfirmationModal from './common/confirmationModal/ConfirmationModal.svelte';
 import DiffDrawer from './DiffDrawer.svelte';
+import DiffEditor from './DiffEditor.svelte';
+import Drawer from './common/drawer/Drawer.svelte';
+import DrawerContent from './common/drawer/DrawerContent.svelte';
 import ParentWorkspaceProtectionAlert from './ParentWorkspaceProtectionAlert.svelte';
-import ScheduleEditor from './triggers/schedules/ScheduleEditor.svelte';
-import RouteEditor from './triggers/http/RouteEditor.svelte';
-import WebsocketTriggerEditor from './triggers/websocket/WebsocketTriggerEditor.svelte';
-import KafkaTriggerEditor from './triggers/kafka/KafkaTriggerEditor.svelte';
-import PostgresTriggerEditor from './triggers/postgres/PostgresTriggerEditor.svelte';
-import NatsTriggerEditor from './triggers/nats/NatsTriggerEditor.svelte';
-import MqttTriggerEditor from './triggers/mqtt/MqttTriggerEditor.svelte';
-import SqsTriggerEditor from './triggers/sqs/SqsTriggerEditor.svelte';
-import GcpTriggerEditor from './triggers/gcp/GcpTriggerEditor.svelte';
-import EmailTriggerEditor from './triggers/email/EmailTriggerEditor.svelte';
 import { userWorkspaces, workspaceStore } from '../stores';
 import { deployItem, deleteItemInWorkspace, getItemValue, getOnBehalfOf } from '../utils_workspace_deploy';
 import Tooltip from './Tooltip.svelte';
 import OnBehalfOfSelector, { needsOnBehalfOfSelection } from './OnBehalfOfSelector.svelte';
 import { sendUserToast } from '../toast';
 import { deepEqual } from 'fast-equals';
+import { orderedJsonStringify, orderedYamlStringify } from '../utils';
 import WorkspaceDeployLayout from './WorkspaceDeployLayout.svelte';
 import DeploymentRequestPanel from './deploymentRequest/DeploymentRequestPanel.svelte';
 import { userStore } from '../stores';
@@ -416,6 +409,8 @@ let deployableItems = $derived.by(() => {
     }));
     const triggerItems = forkTriggers
         .filter((t) => {
+        if (!isTriggerRelevantForDirection(t, mergeIntoParent))
+            return false;
         const key = getTriggerKey(t);
         return deploymentStatus[key]?.status !== 'deployed';
     })
@@ -423,6 +418,7 @@ let deployableItems = $derived.by(() => {
         key: getTriggerKey(trigger),
         path: trigger.path,
         kind: 'trigger',
+        triggerKind: trigger.triggerKind,
         diff: undefined,
         trigger
     }));
@@ -480,185 +476,211 @@ let allCiTests = $derived.by(() => {
     return [...seen.values()];
 });
 let forkTriggers = $state([]);
-let triggerToDelete = $state(undefined);
 let deploymentRequestPanel = $state(undefined);
 let hasOpenDeploymentRequest = $state(false);
-// Trigger detail drawer refs — one per trigger kind. Each is lazy-mounted
-// on first openEdit() call, so having them all sit here is cheap.
-let scheduleEditor = $state();
-let routeEditor = $state();
-let websocketEditor = $state();
-let kafkaEditor = $state();
-let postgresEditor = $state();
-let natsEditor = $state();
-let mqttEditor = $state();
-let sqsEditor = $state();
-let gcpEditor = $state();
-let emailEditor = $state();
-function openTriggerDetails(trigger) {
-    const isFlow = trigger.isFlow;
-    switch (trigger.triggerKind) {
-        case 'schedules':
-            scheduleEditor?.openEdit(trigger.path, isFlow);
-            break;
-        case 'routes':
-            routeEditor?.openEdit(trigger.path, isFlow);
-            break;
-        case 'websockets':
-            websocketEditor?.openEdit(trigger.path, isFlow);
-            break;
-        case 'kafka':
-            kafkaEditor?.openEdit(trigger.path, isFlow);
-            break;
-        case 'postgres':
-            postgresEditor?.openEdit(trigger.path, isFlow);
-            break;
-        case 'nats':
-            natsEditor?.openEdit(trigger.path, isFlow);
-            break;
-        case 'mqtt':
-            mqttEditor?.openEdit(trigger.path, isFlow);
-            break;
-        case 'sqs':
-            sqsEditor?.openEdit(trigger.path, isFlow);
-            break;
-        case 'gcp':
-            gcpEditor?.openEdit(trigger.path, isFlow);
-            break;
-        case 'emails':
-            emailEditor?.openEdit(trigger.path, isFlow);
-            break;
-    }
-}
-/** Deployable trigger kinds and their list+delete services */
+/** Deployable trigger kinds and their list services */
 const triggerServices = {
     schedules: {
         list: (ws) => ScheduleService.listSchedules({ workspace: ws }),
-        delete: (ws, path) => ScheduleService.deleteSchedule({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'schedules',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.enabled,
-            extraLabel: item.schedule
+            extraLabel: item.schedule,
+            raw: item
         })
     },
     routes: {
         list: (ws) => HttpTriggerService.listHttpTriggers({ workspace: ws }),
-        delete: (ws, path) => HttpTriggerService.deleteHttpTrigger({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'routes',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.mode === 'enabled',
             extraLabel: `${(item.http_method ?? 'get').toUpperCase()} ${item.route_path ?? ''}`
         })
     },
     websockets: {
         list: (ws) => WebsocketTriggerService.listWebsocketTriggers({ workspace: ws }),
-        delete: (ws, path) => WebsocketTriggerService.deleteWebsocketTrigger({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'websockets',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.mode === 'enabled',
-            extraLabel: item.url
+            extraLabel: item.url,
+            raw: item
         })
     },
     kafka: {
         list: (ws) => KafkaTriggerService.listKafkaTriggers({ workspace: ws }),
-        delete: (ws, path) => KafkaTriggerService.deleteKafkaTrigger({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'kafka',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.mode === 'enabled',
-            extraLabel: item.topics?.join(', ')
+            extraLabel: item.topics?.join(', '),
+            raw: item
         })
     },
     postgres: {
         list: (ws) => PostgresTriggerService.listPostgresTriggers({ workspace: ws }),
-        delete: (ws, path) => PostgresTriggerService.deletePostgresTrigger({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'postgres',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.mode === 'enabled'
+            raw: item
         })
     },
     nats: {
         list: (ws) => NatsTriggerService.listNatsTriggers({ workspace: ws }),
-        delete: (ws, path) => NatsTriggerService.deleteNatsTrigger({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'nats',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.mode === 'enabled',
-            extraLabel: item.subjects?.join(', ')
+            extraLabel: item.subjects?.join(', '),
+            raw: item
         })
     },
     mqtt: {
         list: (ws) => MqttTriggerService.listMqttTriggers({ workspace: ws }),
-        delete: (ws, path) => MqttTriggerService.deleteMqttTrigger({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'mqtt',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.mode === 'enabled'
+            raw: item
         })
     },
     sqs: {
         list: (ws) => SqsTriggerService.listSqsTriggers({ workspace: ws }),
-        delete: (ws, path) => SqsTriggerService.deleteSqsTrigger({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'sqs',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.mode === 'enabled',
-            extraLabel: item.queue_url
+            extraLabel: item.queue_url,
+            raw: item
         })
     },
     gcp: {
         list: (ws) => GcpTriggerService.listGcpTriggers({ workspace: ws }),
-        delete: (ws, path) => GcpTriggerService.deleteGcpTrigger({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'gcp',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.mode === 'enabled',
-            extraLabel: item.topic_id
+            extraLabel: item.topic_id,
+            raw: item
+        })
+    },
+    azure: {
+        list: (ws) => AzureTriggerService.listAzureTriggers({ workspace: ws }),
+        normalize: (item) => ({
+            path: item.path,
+            triggerKind: 'azure',
+            scriptPath: item.script_path,
+            isFlow: item.is_flow,
+            extraLabel: item.topic_name ?? item.scope_resource_id,
+            raw: item
         })
     },
     emails: {
         list: (ws) => EmailTriggerService.listEmailTriggers({ workspace: ws }),
-        delete: (ws, path) => EmailTriggerService.deleteEmailTrigger({ workspace: ws, path }),
         normalize: (item) => ({
             path: item.path,
             triggerKind: 'emails',
             scriptPath: item.script_path,
             isFlow: item.is_flow,
-            enabled: item.mode === 'enabled',
-            extraLabel: getEmailAddress(item.local_part, item.workspaced_local_part, currentWorkspaceId, emailDomain ?? '')
+            extraLabel: getEmailAddress(item.local_part, item.workspaced_local_part, currentWorkspaceId, emailDomain ?? ''),
+            raw: item
         })
     }
 };
 let emailDomain = $state(undefined);
+/**
+ * Fields that should not count as a "change" between the parent and the
+ * fork. Mode/enabled are forced to 'disabled'/false on clone and stripped
+ * by the fork-export filter; the rest are runtime state or per-row
+ * metadata that always diverges. Comparing without these matches the
+ * semantics of "is this trigger configured the same way?" rather than
+ * "are these two rows byte-identical?".
+ */
+const TRIGGER_COMPARE_IGNORE = new Set([
+    'workspace_id',
+    'mode',
+    'enabled',
+    'edited_at',
+    'edited_by',
+    'last_server_ping',
+    'server_id',
+    'error',
+    'extra_perms',
+    'permissioned_as'
+]);
+function stripIgnoredFields(row) {
+    if (!row || typeof row !== 'object')
+        return row;
+    const out = {};
+    for (const [k, v] of Object.entries(row)) {
+        if (!TRIGGER_COMPARE_IGNORE.has(k))
+            out[k] = v;
+    }
+    return out;
+}
+function rowsHaveSameConfig(a, b) {
+    return (orderedJsonStringify(stripIgnoredFields(a)) === orderedJsonStringify(stripIgnoredFields(b)));
+}
 async function fetchAllTriggers() {
     try {
         emailDomain = await getEmailDomain();
-        const entries = Object.values(triggerServices);
-        const results = await Promise.allSettled(entries.map(async (svc) => {
-            const items = await svc.list(currentWorkspaceId);
-            return items.map(svc.normalize);
+        const entries = Object.entries(triggerServices);
+        // Fetch fork + parent in parallel for each kind. Either side may
+        // fail (e.g. permission denied on parent) — fall back to empty.
+        const results = await Promise.allSettled(entries.map(async ([kind, svc]) => {
+            const [forkItems, parentItems] = await Promise.all([
+                svc.list(currentWorkspaceId).catch(() => []),
+                svc.list(parentWorkspaceId).catch(() => [])
+            ]);
+            const byPath = new Map();
+            for (const item of forkItems) {
+                byPath.set(item.path, { fork: item });
+            }
+            for (const item of parentItems) {
+                const entry = byPath.get(item.path) ?? {};
+                entry.parent = item;
+                byPath.set(item.path, entry);
+            }
+            const merged = [];
+            for (const [path, entry] of byPath) {
+                const sourceItem = entry.fork ?? entry.parent;
+                const normalized = svc.normalize(sourceItem);
+                let changeKind;
+                let hasChanges = false;
+                if (entry.fork && !entry.parent) {
+                    changeKind = 'new';
+                }
+                else if (!entry.fork && entry.parent) {
+                    changeKind = 'deleted-in-source';
+                }
+                else if (entry.fork && entry.parent) {
+                    hasChanges = !rowsHaveSameConfig(entry.fork, entry.parent);
+                    if (hasChanges)
+                        changeKind = 'modified';
+                }
+                merged.push({
+                    ...normalized,
+                    raw: sourceItem,
+                    hasChanges,
+                    changeKind,
+                    sourceRaw: entry.fork,
+                    targetRaw: entry.parent,
+                    path
+                });
+            }
+            return merged;
         }));
         forkTriggers = results.flatMap((r) => (r.status === 'fulfilled' ? r.value : []));
     }
@@ -667,33 +689,48 @@ async function fetchAllTriggers() {
         forkTriggers = [];
     }
 }
-function deleteTrigger(trigger) {
-    triggerToDelete = trigger;
-}
-async function confirmDeleteTrigger() {
-    const trigger = triggerToDelete;
-    if (!trigger)
-        return;
-    triggerToDelete = undefined;
-    const triggerType = triggerKindToTriggerType(trigger.triggerKind);
-    const displayName = triggerType ? triggerDisplayNamesMap[triggerType] : trigger.triggerKind;
-    try {
-        const svc = triggerServices[trigger.triggerKind];
-        if (!svc) {
-            throw new Error(`No service for trigger kind: ${trigger.triggerKind}`);
-        }
-        await svc.delete(currentWorkspaceId, trigger.path);
-        forkTriggers = forkTriggers.filter((t) => !(t.path === trigger.path && t.triggerKind === trigger.triggerKind));
-        sendUserToast(`Deleted ${displayName} trigger '${trigger.path}'`);
+/**
+ * Triggers worth showing in the merge UI given the current direction.
+ * - "Deploy to parent": rows that exist in fork and either don't exist in
+ *   parent or have config differences.
+ * - "Update current" (pull from parent): mirror.
+ * Triggers that exist on both sides with identical config are filtered
+ * out — they would generate a no-op deploy and only add noise.
+ */
+function isTriggerRelevantForDirection(t, deployingToParent) {
+    const existsInFork = !!t.sourceRaw;
+    const existsInParent = !!t.targetRaw;
+    if (deployingToParent) {
+        return existsInFork && (!existsInParent || !!t.hasChanges);
     }
-    catch (e) {
-        sendUserToast(`Failed to delete trigger '${trigger.path}': ${e.body || e.message}`, true);
+    else {
+        return existsInParent && (!existsInFork || !!t.hasChanges);
     }
 }
 function getTriggerDisplayName(triggerKind) {
     const triggerType = triggerKindToTriggerType(triggerKind);
     return triggerType ? triggerDisplayNamesMap[triggerType] : triggerKind;
 }
+let triggerDiffOpen = $state(false);
+let triggerDiffPayload = $state(undefined);
+function openTriggerDiff(t) {
+    // `sourceRaw` is the fork row, `targetRaw` is the parent row regardless
+    // of direction (set in fetchAllTriggers). The diff reads from the
+    // destination (left) to the source (right), matching the deploy arrow.
+    const sourceWorkspace = mergeIntoParent ? currentWorkspaceId : parentWorkspaceId;
+    const targetWorkspace = mergeIntoParent ? parentWorkspaceId : currentWorkspaceId;
+    const fromRow = mergeIntoParent ? t.sourceRaw : t.targetRaw;
+    const toRow = mergeIntoParent ? t.targetRaw : t.sourceRaw;
+    triggerDiffPayload = {
+        kindLabel: getTriggerDisplayName(t.triggerKind),
+        path: t.path,
+        originalLabel: `${targetWorkspace} (target)`,
+        modifiedLabel: `${sourceWorkspace} (source)`,
+        original: orderedYamlStringify(stripIgnoredFields(toRow ?? {})),
+        modified: orderedYamlStringify(stripIgnoredFields(fromRow ?? {}))
+    };
+    triggerDiffOpen = true;
+}
 // Fetch triggers when workspace is available
 $effect(() => {
     if (currentWorkspaceId) {
@@ -901,7 +938,10 @@ $effect(() => {
 					{#if item.trigger}
 						{@const t = item.trigger as ForkTrigger}
 						<span class="text-emphasis">{getTriggerDisplayName(t.triggerKind)}</span>
-						<span class="text-secondary mx-1">&rarr;</span>
+						{#if t.extraLabel}
+							<span class="text-secondary ml-1">{t.extraLabel}</span>
+						{/if}
+						<span class="text-tertiary mx-1">&rarr;</span>
 						<span class="text-secondary">{t.scriptPath}</span>
 					{:else}
 						{@const diff = item.diff as WorkspaceItemDiff}
@@ -932,30 +972,38 @@ $effect(() => {
 					{#if item.trigger}
 						{@const t = item.trigger as ForkTrigger}
 						{@const key = item.key}
-						<Badge color="indigo" size="xs">Fork-only</Badge>
+						{#if t.changeKind === 'new'}
+							<Badge
+								title={mergeIntoParent
+									? `Only exists in '${currentWorkspaceId}'`
+									: `Only exists in '${parentWorkspaceId}'`}
+								color="indigo"
+								size="xs">New</Badge
+							>
+						{/if}
 						{#if t.isFlow}
 							<Badge color="blue" size="xs">flow</Badge>
 						{/if}
-						{#if t.extraLabel}
-							<span class="text-tertiary text-xs">({t.extraLabel})</span>
-						{/if}
-						{#if t.enabled != null}
-							<Badge color={t.enabled ? 'green' : 'gray'} size="xs">
-								{t.enabled ? 'Enabled' : 'Disabled'}
-							</Badge>
-						{/if}
 						{#if !deploymentStatus[key] || deploymentStatus[key].status != 'deployed'}
-							<Button
-								size="xs"
-								variant="subtle"
-								startIcon={{ icon: Eye }}
-								onclick={() => openTriggerDetails(t)}
-							>
-								Details
-							</Button>
-							<Button size="xs" variant="subtle" color="red" onclick={() => deleteTrigger(t)}>
-								<Trash2 size={12} />
-							</Button>
+							{#if mergeIntoParent}
+								<Badge color="green" size="xs">
+									<ArrowUpRight class="w-3 h-3 inline" />
+									1 ahead
+								</Badge>
+							{:else}
+								<Badge color="blue" size="xs">
+									<ArrowDownRight class="w-3 h-3 inline" />
+									1 behind
+								</Badge>
+							{/if}
+							{#if t.changeKind === 'modified'}
+								<div>
+									<Button size="xs" variant="subtle" onclick={() => openTriggerDiff(t)}>
+										<DiffIcon class="w-3 h-3" />
+										Show diff
+									</Button>
+								</div>
+							{/if}
 						{/if}
 					{:else}
 						{@const diff = item.diff as WorkspaceItemDiff}
@@ -1138,29 +1186,30 @@ $effect(() => {
 
 	<DiffDrawer bind:this={diffDrawer} {isFlow} />
 
-	<ScheduleEditor bind:this={scheduleEditor} />
-	<RouteEditor bind:this={routeEditor} />
-	<WebsocketTriggerEditor bind:this={websocketEditor} />
-	<KafkaTriggerEditor bind:this={kafkaEditor} />
-	<PostgresTriggerEditor bind:this={postgresEditor} />
-	<NatsTriggerEditor bind:this={natsEditor} />
-	<MqttTriggerEditor bind:this={mqttEditor} />
-	<SqsTriggerEditor bind:this={sqsEditor} />
-	<GcpTriggerEditor bind:this={gcpEditor} />
-	<EmailTriggerEditor bind:this={emailEditor} />
-
-	<ConfirmationModal
-		title="Delete trigger"
-		confirmationText="Delete"
-		open={!!triggerToDelete}
-		onConfirmed={confirmDeleteTrigger}
-		onCanceled={() => (triggerToDelete = undefined)}
-	>
-		{#if triggerToDelete}
-			Are you sure you want to delete the {getTriggerDisplayName(triggerToDelete.triggerKind)} trigger
-			'{triggerToDelete.path}'?
-		{/if}
-	</ConfirmationModal>
+	<Drawer bind:open={triggerDiffOpen} size="900px">
+		<DrawerContent
+			title={triggerDiffPayload
+				? `${triggerDiffPayload.kindLabel} ${triggerDiffPayload.path}`
+				: 'Trigger diff'}
+			on:close={() => (triggerDiffOpen = false)}
+		>
+			{#if triggerDiffPayload}
+				<div class="flex flex-col h-full">
+					<div class="flex-1 min-h-0">
+						<DiffEditor
+							open={triggerDiffOpen}
+							className="!h-full"
+							defaultLang="yaml"
+							defaultOriginal={triggerDiffPayload.original}
+							defaultModified={triggerDiffPayload.modified}
+							readOnly
+							inlineDiff={false}
+						/>
+					</div>
+				</div>
+			{/if}
+		</DrawerContent>
+	</Drawer>
 {:else}
 	<div class="flex items-center justify-center h-full">
 		<div class="text-gray-500">No comparison data available</div>

package/package/components/DatatableSchemaDiff.svelte

@@ -172,7 +172,7 @@ async function loadDiffs() {
     error = undefined;
     diffs = [];
     try {
-        const forkSettings = await WorkspaceService.getSettings({
+        const forkSettings = await WorkspaceService.getPublicSettings({
             workspace: currentWorkspaceId
         });
         const datatables = forkSettings.datatable?.datatables ?? {};
@@ -310,7 +310,7 @@ async function runMigration() {
         const sourceSchema = drawerDirection === 'ahead' ? drawerDiff.forkSchema : drawerDiff.parentSchema;
         const { schemaName, tableName } = drawerChange;
         const newTableDef = sourceSchema[schemaName]?.[tableName];
-        const forkSettings = await WorkspaceService.getSettings({
+        const forkSettings = await WorkspaceService.getPublicSettings({
             workspace: currentWorkspaceId
         });
         const datatableConfig = forkSettings.datatable ?? { datatables: {} };