windmill-components 1.623.1 → 1.642.0

package/package/components/triggers/native/services/nextcloud/NextcloudTriggerForm.svelte.d.ts

@@ -0,0 +1,18 @@
+interface Props {
+    serviceConfig: Record<string, any>;
+    errors: Record<string, string>;
+    disabled?: boolean;
+    externalData?: any;
+    path?: string;
+    isFlow?: boolean;
+    hash?: string;
+    token?: string;
+    triggerTokens?: any;
+    scopes?: string[];
+    loading: boolean;
+}
+declare const NextcloudTriggerForm: import("svelte").Component<Props, {
+    validate: () => Record<string, string>;
+}, "token" | "loading" | "errors" | "triggerTokens" | "serviceConfig">;
+type NextcloudTriggerForm = ReturnType<typeof NextcloudTriggerForm>;
+export default NextcloudTriggerForm;

package/package/components/triggers/native/utils.d.ts

@@ -0,0 +1,73 @@
+import type { NativeServiceName, NativeTrigger } from '../../../gen/types.gen';
+import { type Writable } from 'svelte/store';
+export interface NativeTriggerConfig {
+    readonly serviceDisplayName: string;
+    readonly serviceKey: NativeServiceName;
+    readonly supportsSync: boolean;
+    readonly isCloudCompatible: boolean;
+    readonly templates?: {
+        script?: string;
+        flow?: string;
+    };
+}
+export declare const NATIVE_TRIGGER_SERVICES: Record<NativeServiceName, NativeTriggerConfig>;
+export declare function isServiceAvailable(service: NativeServiceName, workspace: string): Promise<boolean>;
+export declare function getAvailableServices(): NativeServiceName[];
+export declare function getAvailableNativeTriggerServices(workspace: string): Promise<NativeServiceName[]>;
+export declare function getServiceConfig(service: NativeServiceName): NativeTriggerConfig | undefined;
+export type ExtendedNativeTrigger = NativeTrigger & {
+    marked?: string;
+};
+export interface ServiceFormProps {
+    config: Record<string, any>;
+    errors: Record<string, string>;
+    resources: Array<{
+        path: string;
+        description?: string;
+    }>;
+    onConfigChange: (newConfig: Record<string, any>) => void;
+    onTest?: () => Promise<void>;
+    disabled?: boolean;
+}
+export declare function validateCommonFields(config: Record<string, any>): Record<string, string>;
+export declare function formatTriggerDisplayName(trigger: NativeTrigger): string;
+export declare function getTriggerIconName(service: NativeServiceName): string;
+export declare function getServiceIcon(service: NativeServiceName): Promise<any>;
+export declare function getServiceTemplates(service: NativeServiceName): {
+    script?: string;
+    flow?: string;
+} | undefined;
+export declare function getTemplatePath(service: NativeServiceName, type: 'script' | 'flow'): string | undefined;
+export interface NextcloudEvent {
+    path: string;
+    description?: string;
+}
+export declare function getNextcloudSchema(availableEvents: NextcloudEvent[]): {
+    type: string;
+    properties: {
+        event: {
+            type: string;
+            title: string;
+            description: string;
+            enum: string[];
+            enumLabels: Record<string, string>;
+        };
+        eventFilter: {
+            type: string;
+            title: string;
+            description: string;
+        };
+        userIdFilter: {
+            type: string;
+            title: string;
+            description: string;
+        };
+        headers: {
+            type: string;
+            title: string;
+            description: string;
+        };
+    };
+    required: string[];
+};
+export declare function saveNativeTriggerFromCfg(service: NativeServiceName, initialExternalId: string, triggerCfg: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<string | null>;

package/package/components/triggers/native/utils.js

@@ -0,0 +1,166 @@
+import { isCloudHosted } from '../../../cloud';
+import { NativeTriggerService, WorkspaceIntegrationService } from '../../../gen';
+import { get } from 'svelte/store';
+import { sendUserToast } from '../../../toast';
+export const NATIVE_TRIGGER_SERVICES = {
+    nextcloud: {
+        serviceDisplayName: 'Nextcloud',
+        serviceKey: 'nextcloud',
+        supportsSync: true,
+        isCloudCompatible: true,
+        templates: {
+            script: '/scripts/add?hub=hub%2F28115',
+            flow: '/flows/add?hub=73'
+        }
+    },
+    // Google handles both Drive and Calendar triggers via trigger_type in service_config
+    google: {
+        serviceDisplayName: 'Google',
+        serviceKey: 'google',
+        supportsSync: true,
+        isCloudCompatible: true,
+        templates: {
+            script: '/scripts/add?hub=hub%2F28135',
+            flow: '/flows/add?hub=75'
+        }
+    }
+};
+export async function isServiceAvailable(service, workspace) {
+    const config = NATIVE_TRIGGER_SERVICES[service];
+    if (!config)
+        return false;
+    if (isCloudHosted() && !config.isCloudCompatible) {
+        return false;
+    }
+    try {
+        const response = await WorkspaceIntegrationService.checkIfNativeTriggersServiceExists({
+            workspace,
+            serviceName: service
+        });
+        return response;
+    }
+    catch (workspaceErr) {
+        console.debug(`Workspace integration check failed for ${service}:`, workspaceErr);
+        return false;
+    }
+}
+export function getAvailableServices() {
+    return Object.keys(NATIVE_TRIGGER_SERVICES);
+}
+export async function getAvailableNativeTriggerServices(workspace) {
+    const services = getAvailableServices();
+    const availableServices = [];
+    for (const service of services) {
+        const available = await isServiceAvailable(service, workspace);
+        if (available) {
+            availableServices.push(service);
+        }
+    }
+    return availableServices;
+}
+export function getServiceConfig(service) {
+    return NATIVE_TRIGGER_SERVICES[service];
+}
+export function validateCommonFields(config) {
+    const errors = {};
+    if (!config.script_path?.trim()) {
+        errors.script_path = 'Script/Flow path is required';
+    }
+    return errors;
+}
+export function formatTriggerDisplayName(trigger) {
+    return `${trigger.script_path} (external id: ${trigger.external_id})`;
+}
+export function getTriggerIconName(service) {
+    switch (service) {
+        case 'nextcloud':
+            return 'NextcloudIcon';
+        case 'google':
+            return 'GoogleIcon';
+        default:
+            return 'NextcloudIcon';
+    }
+}
+export async function getServiceIcon(service) {
+    switch (service) {
+        case 'nextcloud':
+            return (await import('../../icons/NextcloudIcon.svelte')).default;
+        case 'google':
+            return (await import('../../icons/GoogleIcon.svelte')).default;
+    }
+}
+export function getServiceTemplates(service) {
+    const config = getServiceConfig(service);
+    return config?.templates;
+}
+export function getTemplatePath(service, type) {
+    const templates = getServiceTemplates(service);
+    return templates?.[type];
+}
+export function getNextcloudSchema(availableEvents) {
+    return {
+        type: 'object',
+        properties: {
+            event: {
+                type: 'string',
+                title: 'Event',
+                description: 'The type of Nextcloud event to listen for',
+                enum: availableEvents.map((e) => e.path),
+                enumLabels: availableEvents.reduce((acc, cur) => ({ ...acc, [cur.path]: cur.description ?? cur.path }), {})
+            },
+            eventFilter: {
+                type: 'object',
+                title: 'Event filter',
+                description: 'Optional filter criteria for the event (JSON object)'
+            },
+            userIdFilter: {
+                type: 'string',
+                title: 'User ID filter',
+                description: 'Filter events by specific user ID'
+            },
+            headers: {
+                type: 'object',
+                title: 'Headers',
+                description: 'Optional HTTP headers to include (JSON object)'
+            }
+        },
+        required: ['event']
+    };
+}
+export async function saveNativeTriggerFromCfg(service, initialExternalId, triggerCfg, edit, workspace, usedTriggerKinds) {
+    const requestBody = {
+        script_path: triggerCfg.script_path,
+        is_flow: triggerCfg.is_flow,
+        service_config: triggerCfg.service_config
+    };
+    const serviceName = NATIVE_TRIGGER_SERVICES[service].serviceDisplayName;
+    try {
+        let externalId = initialExternalId;
+        if (edit) {
+            await NativeTriggerService.updateNativeTrigger({
+                workspace: workspace,
+                serviceName: service,
+                externalId: initialExternalId,
+                requestBody
+            });
+            sendUserToast(`${serviceName} trigger ${externalId} updated`);
+        }
+        else {
+            const response = await NativeTriggerService.createNativeTrigger({
+                workspace: workspace,
+                serviceName: service,
+                requestBody
+            });
+            externalId = response.external_id;
+            sendUserToast(`${serviceName} trigger ${externalId} created`);
+        }
+        if (!get(usedTriggerKinds).includes(service)) {
+            usedTriggerKinds.update((t) => [...t, service]);
+        }
+        return externalId;
+    }
+    catch (error) {
+        sendUserToast(error.body || error.message, true);
+        return null;
+    }
+}

package/package/components/triggers/schedules/ScheduleEditorInner.svelte

@@ -254,17 +254,17 @@ export async function openNew(nis_flow, initial_script_path, defaultValues, sche
         schedule = s?.schedule ?? '0 0 12 * *';
         initialSchedule = schedule;
         timezone = s?.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
-        paused_until = s?.paused_until;
+        paused_until = s?.paused_until ?? undefined;
         showPauseUntil = paused_until !== undefined;
         summary = s?.summary ?? '';
         description = s?.description ?? '';
         script_path = s?.script_path ?? initialScriptPath;
         args = s?.args ?? {};
-        tag = s?.tag;
+        tag = s?.tag ?? undefined;
         await loadScript(script_path);
         no_flow_overlap = s?.no_flow_overlap ?? false;
         wsErrorHandlerMuted = s?.ws_error_handler_muted ?? false;
-        retry = s?.retry;
+        retry = s?.retry ?? undefined;
         await setScheduleHandler(s);
     }
     finally {

package/package/components/triggers/triggers.svelte.d.ts

@@ -1,4 +1,4 @@
-import { type TriggersCount } from '../../gen';
+import { type TriggersCount, type NativeServiceName } from '../../gen';
 import { type Trigger } from './utils';
 import { type Writable } from 'svelte/store';
 import type { TriggerType } from './utils';
@@ -28,5 +28,6 @@ export declare class Triggers {
     fetchGcpTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
     fetchHttpTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
     fetchEmailTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
+    fetchNativeTriggers(triggersCountStore: Writable<TriggersCount | undefined>, serviceName: NativeServiceName, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
     fetchTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, primarySchedule?: ScheduleTrigger | undefined | false, user?: UserExt | undefined): Promise<void>;
 }

package/package/components/triggers/triggers.svelte.js

@@ -1,4 +1,4 @@
-import { KafkaTriggerService, MqttTriggerService, NatsTriggerService, PostgresTriggerService, ScheduleService, SqsTriggerService, WebsocketTriggerService, HttpTriggerService, GcpTriggerService, EmailTriggerService } from '../../gen';
+import { KafkaTriggerService, MqttTriggerService, NatsTriggerService, PostgresTriggerService, ScheduleService, SqsTriggerService, WebsocketTriggerService, NativeTriggerService, HttpTriggerService, GcpTriggerService, EmailTriggerService } from '../../gen';
 import { enterpriseLicense } from '../../stores';
 import { getLightConfig, sortTriggers, updateTriggersCount } from './utils';
 import { get } from 'svelte/store';
@@ -38,6 +38,7 @@ export class Triggers {
         this.#updateDraftCallback?.();
     }
     setDraftConfig(triggerIndex, draftConfig) {
+        console.log('setDraftConfig', triggerIndex, draftConfig);
         if (triggerIndex === undefined || triggerIndex < 0 || triggerIndex >= this.#triggers.length) {
             return;
         }
@@ -339,6 +340,37 @@ export class Triggers {
             console.error('Failed to fetch email triggers:', error);
         }
     }
+    async fetchNativeTriggers(triggersCountStore, serviceName, workspaceId, path, isFlow, user = undefined) {
+        if (!workspaceId)
+            return;
+        try {
+            const triggers = await NativeTriggerService.listNativeTriggers({
+                workspace: workspaceId,
+                serviceName,
+                path,
+                isFlow
+            });
+            // Convert to the trigger format used by updateTriggers
+            const triggerData = triggers.map((t) => ({
+                path: t.external_id,
+                script_path: t.script_path,
+                is_flow: t.is_flow,
+                extra_perms: {},
+                service_config: t.service_config
+            }));
+            const count = this.updateTriggers(triggerData, serviceName, user);
+            const countProperty = `${serviceName}_count`;
+            triggersCountStore.update((triggersCount) => {
+                return {
+                    ...(triggersCount ?? {}),
+                    [countProperty]: count
+                };
+            });
+        }
+        catch (error) {
+            console.debug(`Failed to fetch ${serviceName} triggers:`, error);
+        }
+    }
     async fetchTriggers(triggersCountStore, workspaceId, path, isFlow, primarySchedule = undefined, user = undefined) {
         if (!workspaceId)
             return;
@@ -348,14 +380,18 @@ export class Triggers {
             this.fetchHttpTriggers(triggersCountStore, workspaceId, path, isFlow, user),
             this.fetchWebsocketTriggers(triggersCountStore, workspaceId, path, isFlow, user),
             this.fetchPostgresTriggers(triggersCountStore, workspaceId, path, isFlow, user),
-            this.fetchNatsTriggers(triggersCountStore, workspaceId, path, isFlow, user),
             this.fetchMqttTriggers(triggersCountStore, workspaceId, path, isFlow, user),
-            this.fetchEmailTriggers(triggersCountStore, workspaceId, path, isFlow, user),
-            ...(get(enterpriseLicense) ? [
-                this.fetchKafkaTriggers(triggersCountStore, workspaceId, path, isFlow, user),
-                this.fetchSqsTriggers(triggersCountStore, workspaceId, path, isFlow, user),
-                this.fetchGcpTriggers(triggersCountStore, workspaceId, path, isFlow, user)
-            ] : [])
+            this.fetchNativeTriggers(triggersCountStore, 'nextcloud', workspaceId, path, isFlow, user),
+            this.fetchNativeTriggers(triggersCountStore, 'google', workspaceId, path, isFlow, user),
+            ...(get(enterpriseLicense)
+                ? [
+                    this.fetchKafkaTriggers(triggersCountStore, workspaceId, path, isFlow, user),
+                    this.fetchSqsTriggers(triggersCountStore, workspaceId, path, isFlow, user),
+                    this.fetchGcpTriggers(triggersCountStore, workspaceId, path, isFlow, user),
+                    this.fetchEmailTriggers(triggersCountStore, workspaceId, path, isFlow, user),
+                    this.fetchNatsTriggers(triggersCountStore, workspaceId, path, isFlow, user)
+                ]
+                : [])
         ]);
     }
 }

