weifuwu 0.18.3 → 0.18.5

package/dist/dist/iii/stream.d.ts

@@ -0,0 +1,82 @@
+import type { Redis } from '../vendor.ts';
+import type { PostgresClient } from '../postgres/types.ts';
+import type { StreamUpdateOp, StreamSubscription } from './types.ts';
+export declare function createStream(opts?: {
+    pg?: PostgresClient;
+    redis?: Redis;
+    streamTTL?: number;
+}): {
+    subscribe(ws: WebSocket, sub: StreamSubscription): void;
+    unsubscribe(ws: WebSocket): void;
+    migrate(): Promise<void>;
+    close(): Promise<void>;
+    set(stream: string, group: string, item: string, data: unknown): Promise<{
+        old_value: null;
+        new_value: unknown;
+    }>;
+    get(stream: string, group: string, item: string): Promise<{
+        value: any;
+    }>;
+    delete(stream: string, group: string, item: string): Promise<{
+        old_value: any;
+    }>;
+    list(stream: string, group: string): Promise<{
+        items: {
+            item_id: any;
+            data: any;
+        }[];
+    }>;
+    list_groups(stream: string): Promise<{
+        groups: any[];
+    }>;
+    list_all(): Promise<{
+        streams: {
+            stream_name: any;
+            group_count: number;
+            item_count: number;
+        }[];
+        count: number;
+    }>;
+    send(stream: string, group: string, type: string, data: unknown, id?: string): Promise<void>;
+    update(stream: string, group: string, item: string, ops: StreamUpdateOp[]): Promise<{
+        old_value: any;
+        new_value: any;
+    }>;
+} | {
+    subscribe(ws: WebSocket, sub: StreamSubscription): void;
+    unsubscribe(ws: WebSocket): void;
+    migrate(): Promise<void>;
+    close(): Promise<void>;
+    set(stream: string, group: string, item: string, data: unknown): Promise<{
+        old_value: unknown;
+        new_value: unknown;
+    }>;
+    get(stream: string, group: string, item: string): Promise<{
+        value: any;
+    }>;
+    delete(stream: string, group: string, item: string): Promise<{
+        old_value: any;
+    }>;
+    list(stream: string, group: string): Promise<{
+        items: {
+            item_id: string;
+            data: any;
+        }[];
+    }>;
+    list_groups(stream: string): Promise<{
+        groups: string[];
+    }>;
+    list_all(): Promise<{
+        streams: {
+            stream_name: string;
+            group_count: number;
+            item_count: number;
+        }[];
+        count: number;
+    }>;
+    send(stream: string, group: string, type: string, data: unknown, id?: string): Promise<void>;
+    update(stream: string, group: string, item: string, ops: StreamUpdateOp[]): Promise<{
+        old_value: any;
+        new_value: any;
+    }>;
+};

package/dist/dist/iii/types.d.ts

