@wave-av/workflow-sdk 1.0.0

package/dist/client.d.mts

@@ -0,0 +1,141 @@
+import { EventEmitter } from 'eventemitter3';
+import { AnyWorkflowEvent, WorkflowDefinition, ExecuteWorkflowRequest, WorkflowExecution, ListExecutionsRequest, ListExecutionsResponse, ExecutionLog } from './types.mjs';
+import 'zod';
+
+/**
+ * WAVE Workflow SDK Client
+ *
+ * HTTP client for interacting with the WAVE Workflow API.
+ */
+
+/**
+ * Client configuration options
+ */
+interface WaveWorkflowClientConfig {
+    /** API key for authentication */
+    apiKey: string;
+    /** Organization ID for tenant isolation */
+    organizationId: string;
+    /** Base URL for the API (default: https://api.wave.online) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Workflow event types for the event emitter
+ */
+interface WorkflowClientEvents {
+    'execution.started': (event: AnyWorkflowEvent) => void;
+    'execution.completed': (event: AnyWorkflowEvent) => void;
+    'execution.failed': (event: AnyWorkflowEvent) => void;
+    'phase.started': (event: AnyWorkflowEvent) => void;
+    'phase.completed': (event: AnyWorkflowEvent) => void;
+    'error': (error: Error) => void;
+}
+/**
+ * WAVE Workflow API Client
+ *
+ * @example
+ * ```typescript
+ * const client = new WaveWorkflowClient({
+ *   apiKey: process.env.WAVE_API_KEY,
+ *   organizationId: 'org_123',
+ * });
+ *
+ * // Execute a workflow
+ * const execution = await client.execute('my-workflow', {
+ *   input_params: { foo: 'bar' },
+ * });
+ *
+ * // Wait for completion
+ * const result = await client.waitForCompletion(execution.id);
+ * ```
+ */
+declare class WaveWorkflowClient extends EventEmitter<WorkflowClientEvents> {
+    private readonly config;
+    private readonly headers;
+    constructor(config: WaveWorkflowClientConfig);
+    /**
+     * Get a workflow definition by slug
+     */
+    getWorkflow(slug: string): Promise<WorkflowDefinition>;
+    /**
+     * List all workflows
+     */
+    listWorkflows(options?: {
+        category?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        workflows: WorkflowDefinition[];
+        total: number;
+    }>;
+    /**
+     * Execute a workflow
+     */
+    execute(workflowSlug: string, request?: ExecuteWorkflowRequest): Promise<WorkflowExecution>;
+    /**
+     * Get execution status
+     */
+    getExecution(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * List executions
+     */
+    listExecutions(request?: ListExecutionsRequest): Promise<ListExecutionsResponse>;
+    /**
+     * Cancel a running execution
+     */
+    cancelExecution(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * Pause a running execution
+     */
+    pauseExecution(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * Resume a paused execution
+     */
+    resumeExecution(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * Retry a failed execution
+     */
+    retryExecution(executionId: string, options?: {
+        from_checkpoint?: boolean;
+    }): Promise<WorkflowExecution>;
+    /**
+     * Get execution logs
+     */
+    getLogs(executionId: string, options?: {
+        level?: 'debug' | 'info' | 'warn' | 'error';
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        logs: ExecutionLog[];
+        total: number;
+    }>;
+    /**
+     * Wait for an execution to complete
+     */
+    waitForCompletion(executionId: string, options?: {
+        pollInterval?: number;
+        timeout?: number;
+        onProgress?: (execution: WorkflowExecution) => void;
+    }): Promise<WorkflowExecution>;
+    /**
+     * Execute a workflow and wait for completion
+     */
+    executeAndWait(workflowSlug: string, request?: ExecuteWorkflowRequest, waitOptions?: Parameters<typeof this.waitForCompletion>[1]): Promise<WorkflowExecution>;
+    /**
+     * Subscribe to real-time execution events
+     */
+    subscribeToExecution(executionId: string): () => void;
+    private request;
+    private sleep;
+}
+/**
+ * Create a new workflow client instance
+ */
+declare function createClient(config: WaveWorkflowClientConfig): WaveWorkflowClient;
+
+export { WaveWorkflowClient, type WaveWorkflowClientConfig, type WorkflowClientEvents, createClient };

package/dist/client.d.ts

@@ -0,0 +1,141 @@
+import { EventEmitter } from 'eventemitter3';
+import { AnyWorkflowEvent, WorkflowDefinition, ExecuteWorkflowRequest, WorkflowExecution, ListExecutionsRequest, ListExecutionsResponse, ExecutionLog } from './types.js';
+import 'zod';
+
+/**
+ * WAVE Workflow SDK Client
+ *
+ * HTTP client for interacting with the WAVE Workflow API.
+ */
+
+/**
+ * Client configuration options
+ */
+interface WaveWorkflowClientConfig {
+    /** API key for authentication */
+    apiKey: string;
+    /** Organization ID for tenant isolation */
+    organizationId: string;
+    /** Base URL for the API (default: https://api.wave.online) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Workflow event types for the event emitter
+ */
+interface WorkflowClientEvents {
+    'execution.started': (event: AnyWorkflowEvent) => void;
+    'execution.completed': (event: AnyWorkflowEvent) => void;
+    'execution.failed': (event: AnyWorkflowEvent) => void;
+    'phase.started': (event: AnyWorkflowEvent) => void;
+    'phase.completed': (event: AnyWorkflowEvent) => void;
+    'error': (error: Error) => void;
+}
+/**
+ * WAVE Workflow API Client
+ *
+ * @example
+ * ```typescript
+ * const client = new WaveWorkflowClient({
+ *   apiKey: process.env.WAVE_API_KEY,
+ *   organizationId: 'org_123',
+ * });
+ *
+ * // Execute a workflow
+ * const execution = await client.execute('my-workflow', {
+ *   input_params: { foo: 'bar' },
+ * });
+ *
+ * // Wait for completion
+ * const result = await client.waitForCompletion(execution.id);
+ * ```
+ */
+declare class WaveWorkflowClient extends EventEmitter<WorkflowClientEvents> {
+    private readonly config;
+    private readonly headers;
+    constructor(config: WaveWorkflowClientConfig);
+    /**
+     * Get a workflow definition by slug
+     */
+    getWorkflow(slug: string): Promise<WorkflowDefinition>;
+    /**
+     * List all workflows
+     */
+    listWorkflows(options?: {
+        category?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        workflows: WorkflowDefinition[];
+        total: number;
+    }>;
+    /**
+     * Execute a workflow
+     */
+    execute(workflowSlug: string, request?: ExecuteWorkflowRequest): Promise<WorkflowExecution>;
+    /**
+     * Get execution status
+     */
+    getExecution(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * List executions
+     */
+    listExecutions(request?: ListExecutionsRequest): Promise<ListExecutionsResponse>;
+    /**
+     * Cancel a running execution
+     */
+    cancelExecution(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * Pause a running execution
+     */
+    pauseExecution(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * Resume a paused execution
+     */
+    resumeExecution(executionId: string): Promise<WorkflowExecution>;
+    /**
+     * Retry a failed execution
+     */
+    retryExecution(executionId: string, options?: {
+        from_checkpoint?: boolean;
+    }): Promise<WorkflowExecution>;
+    /**
+     * Get execution logs
+     */
+    getLogs(executionId: string, options?: {
+        level?: 'debug' | 'info' | 'warn' | 'error';
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        logs: ExecutionLog[];
+        total: number;
+    }>;
+    /**
+     * Wait for an execution to complete
+     */
+    waitForCompletion(executionId: string, options?: {
+        pollInterval?: number;
+        timeout?: number;
+        onProgress?: (execution: WorkflowExecution) => void;
+    }): Promise<WorkflowExecution>;
+    /**
+     * Execute a workflow and wait for completion
+     */
+    executeAndWait(workflowSlug: string, request?: ExecuteWorkflowRequest, waitOptions?: Parameters<typeof this.waitForCompletion>[1]): Promise<WorkflowExecution>;
+    /**
+     * Subscribe to real-time execution events
+     */
+    subscribeToExecution(executionId: string): () => void;
+    private request;
+    private sleep;
+}
+/**
+ * Create a new workflow client instance
+ */
+declare function createClient(config: WaveWorkflowClientConfig): WaveWorkflowClient;
+
+export { WaveWorkflowClient, type WaveWorkflowClientConfig, type WorkflowClientEvents, createClient };

package/dist/client.js

@@ -0,0 +1,262 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  WaveWorkflowClient: () => WaveWorkflowClient,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(client_exports);
+var import_eventemitter3 = require("eventemitter3");
+var WaveWorkflowClient = class extends import_eventemitter3.EventEmitter {
+  config;
+  headers;
+  constructor(config) {
+    super();
+    this.config = {
+      baseUrl: "https://api.wave.online",
+      timeout: 3e4,
+      debug: false,
+      ...config
+    };
+    this.headers = {
+      "Authorization": `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json",
+      "X-Organization-Id": this.config.organizationId
+    };
+  }
+  // ==========================================================================
+  // Workflow Definitions
+  // ==========================================================================
+  /**
+   * Get a workflow definition by slug
+   */
+  async getWorkflow(slug) {
+    return this.request(`/v1/workflows/${slug}`);
+  }
+  /**
+   * List all workflows
+   */
+  async listWorkflows(options) {
+    const params = new URLSearchParams();
+    if (options?.category) params.set("category", options.category);
+    if (options?.status) params.set("status", options.status);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.offset) params.set("offset", String(options.offset));
+    return this.request(`/v1/workflows?${params.toString()}`);
+  }
+  // ==========================================================================
+  // Workflow Executions
+  // ==========================================================================
+  /**
+   * Execute a workflow
+   */
+  async execute(workflowSlug, request) {
+    const response = await this.request(
+      `/v1/workflows/${workflowSlug}/execute`,
+      {
+        method: "POST",
+        body: JSON.stringify(request || {})
+      }
+    );
+    return response.execution;
+  }
+  /**
+   * Get execution status
+   */
+  async getExecution(executionId) {
+    return this.request(`/v1/executions/${executionId}`);
+  }
+  /**
+   * List executions
+   */
+  async listExecutions(request) {
+    const params = new URLSearchParams();
+    if (request?.workflow_id) params.set("workflow_id", request.workflow_id);
+    if (request?.status) params.set("status", request.status);
+    if (request?.limit) params.set("limit", String(request.limit));
+    if (request?.offset) params.set("offset", String(request.offset));
+    if (request?.order_by) params.set("order_by", request.order_by);
+    if (request?.order) params.set("order", request.order);
+    return this.request(`/v1/executions?${params.toString()}`);
+  }
+  /**
+   * Cancel a running execution
+   */
+  async cancelExecution(executionId) {
+    return this.request(
+      `/v1/executions/${executionId}/cancel`,
+      { method: "POST" }
+    );
+  }
+  /**
+   * Pause a running execution
+   */
+  async pauseExecution(executionId) {
+    return this.request(
+      `/v1/executions/${executionId}/pause`,
+      { method: "POST" }
+    );
+  }
+  /**
+   * Resume a paused execution
+   */
+  async resumeExecution(executionId) {
+    return this.request(
+      `/v1/executions/${executionId}/resume`,
+      { method: "POST" }
+    );
+  }
+  /**
+   * Retry a failed execution
+   */
+  async retryExecution(executionId, options) {
+    return this.request(
+      `/v1/executions/${executionId}/retry`,
+      {
+        method: "POST",
+        body: JSON.stringify(options || {})
+      }
+    );
+  }
+  // ==========================================================================
+  // Execution Logs
+  // ==========================================================================
+  /**
+   * Get execution logs
+   */
+  async getLogs(executionId, options) {
+    const params = new URLSearchParams();
+    if (options?.level) params.set("level", options.level);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.offset) params.set("offset", String(options.offset));
+    return this.request(`/v1/executions/${executionId}/logs?${params.toString()}`);
+  }
+  // ==========================================================================
+  // Convenience Methods
+  // ==========================================================================
+  /**
+   * Wait for an execution to complete
+   */
+  async waitForCompletion(executionId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 36e5;
+    const startTime = Date.now();
+    const terminalStatuses = [
+      "completed",
+      "failed",
+      "cancelled",
+      "timeout"
+    ];
+    while (Date.now() - startTime < timeout) {
+      const execution = await this.getExecution(executionId);
+      if (options?.onProgress) {
+        options.onProgress(execution);
+      }
+      if (terminalStatuses.includes(execution.status)) {
+        return execution;
+      }
+      await this.sleep(pollInterval);
+    }
+    throw new Error(`Execution ${executionId} timed out after ${timeout}ms`);
+  }
+  /**
+   * Execute a workflow and wait for completion
+   */
+  async executeAndWait(workflowSlug, request, waitOptions) {
+    const execution = await this.execute(workflowSlug, request);
+    return this.waitForCompletion(execution.id, waitOptions);
+  }
+  // ==========================================================================
+  // Real-time Events (WebSocket)
+  // ==========================================================================
+  /**
+   * Subscribe to real-time execution events
+   */
+  subscribeToExecution(executionId) {
+    const wsUrl = this.config.baseUrl.replace("https://", "wss://").replace("http://", "ws://");
+    const ws = new WebSocket(
+      `${wsUrl}/v1/executions/${executionId}/events?token=${this.config.apiKey}`
+    );
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        this.emit(data.type, data);
+      } catch (error) {
+        this.emit("error", error);
+      }
+    };
+    ws.onerror = (error) => {
+      this.emit("error", new Error(`WebSocket error: ${error}`));
+    };
+    return () => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.close();
+      }
+    };
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  async request(path, options) {
+    const url = `${this.config.baseUrl}${path}`;
+    if (this.config.debug) {
+      console.log(`[WaveWorkflowClient] ${options?.method || "GET"} ${url}`);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      this.config.timeout
+    );
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...this.headers,
+          ...options?.headers
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`API error (${response.status}): ${error}`);
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.config.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createClient(config) {
+  return new WaveWorkflowClient(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WaveWorkflowClient,
+  createClient
+});

package/dist/client.mjs

@@ -0,0 +1,8 @@
+import {
+  WaveWorkflowClient,
+  createClient
+} from "./chunk-M3UAADWT.mjs";
+export {
+  WaveWorkflowClient,
+  createClient
+};