@windmill-labs/shared-utils 1.0.1 → 1.0.3

package/components/diff_drawer.d.ts

@@ -0,0 +1,26 @@
+import type { Value } from "$lib/utils";
+export type DiffDrawerDiff = {
+    mode: 'normal';
+    deployed: Value;
+    draft: Value | undefined;
+    current: Value;
+    defaultDiffType?: 'deployed' | 'draft';
+    button?: {
+        text: string;
+        onClick: () => void;
+    };
+} | {
+    mode: 'simple';
+    original: Value;
+    current: Value;
+    title: string;
+    button?: {
+        text: string;
+        onClick: () => void;
+    };
+};
+export interface DiffDrawerI {
+    openDrawer: () => void;
+    closeDrawer: () => void;
+    setDiff: (diff: DiffDrawerDiff) => void;
+}

package/components/ducklake.d.ts

@@ -0,0 +1 @@
+export declare function wrapDucklakeQuery(query: string, ducklake: string): string;

package/components/flows/scheduleUtils.d.ts

@@ -0,0 +1,7 @@
+import { type Schedule, type TriggersCount } from '$lib/gen';
+import type { ScheduleTrigger } from '../triggers';
+import type { Writable } from 'svelte/store';
+export declare function loadSchedule(path: string, workspace: string): Promise<ScheduleTrigger>;
+export declare function loadSchedules(forceRefresh: boolean, path: string, isFlow: boolean, schedules: Writable<Schedule[] | undefined>, primarySchedule: Writable<ScheduleTrigger | false | undefined>, initialPrimarySchedule: Writable<ScheduleTrigger | false | undefined>, workspace: string, triggersCount: Writable<TriggersCount | undefined>, loadPrimarySchedule?: boolean, isDeployed?: Writable<boolean | undefined>): Promise<void>;
+export declare function saveSchedule(path: string, newItem: boolean, workspace: string, primarySchedule: Writable<ScheduleTrigger | false | undefined>, isFlow: boolean): Promise<void>;
+export declare function saveScheduleFromCfg(scheduleCfg: Record<string, any>, edit: boolean, workspace: string): Promise<boolean>;

package/components/random_positive_adjetive.d.ts

@@ -0,0 +1 @@
+export declare function random_adj(): string;

package/components/raw_apps/utils.d.ts

@@ -0,0 +1,15 @@
+import type { ScriptLang } from '../../gen/types.gen';
+import type { InlineScript } from '../apps/sharedTypes';
+export type RunnableWithFields = any;
+type RunnableWithInlineScript = RunnableWithFields & {
+    inlineScript?: InlineScript & {
+        language: ScriptLang;
+    };
+};
+export type Runnable = RunnableWithInlineScript | undefined;
+export type RawApp = {
+    files: string[];
+};
+export declare function htmlContent(workspace: string, secret: string | undefined, ctx: any): string;
+export declare function genWmillTs(runnables: Record<string, Runnable>): string;
+export {};

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

@@ -0,0 +1,4 @@
+import type { Writable } from 'svelte/store';
+export declare function getEmailAddress(local_part: string | undefined, workspaced_local_part: boolean, workspace_id: string, emailDomain: string): string;
+export declare function saveEmailTriggerFromCfg(initialPath: string, emailCfg: Record<string, any>, edit: boolean, workspace: string, isAdmin: boolean, usedTriggerKinds: Writable<string[]>): Promise<boolean>;
+export declare function getEmailDomain(): Promise<string>;

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

