windmill-components 1.623.1 → 1.642.0

package/package/tutorials/config.js

@@ -1,4 +1,4 @@
-import { Workflow, GraduationCap, Wrench, PlayCircle, Link2 } from 'lucide-svelte';
+import { Workflow, GraduationCap, Wrench, PlayCircle, Link2, History } from 'lucide-svelte';
 import { base } from '../base';
 /**
  * Get tutorial index from config by tutorial ID.
@@ -16,7 +16,7 @@ export function getTutorialIndex(id) {
 export const TUTORIALS_CONFIG = {
     quickstart: {
         label: 'Quickstart',
-        roles: ['admin', 'developer'],
+        roles: ['admin', 'developer', 'operator'],
         progressBar: true,
         active: true,
         tutorials: [
@@ -61,7 +61,35 @@ export const TUTORIALS_CONFIG = {
                 comingSoon: false,
                 roles: ['admin', 'developer'],
                 order: 3
-            }
+            },
+            {
+                id: 'runs-tutorial',
+                icon: History,
+                title: 'Discover your monitoring dashboard',
+                description: 'Learn how to monitor, filter, and manage your script and flow executions.',
+                onClick: () => {
+                    window.location.href = `${base}/runs?tutorial=runs-tutorial`;
+                },
+                index: 7,
+                active: true,
+                comingSoon: false,
+                roles: ['admin', 'developer', 'operator'],
+                order: 4
+            },
+            {
+                id: 'workspace-onboarding-operator',
+                icon: GraduationCap,
+                title: 'Workspace onboarding',
+                description: 'Discover the basics of Windmill with a quick tour of the workspace.',
+                onClick: () => {
+                    window.location.href = `${base}/?tutorial=workspace-onboarding-operator`;
+                },
+                index: 6,
+                active: true,
+                comingSoon: false,
+                roles: ['operator'],
+                order: 1
+            },
         ]
     },
     app_editor: {

package/package/tutorials/roleUtils.d.ts

@@ -15,6 +15,6 @@ export declare function hasRoleAccess(user: UserExt | null | undefined, roles?:
 /**
  * Check if a preview role has access based on a roles array.
  * Used by admins to preview what other roles can see.
- * This is a convenience wrapper around hasRoleAccess for preview mode.
+ * Uses exact role matching - only shows tutorials explicitly marked for the preview role.
  */
 export declare function hasRoleAccessForPreview(previewRole: Role, roles?: Role[]): boolean;

package/package/tutorials/roleUtils.js