@@ -0,0 +1,133 @@
+import type { Router } from '../router.ts';
+import type { Redis } from '../vendor.ts';
+import type { PostgresClient } from '../postgres/types.ts';
+export type FunctionHandler = (payload: unknown, ctx: FunctionContext) => unknown | Promise<unknown>;
+export interface FunctionContext {
+    engine: IIIModule;
+    functionId: string;
+    workerName: string;
+    triggerId?: string;
+    user?: unknown;
+}
+export interface TriggerInput {
+    type: string;
+    function_id: string;
+    config: Record<string, unknown>;
+}
+export interface IIIOptions {
+    pg?: PostgresClient;
+    redis?: Redis;
+    /** TTL in seconds for Redis stream keys. Default: 3600 (1 hour). Set to 0 for no expiration. */
+    streamTTL?: number;
+}
+export interface TriggerRequest {
+    function_id: string;
+    payload: unknown;
+    action?: 'sync' | 'void';
+    timeout_ms?: number;
+}
+export interface TriggerOptions {
+    action?: 'sync' | 'void';
+    timeout_ms?: number;
+}
+export interface IIIModule extends Router {
+    wsHandler: () => any;
+    addWorker: (worker: Worker) => void;
+    trigger: (request: TriggerRequest) => Promise<unknown>;
+    removeWorker: (worker: Worker) => void;
+    listWorkers: () => WorkerInfo[];
+    listFunctions: () => FunctionInfo[];
+    listTriggers: () => TriggerInfo[];
+    migrate: () => Promise<void>;
+    shutdown: () => Promise<void>;
+}
+export interface WorkerInfo {
+    id: string;
+    name: string;
+    status: 'connected' | 'disconnected';
+    connectedAt: number;
+    functionCount: number;
+    triggerCount: number;
+}
+export interface FunctionInfo {
+    id: string;
+    workerId: string;
+    workerName: string;
+    triggers: string[];
+}
+export interface TriggerInfo {
+    id: string;
+    type: string;
+    function_id: string;
+    config: Record<string, unknown>;
+    workerId: string;
+}
+export interface Worker {
+    readonly name: string;
+    registerFunction: (id: string, handler: FunctionHandler, opts?: {
+        description?: string;
+    }) => Worker;
+    unregisterFunction: (id: string) => Worker;
+    registerTrigger: (input: TriggerInput) => Worker;
+    unregisterTrigger: (functionId: string) => Worker;
+    getFunctions: () => {
+        id: string;
+        handler: FunctionHandler;
+    }[];
+    getTriggers: () => {
+        id: string;
+        input: TriggerInput;
+    }[];
+}
+export interface RemoteWorker {
+    registerFunction: (id: string, handler: FunctionHandler) => void;
+    unregisterFunction: (id: string) => void;
+    registerTrigger: (input: TriggerInput) => void;
+    unregisterTrigger: (functionId: string) => void;
+    trigger: (request: TriggerRequest) => Promise<unknown>;
+    shutdown: () => void;
+}
+export interface FunctionRegistration {
+    id: string;
+    handler: FunctionHandler;
+    workerId: string;
+    workerName: string;
+    triggers: string[];
+}
+export interface TriggerRegistration {
+    id: string;
+    type: string;
+    function_id: string;
+    config: Record<string, unknown>;
+    workerId: string;
+}
+export interface WorkerRegistration {
+    id: string;
+    name: string;
+    ws?: WebSocket;
+    functions: FunctionRegistration[];
+    triggers: TriggerRegistration[];
+}
+export type StreamUpdateOp = {
+    op: 'set';
+    value: unknown;
+} | {
+    op: 'merge';
+    value: Record<string, unknown>;
+} | {
+    op: 'increment';
+    value: number;
+} | {
+    op: 'decrement';
+    value: number;
+} | {
+    op: 'append';
+    value: unknown;
+} | {
+    op: 'remove';
+};
+export interface StreamSubscription {
+    stream_name: string;
+    group_id?: string;
+    item_id?: string;
+}

package/dist/dist/iii/worker.d.ts

@@ -0,0 +1,2 @@
+import type { Worker } from './types.ts';
+export declare function createWorker(name: string): Worker;

package/dist/dist/iii/ws.d.ts

@@ -0,0 +1,29 @@
+import type { Context } from '../types.ts';
+interface WsHandlerDeps {
+    registerRemoteWorker: (ws: WebSocket, name: string) => string;
+    unregisterRemoteWorker: (workerId: string) => void;
+    registerRemoteFunction: (workerId: string, id: string) => void;
+    unregisterRemoteFunction: (workerId: string, id: string) => void;
+    registerRemoteTrigger: (workerId: string, input: {
+        type: string;
+        function_id: string;
+        config: Record<string, unknown>;
+    }) => void;
+    unregisterRemoteTrigger: (workerId: string, functionId: string) => void;
+    addStreamSubscriber: (ws: WebSocket, sub: {
+        stream_name: string;
+        group_id?: string;
+        item_id?: string;
+    }) => void;
+    removeStreamSubscriber: (ws: WebSocket) => void;
+    handleInvokeResult: (invocationId: string, result: unknown) => void;
+    handleInvokeError: (invocationId: string, error: string) => void;
+    handleInvoke: (ws: WebSocket, invocationId: string, functionId: string, payload: unknown) => void;
+}
+export declare function createWsHandler(deps: WsHandlerDeps): {
+    open(_ws: WebSocket, _ctx: Context): void;
+    message(ws: WebSocket, ctx: Context, data: string | Buffer): Promise<void>;
+    close(ws: WebSocket): void;
+    error(ws: WebSocket): void;
+};
+export {};