package/package/components/triggers/utils.js

@@ -5,7 +5,6 @@ import MqttIcon from '../icons/MqttIcon.svelte';
 import AwsIcon from '../icons/AwsIcon.svelte';
 import GoogleCloudIcon from '../icons/GoogleCloudIcon.svelte';
 import SchedulePollIcon from '../icons/SchedulePollIcon.svelte';
-import {} from './';
 import { saveScheduleFromCfg } from '../flows/scheduleUtils';
 import { saveHttpRouteFromCfg } from './http/utils';
 import { saveWebsocketTriggerFromCfg } from './websocket/utils';
@@ -17,6 +16,9 @@ import { saveMqttTriggerFromCfg } from './mqtt/utils';
 import { saveGcpTriggerFromCfg } from './gcp/utils';
 import { emptyString } from '../../utils';
 import { saveEmailTriggerFromCfg } from './email/utils';
+import NextcloudIcon from '../icons/NextcloudIcon.svelte';
+import GoogleIcon from '../icons/GoogleIcon.svelte';
+import { saveNativeTriggerFromCfg } from './native/utils';
 export const CLOUD_DISABLED_TRIGGER_TYPES = [
     'nats',
     'kafka',
@@ -38,7 +40,8 @@ export const jobTriggerKinds = [
     'sqs',
     'postgres',
     'schedule',
-    'gcp'
+    'gcp',
+    'google'
 ];
 // Map of trigger kinds to icons
 export const triggerIconMap = {
@@ -56,7 +59,9 @@ export const triggerIconMap = {
     gcp: GoogleCloudIcon,
     primary_schedule: Calendar,
     poll: SchedulePollIcon,
-    cli: Terminal
+    cli: Terminal,
+    nextcloud: NextcloudIcon,
+    google: GoogleIcon
 };
 export const triggerDisplayNamesMap = {
     schedule: 'Schedule',
@@ -72,7 +77,9 @@ export const triggerDisplayNamesMap = {
     poll: 'Scheduled Poll',
     webhook: 'Webhook',
     default_email: 'Default Email',
-    cli: 'CLI'
+    cli: 'CLI',
+    nextcloud: 'Nextcloud',
+    google: 'Google'
 };
 /**
  * Converts a TriggerType to a CaptureTriggerKind when a mapping exists
@@ -116,7 +123,9 @@ export function updateTriggersCount(triggersCountStore, type, action, primaryCfg
         gcp: 'gcp_count',
         email: 'email_count',
         poll: undefined,
-        cli: undefined
+        cli: undefined,
+        nextcloud: 'nextcloud_count',
+        google: 'google_count'
     };
     const countProperty = countPropertyMap[type];
     triggersCountStore.update((triggersCount) => {
@@ -221,7 +230,9 @@ export async function deployTriggers(triggersToDeploy, workspaceId, isAdmin, use
         gcp: (trigger) => saveGcpTriggerFromCfg(trigger.path ?? trigger.draftConfig?.path ?? '', trigger.draftConfig ?? {}, !trigger.isDraft, workspaceId, usedTriggerKinds),
         email: (trigger) => saveEmailTriggerFromCfg(trigger.path ?? trigger.draftConfig?.path ?? '', trigger.draftConfig ?? {}, !trigger.isDraft, workspaceId, isAdmin, usedTriggerKinds),
         poll: undefined,
-        cli: undefined
+        cli: undefined,
+        nextcloud: (trigger) => saveNativeTriggerFromCfg('nextcloud', trigger.path ?? '', trigger.draftConfig ?? {}, !trigger.isDraft, workspaceId, usedTriggerKinds),
+        google: (trigger) => saveNativeTriggerFromCfg('google', trigger.path ?? '', trigger.draftConfig ?? {}, !trigger.isDraft, workspaceId, usedTriggerKinds)
     };
     await Promise.all(triggersToDeploy.map(async (trigger) => {
         const saveFunction = triggerSaveFunctions[trigger.type];
@@ -302,6 +313,18 @@ export function getLightConfig(triggerType, trigger) {
     else if (triggerType === 'email') {
         return { local_part: trigger.local_part };
     }
+    else if (triggerType === 'nextcloud') {
+        return { event: trigger.service_config?.event ?? trigger.event };
+    }
+    else if (triggerType === 'google') {
+        return {
+            trigger_type: trigger.service_config?.triggerType ?? trigger.trigger_type,
+            resource_id: trigger.service_config?.resourceId ?? trigger.resource_id,
+            resource_name: trigger.service_config?.resourceName ?? trigger.resource_name,
+            calendar_id: trigger.service_config?.calendarId ?? trigger.calendar_id,
+            calendar_name: trigger.service_config?.calendarName ?? trigger.calendar_name
+        };
+    }
     else {
         return undefined;
     }
@@ -346,6 +369,20 @@ export function getTriggerLabel(trigger) {
     else if (type === 'email' && config?.local_part) {
         return `${config?.local_part}`;
     }
+    else if (type === 'nextcloud' && path) {
+        return `${path}`;
+    }
+    else if (type === 'google' && path) {
+        const triggerType = config?.trigger_type ?? config?.triggerType;
+        if (triggerType === 'calendar') {
+            const name = config?.resource_name ?? config?.calendar_id ?? '';
+            return `Calendar: ${name || path}`;
+        }
+        else {
+            const name = config?.resource_name ?? '';
+            return name ? `Drive: ${name}` : config?.resource_id ? `Drive: ${path}` : `Drive: All changes`;
+        }
+    }
     else if (isDraft && draftConfig?.path) {
         return `${draftConfig?.path}`;
     }
@@ -371,7 +408,9 @@ export function sortTriggers(triggers) {
         'mqtt',
         'sqs',
         'gcp',
-        'email'
+        'email',
+        'nextcloud',
+        'google'
     ];
     return triggers.sort((a, b) => {
         // Draft triggers always come last

package/package/components/triggers/websocket/WebsocketEditorConfigSection.svelte

@@ -135,7 +135,7 @@ $effect(() => {
 						{/key}
 					{/await}
 					{#if urlRunnableSchema.properties && Object.keys(urlRunnableSchema.properties).length === 0}
-						<div class="text-xs texg-gray-700">This runnable takes no arguments</div>
+						<div class="text-xs text-secondary">This runnable takes no arguments</div>
 					{/if}
 				{:else}
 					<Loader2 class="animate-spin mt-2" />

package/package/components/triggers/websocket/WebsocketTriggerEditorInner.svelte

@@ -12,6 +12,7 @@ import { Loader2, X, Plus } from 'lucide-svelte';
 import Label from '../../Label.svelte';
 import { fade } from 'svelte/transition';
 import JsonEditor from '../../JsonEditor.svelte';
+import TriggerFilters from '../TriggerFilters.svelte';
 import Toggle from '../../Toggle.svelte';
 import WebsocketEditorConfigSection from './WebsocketEditorConfigSection.svelte';
 import { untrack } from 'svelte';
@@ -547,7 +548,7 @@ $effect(() => {
 													/>
 												{/await}
 												{#if schema && schema.properties && Object.keys(schema.properties).length === 0}
-													<div class="text-xs texg-gray-700">This runnable takes no arguments</div>
+													<div class="text-xs text-secondary">This runnable takes no arguments</div>
 												{/if}
 											{:else}
 												<Loader2 class="animate-spin mt-2" />
@@ -594,86 +595,7 @@ $effect(() => {
 				</div>
 			</Section>
 
-			<Section label="Filters">
-				<p class="text-xs mb-1 text-primary">
-					Filters will limit the execution of the trigger to only messages that match all criteria.<br
-					/>
-					The JSON filter checks if the value at the key is equal or a superset of the filter value.
-				</p>
-				<div class="flex flex-col gap-4 mt-1">
-					{#each filters as v, i}
-						<div class="flex w-full gap-2 items-center">
-							<div class="w-full flex flex-col gap-2 border p-2 rounded-md">
-								<div class="flex flex-row gap-2 w-full">
-									<label class="flex flex-col w-full">
-										<div class="text-secondary text-sm mb-2">Type</div>
-										<select
-											class="w-20"
-											onchange={(e) => {
-												if (e.target?.['value']) {
-													filters[i] = {
-														key: '',
-														value: ''
-													}
-												}
-											}}
-											value={'json'}
-											disabled={!can_write}
-										>
-											<option value="json">JSON</option>
-										</select>
-									</label>
-								</div>
-								<label class="flex flex-col w-full">
-									<div class="text-secondary text-sm mb-2">Key</div>
-									<input type="text" bind:value={v.key} disabled={!can_write} />
-								</label>
-								<!-- svelte-ignore a11y_label_has_associated_control -->
-								<label class="flex flex-col w-full">
-									<div class="text-secondary text-sm mb-2">Value</div>
-									<JsonEditor
-										bind:value={v.value}
-										code={JSON.stringify(v.value)}
-										disabled={!can_write}
-									/>
-								</label>
-							</div>
-							<button
-								transition:fade|local={{ duration: 100 }}
-								class="rounded-full p-1 bg-surface-secondary duration-200 hover:bg-surface-hover"
-								aria-label="Clear"
-								onclick={() => {
-									filters = filters.filter((_, index) => index !== i)
-								}}
-								disabled={!can_write}
-							>
-								<X size={14} />
-							</button>
-						</div>
-					{/each}
-
-					<div class="flex items-baseline">
-						<Button
-							variant="default"
-							size="xs"
-							btnClasses="mt-1"
-							on:click={() => {
-								if (filters == undefined || !Array.isArray(filters)) {
-									filters = []
-								}
-								filters = filters.concat({
-									key: '',
-									value: ''
-								})
-							}}
-							disabled={!can_write}
-							startIcon={{ icon: Plus }}
-						>
-							Add item
-						</Button>
-					</div>
-				</div>
-			</Section>
+			<TriggerFilters bind:filters disabled={!can_write} />
 
 			<Section label="Advanced" collapsable>
 				<div class="flex flex-col gap-4">

package/package/components/triggers.d.ts

@@ -16,5 +16,5 @@ export type TriggerContext = {
     triggersState: Triggers;
 };
 export declare function setScheduledPollSchedule(triggersState: Triggers, triggersCount: Writable<TriggersCount | undefined>): void;
-export type TriggerKind = 'webhooks' | 'emails' | 'default_emails' | 'schedules' | 'cli' | 'routes' | 'websockets' | 'scheduledPoll' | 'kafka' | 'nats' | 'postgres' | 'mqtt' | 'sqs' | 'gcp';
+export type TriggerKind = 'webhooks' | 'emails' | 'default_emails' | 'schedules' | 'cli' | 'routes' | 'websockets' | 'scheduledPoll' | 'kafka' | 'nats' | 'postgres' | 'mqtt' | 'sqs' | 'gcp' | 'nextcloud' | 'google';
 export declare function captureTriggerKindToTriggerKind(kind: CaptureTriggerKind): TriggerKind;