@@ -45,8 +45,12 @@ export function hasRoleAccess(user, roles, previewRole) {
 /**
  * Check if a preview role has access based on a roles array.
  * Used by admins to preview what other roles can see.
- * This is a convenience wrapper around hasRoleAccess for preview mode.
+ * Uses exact role matching - only shows tutorials explicitly marked for the preview role.
  */
 export function hasRoleAccessForPreview(previewRole, roles) {
-    return hasRoleAccess(null, roles, previewRole);
+    // No roles specified = available to everyone
+    if (!roles || roles.length === 0)
+        return true;
+    // Exact role match - tutorial must explicitly include the preview role
+    return roles.includes(previewRole);
 }

package/package/utils.js

@@ -75,13 +75,6 @@ export function isJobReRunnable(j) {
     return (j.job_kind === 'script' || j.job_kind === 'flow') && j.parent_job === undefined;
 }
 export const WORKER_NAME_PREFIX = 'wk';
-export function isJobSelectable(selectionType) {
-    const f = {
-        cancel: isJobCancelable,
-        're-run': isJobReRunnable
-    }[selectionType];
-    return f;
-}
 export function escapeHtml(unsafe) {
     return unsafe
         .replace(/&/g, '&')
@@ -678,7 +671,7 @@ export function pluralize(quantity, word, customPlural) {
         return `${quantity} ${word}`;
     }
     else if (customPlural) {
-        return `${quantity} ${customPlural}}`;
+        return `${quantity} ${customPlural}`;
     }
     else {
         return `${quantity} ${word}s`;
@@ -730,6 +723,134 @@ export function getModifierKey() {
 export function isValidHexColor(color) {
     return /^#(([A-F0-9]{2}){3,4}|[A-F0-9]{3})$/i.test(color);
 }
+/**
+ * Calculates the relative luminance of a color according to WCAG 2.1
+ * @param r Red component (0-255)
+ * @param g Green component (0-255)
+ * @param b Blue component (0-255)
+ * @returns Relative luminance value (0-1)
+ */
+function getRelativeLuminance(r, g, b) {
+    const [rs, gs, bs] = [r, g, b].map((val) => {
+        val = val / 255;
+        return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
+    });
+    return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+}
+/**
+ * Converts hex color to HSL
+ * @param hex Hex color string (e.g., "#FF0000")
+ * @returns Array of [hue (0-360), saturation (0-100), lightness (0-100)]
+ */
+function hexToHsl(hex) {
+    // Normalize hex color
+    let normalizedHex = hex.replace('#', '');
+    if (normalizedHex.length === 3) {
+        normalizedHex = normalizedHex
+            .split('')
+            .map((char) => char + char)
+            .join('');
+    }
+    const r = parseInt(normalizedHex.substring(0, 2), 16) / 255;
+    const g = parseInt(normalizedHex.substring(2, 4), 16) / 255;
+    const b = parseInt(normalizedHex.substring(4, 6), 16) / 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    let h = 0;
+    let s = 0;
+    const l = (max + min) / 2;
+    if (max !== min) {
+        const d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r:
+                h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+                break;
+            case g:
+                h = ((b - r) / d + 2) / 6;
+                break;
+            case b:
+                h = ((r - g) / d + 4) / 6;
+                break;
+        }
+    }
+    return [h * 360, s * 100, l * 100];
+}
+/**
+ * Converts HSL to hex color
+ * @param h Hue (0-360)
+ * @param s Saturation (0-100)
+ * @param l Lightness (0-100)
+ * @returns Hex color string
+ */
+function hslToHex(h, s, l) {
+    h = h / 360;
+    s = s / 100;
+    l = l / 100;
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l; // Achromatic
+    }
+    else {
+        const hue2rgb = (p, q, t) => {
+            if (t < 0)
+                t += 1;
+            if (t > 1)
+                t -= 1;
+            if (t < 1 / 6)
+                return p + (q - p) * 6 * t;
+            if (t < 1 / 2)
+                return q;
+            if (t < 2 / 3)
+                return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+    }
+    const toHex = (c) => {
+        const hex = Math.round(c * 255).toString(16);
+        return hex.length === 1 ? '0' + hex : hex;
+    };
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+/**
+ * Generates a text color with the same hue as the background but adjusted lightness for good contrast
+ * @param backgroundColor Hex color string (e.g., "#FF0000" or "#F00")
+ * @returns Hex color string with same hue but good contrast, or undefined if invalid
+ */
+export function getContrastTextColor(backgroundColor) {
+    if (!backgroundColor || !isValidHexColor(backgroundColor)) {
+        return undefined;
+    }
+    // Normalize hex color
+    let hex = backgroundColor.replace('#', '');
+    if (hex.length === 3) {
+        hex = hex
+            .split('')
+            .map((char) => char + char)
+            .join('');
+    }
+    // Parse RGB components and calculate background luminance
+    const r = parseInt(hex.substring(0, 2), 16);
+    const g = parseInt(hex.substring(2, 4), 16);
+    const b = parseInt(hex.substring(4, 6), 16);
+    const bgLuminance = getRelativeLuminance(r, g, b);
+    // Convert to HSL to extract hue
+    const [hue] = hexToHsl(backgroundColor);
+    // Determine if background is light or dark
+    const isLightBackground = bgLuminance > 0.5;
+    // Use fixed saturation and lightness based on background lightness
+    // For light backgrounds: use dark text (low lightness, high saturation)
+    // For dark backgrounds: use light text (high lightness, high saturation)
+    const saturation = 70; // Fixed saturation for good readability
+    const lightness = isLightBackground ? 25 : 85; // Dark for light bg, light for dark bg
+    // Generate the color with the same hue but adjusted saturation and lightness
+    return hslToHex(hue, saturation, lightness);
+}
 export function sortObject(o) {
     return Object.keys(o)
         .sort()
@@ -975,6 +1096,12 @@ export function cleanValueProperties(obj) {
         return newObj;
     }
 }
+export function hasUnsavedChanges(saved, modified) {
+    const normalizedSaved = cleanValueProperties({ ...saved, path: undefined });
+    const normalizedModified = cleanValueProperties({ ...modified, path: undefined });
+    return (orderedJsonStringify(replaceFalseWithUndefined(normalizedSaved)) !==
+        orderedJsonStringify(replaceFalseWithUndefined(normalizedModified)));
+}
 export function orderedJsonStringify(obj, space) {
     const allKeys = new Set();
     JSON.stringify(obj, (key, value) => (value != undefined && value != null && allKeys.add(key), value));
@@ -1202,6 +1329,37 @@ export function formatDateShort(dateString) {
         day: 'numeric'
     }).format(date);
 }
+export function formatDateRange(start, end) {
+    if (typeof start === 'string')
+        start = new Date(start);
+    if (typeof end === 'string')
+        end = new Date(end);
+    if (start && end) {
+        const differentDays = start.getFullYear() !== end.getFullYear() ||
+            start.getMonth() !== end.getMonth() ||
+            start.getDate() !== end.getDate();
+        const differentYears = start.getFullYear() !== end.getFullYear();
+        if (differentDays || differentYears) {
+            // Clone to avoid mutating originals
+            start = new Date(start);
+            end = new Date(end);
+            // Zero out time for display
+            start.setHours(0, 0, 0, 0);
+            end.setHours(0, 0, 0, 0);
+        }
+        if (differentYears) {
+            // Zero out month and day for display
+            start.setMonth(0, 1);
+            end.setMonth(0, 1);
+        }
+        return `${formatDatePretty(start)} to ${formatDatePretty(end)}`;
+    }
+    if (!end && start)
+        return `After ${formatDatePretty(start)}`;
+    if (!start && end)
+        return `Before ${formatDatePretty(end)}`;
+    return 'No input';
+}
 export function toJsonStr(result) {
     try {
         // console.log(result)
@@ -1514,3 +1672,213 @@ export function getQueryStmtCountHeuristic(query) {
     }
     return count;
 }
+export function countChars(str, char) {
+    let count = 0;
+    for (let i = 0; i < str.length; i++) {
+        if (str[i] === char) {
+            count++;
+        }
+    }
+    return count;
+}
+export function onlyAlphaNumAndUnderscore(str) {
+    return str.replace(/[^a-zA-Z0-9_]/g, '');
+}
+export function buildReactiveObj(fields) {
+    const obj = {};
+    for (const key in fields) {
+        Object.defineProperty(obj, key, {
+            get: fields[key][0],
+            set: fields[key][1],
+            enumerable: true,
+            configurable: true
+        });
+    }
+    return obj;
+}
+export function pick(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+export function parseDbInputFromAssetSyntax(path) {
+    const [p1, _p2] = path.split('://');
+    const [p2, _p3] = _p2.split('/');
+    const [p3, p4] = _p3.split('.');
+    return p1 === 'ducklake'
+        ? { type: 'ducklake', ducklake: p2 || 'main', specificTable: p4 ?? p3 }
+        : p1 === 'datatable'
+            ? {
+                type: 'database',
+                resourcePath: `datatable://${p2 || 'main'}`,
+                resourceType: 'postgresql',
+                specificTable: p4 ?? p3,
+                specificSchema: p4 ? p3 : undefined
+            }
+            : null;
+}
+export function formatMemory(sizeInKb, includeTooltip = false) {
+    const precise = `${sizeInKb.toLocaleString()}KB`;
+    let display;
+    if (sizeInKb >= 1024 * 1024) {
+        // Convert to GB for values >= 1GB
+        display = `${(sizeInKb / (1024 * 1024)).toFixed(0)}GB`;
+    }
+    else if (sizeInKb >= 1024) {
+        // Convert to MB for values >= 1MB
+        display = `${(sizeInKb / 1024).toFixed(0)}MB`;
+    }
+    else {
+        // Keep as KB for smaller values
+        display = `${sizeInKb.toFixed(0)}KB`;
+    }
+    if (includeTooltip) {
+        return {
+            display,
+            tooltip: `${precise} (${(sizeInKb / 1024).toFixed(2)}MB)`
+        };
+    }
+    return display;
+}
+export function assignObjInPlace(target, source, options = { onDelete: 'Delete' }) {
+    for (const key in target) {
+        if (!(key in source)) {
+            if (options?.onDelete === 'Delete')
+                delete target[key];
+            else if (options?.onDelete === 'SetNull')
+                target[key] = null;
+        }
+    }
+    for (const key in source)
+        target[key] = source[key];
+}
+export function isUSLocale() {
+    try {
+        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+        return locale.startsWith('en-US');
+    }
+    catch {
+        return false;
+    }
+}
+export function formatDatePretty(date) {
+    if (!date || isNaN(date.getTime()))
+        return '';
+    const now = new Date();
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const isCurrentYear = year === now.getFullYear();
+    const isToday = isCurrentYear && month === now.getMonth() + 1 && day === now.getDate();
+    const isOnlyYear = month === 1 && day === 1 && hours === 0 && minutes === 0;
+    const hasTime = hours !== 0 || minutes !== 0;
+    // If only year is defined (rest is 01/01 00:00)
+    if (isOnlyYear) {
+        return String(year);
+    }
+    // Format month/day depending on locale: MM/DD for US, DD/MM otherwise
+    const mm = String(month).padStart(2, '0');
+    const dd = String(day).padStart(2, '0');
+    const monthDay = isUSLocale() ? `${mm}/${dd}` : `${dd}/${mm}`;
+    // Format time if present (12-hour format with AM/PM)
+    let timeStr = '';
+    if (hasTime) {
+        const isPM = hours >= 12;
+        const displayHours = hours % 12 || 12;
+        const displayMinutes = String(minutes).padStart(2, '0');
+        timeStr = ` ${displayHours}:${displayMinutes} ${isPM ? 'PM' : 'AM'}`;
+    }
+    // If today and same year, only show time (if present)
+    if (isToday) {
+        return timeStr ? timeStr.trim() : monthDay;
+    }
+    // If same year, show month/day and time (if present)
+    if (isCurrentYear) {
+        return `${monthDay}${timeStr}`;
+    }
+    // Otherwise, show full date with year and time (if present)
+    return `${monthDay}/${year}${timeStr}`;
+}
+export function parsePrettyDate(text) {
+    if (!text)
+        return null;
+    const now = new Date();
+    const currentYear = now.getFullYear();
+    // Try parsing as year-only (e.g., "2025")
+    if (/^\d{4}$/.test(text)) {
+        const year = parseInt(text);
+        return new Date(year, 0, 1, 0, 0, 0);
+    }
+    // Try parsing time-only (e.g., "11:02 AM") - assumes today
+    const timeOnlyMatch = text.match(/^(\d{1,2}):(\d{2})\s+(AM|PM)$/i);
+    if (timeOnlyMatch) {
+        const [, hourStr, minuteStr, meridiem] = timeOnlyMatch;
+        let hours = parseInt(hourStr);
+        const minutes = parseInt(minuteStr);
+        if (meridiem.toUpperCase() === 'PM' && hours !== 12)
+            hours += 12;
+        if (meridiem.toUpperCase() === 'AM' && hours === 12)
+            hours = 0;
+        return new Date(currentYear, now.getMonth(), now.getDate(), hours, minutes, 0);
+    }
+    const usLocale = isUSLocale();
+    // Parse a "first/second" pair as month/day (US) or day/month (non-US)
+    function parseFirstSecond(firstStr, secondStr) {
+        const first = parseInt(firstStr);
+        const second = parseInt(secondStr);
+        return usLocale ? { month: first - 1, day: second } : { month: second - 1, day: first };
+    }
+    // Try parsing NN/NN (e.g., "01/04") - assumes current year, no time
+    // US: MM/DD, non-US: DD/MM
+    const monthDayMatch = text.match(/^(\d{2})\/(\d{2})$/);
+    if (monthDayMatch) {
+        const { month, day } = parseFirstSecond(monthDayMatch[1], monthDayMatch[2]);
+        return new Date(currentYear, month, day, 0, 0, 0);
+    }
+    // Try parsing NN/NN TIME (e.g., "01/04 11:02 AM") - assumes current year with time
+    // US: MM/DD TIME, non-US: DD/MM TIME
+    const monthDayTimeMatch = text.match(/^(\d{2})\/(\d{2})\s+(\d{1,2}):(\d{2})\s+(AM|PM)$/i);
+    if (monthDayTimeMatch) {
+        const { month, day } = parseFirstSecond(monthDayTimeMatch[1], monthDayTimeMatch[2]);
+        let hours = parseInt(monthDayTimeMatch[3]);
+        const minutes = parseInt(monthDayTimeMatch[4]);
+        const meridiem = monthDayTimeMatch[5];
+        if (meridiem.toUpperCase() === 'PM' && hours !== 12)
+            hours += 12;
+        if (meridiem.toUpperCase() === 'AM' && hours === 12)
+            hours = 0;
+        return new Date(currentYear, month, day, hours, minutes, 0);
+    }
+    // Try parsing NN/NN/YYYY (e.g., "01/04/2025") - no time
+    // US: MM/DD/YYYY, non-US: DD/MM/YYYY
+    const fullDateMatch = text.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+    if (fullDateMatch) {
+        const { month, day } = parseFirstSecond(fullDateMatch[1], fullDateMatch[2]);
+        const year = parseInt(fullDateMatch[3]);
+        return new Date(year, month, day, 0, 0, 0);
+    }
+    // Try parsing NN/NN/YYYY TIME (e.g., "01/04/2025 3:00 PM")
+    // US: MM/DD/YYYY TIME, non-US: DD/MM/YYYY TIME
+    const fullDateTimeMatch = text.match(/^(\d{2})\/(\d{2})\/(\d{4})\s+(\d{1,2}):(\d{2})\s+(AM|PM)$/i);
+    if (fullDateTimeMatch) {
+        const { month, day } = parseFirstSecond(fullDateTimeMatch[1], fullDateTimeMatch[2]);
+        const year = parseInt(fullDateTimeMatch[3]);
+        let hours = parseInt(fullDateTimeMatch[4]);
+        const minutes = parseInt(fullDateTimeMatch[5]);
+        const meridiem = fullDateTimeMatch[6];
+        if (meridiem.toUpperCase() === 'PM' && hours !== 12)
+            hours += 12;
+        if (meridiem.toUpperCase() === 'AM' && hours === 12)
+            hours = 0;
+        return new Date(year, month, day, hours, minutes, 0);
+    }
+    // Fallback to standard Date parsing (e.g., ISO strings)
+    const date = new Date(text);
+    return isNaN(date.getTime()) ? null : date;
+}

package/package/utils_deployable.d.ts

@@ -56,7 +56,7 @@ export declare function getTriggerValue(kind: TriggerKind, path: string, workspa
     is_flow: boolean;
     queue_url: string;
     aws_resource_path: string;
-    message_attributes: string[] | undefined;
+    message_attributes: string[] | null | undefined;
     kafka_resource_path?: undefined;
     topics?: undefined;
     group_id?: undefined;
@@ -165,11 +165,11 @@ export declare function getTriggerValue(kind: TriggerKind, path: string, workspa
     script_path: string;
     is_flow: boolean;
     mqtt_resource_path: string;
-    v3_config: import("./gen").MqttV3Config | undefined;
-    v5_config: import("./gen").MqttV5Config | undefined;
-    client_id: string | undefined;
+    v3_config: import("./gen").MqttV3Config | null | undefined;
+    v5_config: import("./gen").MqttV5Config | null | undefined;
+    client_id: string | null | undefined;
     subscribe_topics: import("./gen").MqttSubscribeTopic[];
-    client_version: import("./gen").MqttClientVersion | undefined;
+    client_version: import("./gen").MqttClientVersion | null | undefined;
     queue_url?: undefined;
     aws_resource_path?: undefined;
     message_attributes?: undefined;
@@ -221,8 +221,8 @@ export declare function getTriggerValue(kind: TriggerKind, path: string, workspa
     is_flow: boolean;
     nats_resource_path: string;
     use_jetstream: boolean;
-    stream_name: string | undefined;
-    consumer_name: string | undefined;
+    stream_name: string | null | undefined;
+    consumer_name: string | null | undefined;
     subjects: string[];
     queue_url?: undefined;
     aws_resource_path?: undefined;
@@ -385,13 +385,13 @@ export declare function getTriggerValue(kind: TriggerKind, path: string, workspa
     script_path: string;
     is_flow: boolean;
     url: string;
-    url_runnable_args: import("./gen").ScriptArgs | undefined;
+    url_runnable_args: import("./gen").ScriptArgs | null | undefined;
     can_return_message: boolean;
     filters: {
         key: string;
         value: unknown;
     }[];
-    initial_messages: import("./gen").WebsocketTriggerInitialMessage[] | undefined;
+    initial_messages: import("./gen").WebsocketTriggerInitialMessage[] | null | undefined;
     queue_url?: undefined;
     aws_resource_path?: undefined;
     message_attributes?: undefined;
@@ -447,11 +447,11 @@ export declare function getTriggerValue(kind: TriggerKind, path: string, workspa
         s3: string;
         storage?: string;
         filename?: string;
-    } | undefined;
+    } | null | undefined;
     request_type: import("./gen").HttpRequestType;
     authentication_method: import("./gen").AuthenticationMethod;
     is_static_website: boolean;
-    authentication_resource_path: string | undefined;
+    authentication_resource_path: string | null | undefined;
     mode?: undefined;
     queue_url?: undefined;
     aws_resource_path?: undefined;
@@ -500,24 +500,24 @@ export declare function getTriggerValue(kind: TriggerKind, path: string, workspa
 } | {
     script_path: string;
     is_flow: boolean;
-    on_failure: string | undefined;
+    on_failure: string | null | undefined;
     schedule: string;
     timezone: string;
-    on_failure_times: number | undefined;
-    on_failure_exact: boolean | undefined;
-    on_failure_extra_args: import("./gen").ScriptArgs | undefined;
-    on_recovery: string | undefined;
-    on_recovery_times: number | undefined;
-    on_recovery_extra_args: import("./gen").ScriptArgs | undefined;
-    on_success: string | undefined;
-    on_success_extra_args: import("./gen").ScriptArgs | undefined;
+    on_failure_times: number | null | undefined;
+    on_failure_exact: boolean | null | undefined;
+    on_failure_extra_args: import("./gen").ScriptArgs | null | undefined;
+    on_recovery: string | null | undefined;
+    on_recovery_times: number | null | undefined;
+    on_recovery_extra_args: import("./gen").ScriptArgs | null | undefined;
+    on_success: string | null | undefined;
+    on_success_extra_args: import("./gen").ScriptArgs | null | undefined;
     ws_error_handler_muted: boolean | undefined;
-    retry: import("./gen").Retry | undefined;
-    summary: string | undefined;
+    retry: import("./gen").Retry | null | undefined;
+    summary: string | null | undefined;
     no_flow_overlap: boolean | undefined;
-    tag: string | undefined;
-    paused_until: string | undefined;
-    cron_version: string | undefined;
+    tag: string | null | undefined;
+    paused_until: string | null | undefined;
+    cron_version: string | null | undefined;
     mode?: undefined;
     queue_url?: undefined;
     aws_resource_path?: undefined;

package/package/utils_deployable.js

@@ -106,6 +106,7 @@ export async function getTriggersDeployData(kind, path, workspace) {
         }
         const data = {
             ...gcpTrigger,
+            delivery_config: gcpTrigger.delivery_config ?? undefined,
             base_endpoint: gcpTrigger.delivery_type === 'push' ? `${window.location.origin}${base}` : undefined
         };
         return {
@@ -395,7 +396,7 @@ export async function getTriggerDependency(kind, path, workspace) {
         result = retrieveKindsValues({
             script_path,
             is_flow,
-            resource_path: authentication_resource_path
+            resource_path: authentication_resource_path ?? undefined
         });
     }
     else if (kind === 'schedules') {

package/package/validators/workspaceSettings.d.ts

@@ -0,0 +1,12 @@
+export declare function validateDeployPathFilters(paths: string[]): {
+    isValid: boolean;
+    errors: Record<number, string>;
+};
+export declare function validateWebhookUrl(url: string): {
+    isValid: boolean;
+    error?: string;
+};
+export declare function validateEncryptionKey(key: string): {
+    isValid: boolean;
+    error?: string;
+};