windmill-components 1.623.2 → 1.642.0

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, '&')
@@ -1103,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));
@@ -1330,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)
@@ -1675,3 +1705,180 @@ export function pick(obj, keys) {
     }
     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;
+};

package/package/validators/workspaceSettings.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+// Deploy path filter validation
+const deployPathFilterSchema = z
+    .string()
+    .min(1, 'Path filter cannot be empty')
+    .refine((val) => {
+    // Allow alphanumeric characters, underscores, slashes, asterisks, and hyphens
+    // But don't allow consecutive slashes or ending with slash
+    const validChars = /^[a-zA-Z0-9/_*-]+$/;
+    const noConsecutiveSlashes = !/\/\//.test(val);
+    const noEndingSlash = !val.endsWith('/');
+    const noEndingDash = !val.endsWith('-');
+    return validChars.test(val) && noConsecutiveSlashes && noEndingSlash && noEndingDash;
+}, {
+    message: 'Path filter contains invalid characters or format. Allowed: letters, numbers, /, _, -, *. Cannot end with / or -'
+})
+    .refine((val) => {
+    // Validate glob patterns - * and ** are allowed, but *** is not
+    const invalidGlobPattern = /\*{3,}/.test(val);
+    return !invalidGlobPattern;
+}, {
+    message: 'Invalid glob pattern. Use * for single level wildcard or ** for multi-level wildcard'
+});
+// Webhook URL validation
+const webhookUrlSchema = z
+    .string()
+    .refine((val) => {
+    if (!val || val.trim() === '')
+        return true; // Allow empty
+    try {
+        new URL(val);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, {
+    message: 'Please enter a valid URL (e.g., https://example.com/webhook)'
+})
+    .optional()
+    .or(z.literal(''));
+// Workspace encryption key validation
+const encryptionKeySchema = z.string().regex(/^[a-zA-Z0-9]{64}$/, {
+    message: 'Encryption key must be exactly 64 characters long and contain only letters and numbers'
+});
+export function validateDeployPathFilters(paths) {
+    const errors = {};
+    paths.forEach((path, index) => {
+        const result = deployPathFilterSchema.safeParse(path);
+        if (!result.success) {
+            errors[index] = result.error.issues[0]?.message || 'Invalid path filter';
+        }
+    });
+    return {
+        isValid: Object.keys(errors).length === 0,
+        errors
+    };
+}
+export function validateWebhookUrl(url) {
+    const result = webhookUrlSchema.safeParse(url);
+    return {
+        isValid: result.success,
+        error: result.success ? undefined : result.error.issues[0]?.message || 'Invalid URL'
+    };
+}
+export function validateEncryptionKey(key) {
+    const result = encryptionKeySchema.safeParse(key);
+    return {
+        isValid: result.success,
+        error: result.success ? undefined : result.error.issues[0]?.message || 'Invalid encryption key'
+    };
+}

package/package/workspaceProtectionRules.svelte.d.ts

@@ -0,0 +1,73 @@
+import { type ProtectionRuleset, type ProtectionRuleKind } from './gen';
+import type { UserExt } from './stores';
+/**
+ * Exported reactive state object with readonly getters
+ */
+export declare const protectionRulesState: {
+    readonly rulesets: ProtectionRuleset[] | undefined;
+    readonly loading: boolean;
+    readonly error: string | undefined;
+    readonly workspace: string | undefined;
+};
+/**
+ * Internal function to reset state (used by storeUtils)
+ */
+export declare function resetProtectionRules(): void;
+/**
+ * Loads protection rules for a workspace from the API and updates the state
+ * Early returns if already loading the same workspace to prevent duplicate requests
+ */
+export declare function loadProtectionRules(workspace: string): Promise<void>;
+/**
+ * Fetches protection rules for a specific workspace without updating the state
+ * @param workspace The workspace ID to fetch rules for
+ * @returns Array of protection rulesets, or empty array on error
+ */
+export declare function fetchProtectionRulesForWorkspace(workspace: string): Promise<ProtectionRuleset[]>;
+/**
+ * Checks if a user can bypass a specific ruleset
+ * @param ruleset The protection ruleset to check
+ * @param userInfo The user information
+ * @returns true if user can bypass (is admin, in bypass_users, or has group in bypass_groups)
+ */
+export declare function canUserBypassRule(ruleset: ProtectionRuleset, userInfo: UserExt): boolean;
+/**
+ * Checks if a specific rule type is active in ANY ruleset
+ * FIXED: No longer uses await without async context
+ * @param ruleKind The rule type to check
+ * @returns true if the rule is active in at least one ruleset, false if not loaded or not active
+ */
+export declare function isRuleActive(ruleKind: ProtectionRuleKind): boolean;
+/**
+ * Checks if a user can bypass a specific rule type
+ * @param ruleKind The rule type to check
+ * @param userInfo The user information
+ * @returns true if the rule is not active OR user can bypass ALL rulesets containing it
+ */
+export declare function canUserBypassRuleKind(ruleKind: ProtectionRuleKind, userInfo: UserExt | undefined): boolean;
+/**
+ * Returns all rulesets that contain a specific rule kind
+ */
+export declare function getActiveRulesetsForKind(ruleKind: ProtectionRuleKind): ProtectionRuleset[];
+/**
+ * Checks if a specific rule kind is active in given rulesets (workspace-agnostic version)
+ * @param rulesets Array of protection rulesets to check
+ * @param ruleKind The rule type to check
+ * @returns true if the rule is active in at least one ruleset
+ */
+export declare function isRuleActiveInRulesets(rulesets: ProtectionRuleset[], ruleKind: ProtectionRuleKind): boolean;
+/**
+ * Checks if user can bypass a rule kind in given rulesets (workspace-agnostic version)
+ * @param rulesets Array of protection rulesets to check
+ * @param ruleKind The rule type to check
+ * @param userInfo The user information
+ * @returns true if the rule is not active OR user can bypass ALL rulesets containing it
+ */
+export declare function canUserBypassRuleKindInRulesets(rulesets: ProtectionRuleset[], ruleKind: ProtectionRuleKind, userInfo: UserExt | undefined): boolean;
+/**
+ * Returns rulesets that contain a specific rule kind from given rulesets (workspace-agnostic version)
+ * @param rulesets Array of protection rulesets to filter
+ * @param ruleKind The rule type to filter by
+ * @returns Array of rulesets containing the specified rule
+ */
+export declare function getActiveRulesetsForKindInRulesets(rulesets: ProtectionRuleset[], ruleKind: ProtectionRuleKind): ProtectionRuleset[];