@@ -0,0 +1,2 @@
+import { type Writable } from 'svelte/store';
+export declare function saveGcpTriggerFromCfg(initialPath: string, cfg: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<boolean>;

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

@@ -0,0 +1,11 @@
+import type { NewHttpTrigger } from '$lib/gen';
+import type { Writable } from 'svelte/store';
+export declare const SECRET_KEY_PATH = "secret_key_path";
+export declare const HUB_SCRIPT_ID = 19670;
+export declare const SIGNATURE_TEMPLATE_SCRIPT_HUB_PATH: string;
+export declare const SIGNATURE_TEMPLATE_FLOW_HUB_ID = "67";
+export declare function getHttpRoute(route_prefix: string, route_path: string | undefined, workspaced_route: boolean, workspace_id: string): string;
+export declare function replacePlaceholderForSignatureScriptTemplate(content: string): string;
+export declare function saveHttpRouteFromCfg(initialPath: string, routeCfg: Record<string, any>, edit: boolean, workspace: string, isAdmin: boolean, usedTriggerKinds: Writable<string[]>): Promise<boolean>;
+export type Source = 'OpenAPI' | 'OpenAPI_File' | 'OpenAPI_URL';
+export declare function generateHttpTriggerFromOpenApi(api: string, folderName: string): Promise<NewHttpTrigger[]>;

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

@@ -0,0 +1,2 @@
+import { type Writable } from 'svelte/store';
+export declare function saveKafkaTriggerFromCfg(initialPath: string, cfg: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<boolean>;

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

@@ -0,0 +1,2 @@
+import { type Writable } from 'svelte/store';
+export declare function saveMqttTriggerFromCfg(initialPath: string, cfg: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<boolean>;

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

@@ -0,0 +1,2 @@
+import { type Writable } from 'svelte/store';
+export declare function saveNatsTriggerFromCfg(initialPath: string, cfg: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<boolean>;

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

@@ -0,0 +1,8 @@
+import { type Relations } from '$lib/gen';
+import type { Writable } from 'svelte/store';
+export declare function invalidRelations(relations: Relations[], options?: {
+    trackSchemaTableError?: boolean;
+    showError?: boolean;
+}): string;
+export declare function savePostgresTriggerFromCfg(initialPath: string, config: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<boolean>;
+export declare function getDefaultTableToTrack(pg14: boolean): Relations[];

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

@@ -0,0 +1,2 @@
+import { type Writable } from 'svelte/store';
+export declare function saveSqsTriggerFromCfg(initialPath: string, cfg: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<boolean>;

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

@@ -0,0 +1,32 @@
+import { type TriggersCount } from '$lib/gen';
+import { type Trigger } from './utils';
+import { type Writable } from 'svelte/store';
+import type { TriggerType } from './utils';
+import type { UserExt } from '$lib/stores';
+import type { ScheduleTrigger } from '../triggers';
+export declare class Triggers {
+    #private;
+    constructor(triggers?: Trigger[], selectedIndex?: number, updateDraftCallback?: (() => void) | undefined);
+    get selectedTrigger(): Trigger | undefined;
+    get selectedTriggerIndex(): number | undefined;
+    set selectedTriggerIndex(index: number | undefined);
+    get triggers(): Trigger[];
+    setTriggers(triggers: Trigger[]): void;
+    setDraftConfig(triggerIndex: number, draftConfig: Record<string, any> | undefined): void;
+    getDraftTriggersSnapshot(): Trigger[] | undefined;
+    getSelectedTriggerSnapshot(): number | undefined;
+    addDraftTrigger(triggersCountStore: Writable<TriggersCount | undefined>, type: TriggerType, path?: string, draftCfg?: Record<string, any>): number;
+    deleteTrigger(triggersCountStore: Writable<TriggersCount | undefined>, triggerIndex: number): void;
+    updateTriggers(remoteTriggers: any[], type: TriggerType, user?: UserExt | undefined): number;
+    fetchSchedules(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, primarySchedule?: ScheduleTrigger | undefined | false, user?: UserExt | undefined): Promise<void>;
+    fetchWebsocketTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
+    fetchPostgresTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
+    fetchKafkaTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
+    fetchNatsTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
+    fetchMqttTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
+    fetchSqsTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, user?: UserExt | undefined): Promise<void>;
+    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>;
+    fetchTriggers(triggersCountStore: Writable<TriggersCount | undefined>, workspaceId: string | undefined, path: string, isFlow: boolean, primarySchedule?: ScheduleTrigger | undefined | false, user?: UserExt | undefined): Promise<void>;
+}

package/components/triggers/utils.d.ts

@@ -0,0 +1,81 @@
+import { Webhook, Mail, Calendar, Route, Unplug, Database, Terminal } from 'lucide-svelte';
+import type { CaptureTriggerKind, ErrorHandler, Flow, NewScript, TriggersCount } from '$lib/gen/types.gen';
+import type { Writable } from 'svelte/store';
+import { type TriggerKind } from '$lib/components/triggers';
+import type { Triggers } from './triggers.svelte';
+export declare const CLOUD_DISABLED_TRIGGER_TYPES: string[];
+export type TriggerType = 'webhook' | 'default_email' | 'email' | 'schedule' | 'http' | 'websocket' | 'postgres' | 'kafka' | 'nats' | 'mqtt' | 'sqs' | 'gcp' | 'email' | 'poll' | 'cli';
+export declare const jobTriggerTypes: readonly ["webhook", "http", "websocket", "kafka", "email", "nats", "mqtt", "sqs", "postgres", "schedule", "gcp"];
+export type JobTriggerType = (typeof jobTriggerTypes)[number];
+export type Trigger = {
+    type: TriggerType;
+    path?: string;
+    isDraft?: boolean;
+    isPrimary?: boolean;
+    canWrite?: boolean;
+    id?: string;
+    draftConfig?: Record<string, any>;
+    captureConfig?: Record<string, any>;
+    extra?: Record<string, any>;
+    lightConfig?: Record<string, any>;
+};
+export declare const triggerIconMap: {
+    webhook: typeof Webhook;
+    email: typeof Mail;
+    default_email: typeof Mail;
+    schedule: typeof Calendar;
+    http: typeof Route;
+    websocket: typeof Unplug;
+    postgres: typeof Database;
+    kafka: import("svelte/legacy").LegacyComponentType;
+    nats: import("svelte/legacy").LegacyComponentType;
+    mqtt: import("svelte/legacy").LegacyComponentType;
+    sqs: import("svelte/legacy").LegacyComponentType;
+    gcp: import("svelte/legacy").LegacyComponentType;
+    primary_schedule: typeof Calendar;
+    poll: import("svelte/legacy").LegacyComponentType;
+    cli: typeof Terminal;
+};
+export declare const triggerDisplayNamesMap: {
+    readonly schedule: "Schedule";
+    readonly http: "HTTP";
+    readonly websocket: "WebSocket";
+    readonly postgres: "Postgres";
+    readonly kafka: "Kafka";
+    readonly nats: "NATS";
+    readonly mqtt: "MQTT";
+    readonly sqs: "SQS";
+    readonly gcp: "GCP Pub/Sub";
+    readonly email: "Email";
+    readonly poll: "Scheduled Poll";
+    readonly webhook: "Webhook";
+    readonly default_email: "Default Email";
+    readonly cli: "CLI";
+};
+/**
+ * Converts a TriggerType to a CaptureTriggerKind when a mapping exists
+ * @param triggerType The trigger type to convert
+ * @returns The corresponding CaptureTriggerKind or undefined if no mapping exists
+ */
+export declare function triggerTypeToCaptureKind(triggerType: TriggerType): CaptureTriggerKind | undefined;
+export declare function updateTriggersCount(triggersCountStore: Writable<TriggersCount | undefined>, type: TriggerType, action: 'add' | 'remove', primaryCfg?: Record<string, any>, isPrimary?: boolean): void;
+export declare function triggerKindToTriggerType(kind: TriggerKind): TriggerType | undefined;
+export declare function deployTriggers(triggersToDeploy: Trigger[], workspaceId: string | undefined, isAdmin: boolean, usedTriggerKinds: Writable<string[]>, initialPath?: string, isNew?: boolean): Promise<void>;
+export declare function handleSelectTriggerFromKind(triggersState: Triggers, triggersCountStore: Writable<TriggersCount | undefined>, initialPath: string | undefined, triggerKind: TriggerKind): void;
+export declare function handleConfigChange(nCfg: Record<string, any>, initialConfig: Record<string, any> | undefined, saveDisabled: boolean, edit: boolean, onConfigChange?: (cfg: Record<string, any>, saveDisabled: boolean, updated: boolean) => void): void;
+export declare function getLightConfig(triggerType: TriggerType, trigger: Record<string, any>): Record<string, any> | undefined;
+export declare function getTriggerLabel(trigger: Trigger): string;
+export declare function sortTriggers(triggers: Trigger[]): Trigger[];
+export type FlowWithDraftAndDraftTriggers = Flow & {
+    draft?: Flow & {
+        draft_triggers?: Trigger[];
+    };
+};
+export type NewScriptWithDraftAndDraftTriggers = NewScript & {
+    draft?: NewScript & {
+        draft_triggers?: Trigger[];
+    };
+    hash: string;
+};
+export declare function filterDraftTriggers(savedValue: FlowWithDraftAndDraftTriggers | NewScriptWithDraftAndDraftTriggers, triggersState: Triggers): FlowWithDraftAndDraftTriggers | NewScriptWithDraftAndDraftTriggers;
+export declare function getHandlerType(scriptPath: string): ErrorHandler;

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

@@ -0,0 +1,2 @@
+import type { Writable } from 'svelte/store';
+export declare function saveWebsocketTriggerFromCfg(initialPath: string, triggerCfg: Record<string, any>, edit: boolean, workspace: string, usedTriggerKinds: Writable<string[]>): Promise<boolean>;

package/components/triggers.d.ts

@@ -0,0 +1,20 @@
+import type { CaptureTriggerKind, TriggersCount } from '$lib/gen';
+import { type Writable } from 'svelte/store';
+import { Triggers } from './triggers/triggers.svelte';
+export type ScheduleTrigger = {
+    summary: string | undefined;
+    description?: string;
+    args: Record<string, any>;
+    cron: string;
+    timezone: string;
+    enabled: boolean;
+};
+export type TriggerContext = {
+    triggersCount: Writable<TriggersCount | undefined>;
+    simplifiedPoll: Writable<boolean | undefined>;
+    showCaptureHint: Writable<boolean | undefined>;
+    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 declare function captureTriggerKindToTriggerKind(kind: CaptureTriggerKind): TriggerKind;

package/gen/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: unknown;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/gen/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, unknown>;
+    readonly cookies?: Record<string, unknown>;
+    readonly headers?: Record<string, unknown>;
+    readonly query?: Record<string, unknown>;
+    readonly formData?: Record<string, unknown>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/gen/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult<TData = any> = {
+    readonly body: TData;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly url: string;
+};

package/gen/core/CancelablePromise.d.ts

@@ -0,0 +1,26 @@
+export declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+export declare class CancelablePromise<T> implements Promise<T> {
+    private _isResolved;
+    private _isRejected;
+    private _isCancelled;
+    readonly cancelHandlers: (() => void)[];
+    readonly promise: Promise<T>;
+    private _resolve?;
+    private _reject?;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: unknown) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}

package/gen/core/OpenAPI.d.ts

@@ -0,0 +1,27 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+type Headers = Record<string, string>;
+type Middleware<T> = (value: T) => T | Promise<T>;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+export declare class Interceptors<T> {
+    _fns: Middleware<T>[];
+    constructor();
+    eject(fn: Middleware<T>): void;
+    use(fn: Middleware<T>): void;
+}
+export type OpenAPIConfig = {
+    BASE: string;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    interceptors: {
+        request: Interceptors<RequestInit>;
+        response: Interceptors<Response>;
+    };
+};
+export declare const OpenAPI: OpenAPIConfig;
+export {};

package/gen/core/request.d.ts

@@ -0,0 +1,29 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { CancelablePromise } from './CancelablePromise';
+import type { OnCancel } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare const isString: (value: unknown) => value is string;
+export declare const isStringWithValue: (value: unknown) => value is string;
+export declare const isBlob: (value: any) => value is Blob;
+export declare const isFormData: (value: unknown) => value is FormData;
+export declare const base64: (str: string) => string;
+export declare const getQueryString: (params: Record<string, unknown>) => string;
+export declare const getFormData: (options: ApiRequestOptions) => FormData | undefined;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+export declare const resolve: <T>(options: ApiRequestOptions, resolver?: T | Resolver<T>) => Promise<T | undefined>;
+export declare const getHeaders: (config: OpenAPIConfig, options: ApiRequestOptions) => Promise<Headers>;
+export declare const getRequestBody: (options: ApiRequestOptions) => unknown;
+export declare const sendRequest: (config: OpenAPIConfig, options: ApiRequestOptions, url: string, body: any, formData: FormData | undefined, headers: Headers, onCancel: OnCancel) => Promise<Response>;
+export declare const getResponseHeader: (response: Response, responseHeader?: string) => string | undefined;
+export declare const getResponseBody: (response: Response) => Promise<unknown>;
+export declare const catchErrorCodes: (options: ApiRequestOptions, result: ApiResult) => void;
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
+export {};

package/gen/index.d.ts

@@ -0,0 +1,6 @@
+export { ApiError } from './core/ApiError';
+export { CancelablePromise, CancelError } from './core/CancelablePromise';
+export { OpenAPI, type OpenAPIConfig } from './core/OpenAPI';
+export * from './schemas.gen';
+export * from './services.gen';
+export * from './types.gen';