@wave-av/workflow-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,507 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_API_URL: () => DEFAULT_API_URL,
+  ExecuteWorkflowRequestSchema: () => ExecuteWorkflowRequestSchema,
+  VERSION: () => VERSION,
+  WaveWorkflowClient: () => WaveWorkflowClient,
+  WorkflowAgentSchema: () => WorkflowAgentSchema,
+  WorkflowBuilder: () => WorkflowBuilder,
+  WorkflowConfigSchema: () => WorkflowConfigSchema,
+  WorkflowDefinitionSchema: () => WorkflowDefinitionSchema,
+  WorkflowPhaseSchema: () => WorkflowPhaseSchema,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var import_zod = require("zod");
+var WorkflowAgentSchema = import_zod.z.object({
+  type: import_zod.z.string().min(1),
+  config: import_zod.z.record(import_zod.z.unknown()).optional(),
+  timeout_seconds: import_zod.z.number().int().positive().optional(),
+  retry_policy: import_zod.z.object({
+    max_attempts: import_zod.z.number().int().positive(),
+    backoff_type: import_zod.z.enum(["fixed", "exponential"]),
+    initial_delay_ms: import_zod.z.number().int().positive(),
+    max_delay_ms: import_zod.z.number().int().positive().optional()
+  }).optional()
+});
+var WorkflowPhaseSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1).max(100),
+  description: import_zod.z.string().max(500).optional(),
+  order: import_zod.z.number().int().positive(),
+  agents: import_zod.z.array(WorkflowAgentSchema),
+  condition: import_zod.z.object({
+    type: import_zod.z.enum(["expression", "previous_phase_status"]),
+    expression: import_zod.z.string().optional(),
+    required_status: import_zod.z.enum(["completed", "skipped"]).optional()
+  }).optional(),
+  on_failure: import_zod.z.enum(["fail", "skip", "retry"]).optional()
+});
+var WorkflowConfigSchema = import_zod.z.object({
+  timeout_seconds: import_zod.z.number().int().positive().max(86400).optional(),
+  max_retries: import_zod.z.number().int().min(0).max(10).optional(),
+  checkpoint_enabled: import_zod.z.boolean().optional(),
+  parallel_phases: import_zod.z.boolean().optional(),
+  fail_fast: import_zod.z.boolean().optional(),
+  notification_channels: import_zod.z.array(import_zod.z.string()).optional()
+});
+var WorkflowDefinitionSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1).max(200),
+  slug: import_zod.z.string().regex(/^[a-z0-9-]+$/).min(1).max(100),
+  description: import_zod.z.string().max(1e3).optional(),
+  category: import_zod.z.string().min(1).max(50),
+  version: import_zod.z.string().regex(/^\d+\.\d+\.\d+$/),
+  phases: import_zod.z.array(WorkflowPhaseSchema).min(1),
+  config: WorkflowConfigSchema.optional(),
+  tags: import_zod.z.array(import_zod.z.string().max(50)).max(10).optional()
+});
+var ExecuteWorkflowRequestSchema = import_zod.z.object({
+  input_params: import_zod.z.record(import_zod.z.unknown()).optional(),
+  trigger_type: import_zod.z.enum(["manual", "api"]).optional(),
+  idempotency_key: import_zod.z.string().max(100).optional(),
+  checkpoint_id: import_zod.z.string().uuid().optional()
+});
+
+// src/client.ts
+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);
+}
+
+// src/builder.ts
+var WorkflowBuilder = class {
+  definition = {
+    phases: [],
+    config: {},
+    tags: []
+  };
+  constructor(slug) {
+    this.definition.slug = slug;
+  }
+  /**
+   * Set the workflow name
+   */
+  name(name) {
+    this.definition.name = name;
+    return this;
+  }
+  /**
+   * Set the workflow description
+   */
+  description(description) {
+    this.definition.description = description;
+    return this;
+  }
+  /**
+   * Set the workflow category
+   */
+  category(category) {
+    this.definition.category = category;
+    return this;
+  }
+  /**
+   * Set the workflow version
+   */
+  version(version) {
+    this.definition.version = version;
+    return this;
+  }
+  /**
+   * Add tags to the workflow
+   */
+  tags(...tags) {
+    this.definition.tags = [...this.definition.tags || [], ...tags];
+    return this;
+  }
+  /**
+   * Add a phase to the workflow
+   */
+  phase(name, builder) {
+    const phaseBuilder = new PhaseBuilder(name, (this.definition.phases?.length || 0) + 1);
+    builder(phaseBuilder);
+    this.definition.phases = [...this.definition.phases || [], phaseBuilder.build()];
+    return this;
+  }
+  /**
+   * Set workflow configuration
+   */
+  config(config) {
+    this.definition.config = { ...this.definition.config, ...config };
+    return this;
+  }
+  /**
+   * Set timeout in seconds
+   */
+  timeout(seconds) {
+    this.definition.config = { ...this.definition.config, timeout_seconds: seconds };
+    return this;
+  }
+  /**
+   * Enable checkpointing
+   */
+  enableCheckpoints() {
+    this.definition.config = { ...this.definition.config, checkpoint_enabled: true };
+    return this;
+  }
+  /**
+   * Set max retries
+   */
+  maxRetries(retries) {
+    this.definition.config = { ...this.definition.config, max_retries: retries };
+    return this;
+  }
+  /**
+   * Build and validate the workflow definition
+   */
+  build() {
+    const result = WorkflowDefinitionSchema.safeParse(this.definition);
+    if (!result.success) {
+      const errors = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("\n");
+      throw new Error(`Invalid workflow definition:
+${errors}`);
+    }
+    return result.data;
+  }
+  /**
+   * Export as JSON
+   */
+  toJSON() {
+    return JSON.stringify(this.build(), null, 2);
+  }
+};
+var PhaseBuilder = class {
+  phase;
+  constructor(name, order) {
+    this.phase = {
+      name,
+      order,
+      agents: []
+    };
+  }
+  /**
+   * Set phase description
+   */
+  description(description) {
+    this.phase.description = description;
+    return this;
+  }
+  /**
+   * Add an agent to the phase
+   */
+  agent(type, config) {
+    const agent = { type };
+    if (config) agent.config = config;
+    this.phase.agents = [...this.phase.agents || [], agent];
+    return this;
+  }
+  /**
+   * Add an agent with full configuration
+   */
+  agentWithRetry(type, config, retryPolicy) {
+    const agent = {
+      type,
+      config,
+      retry_policy: retryPolicy
+    };
+    this.phase.agents = [...this.phase.agents || [], agent];
+    return this;
+  }
+  /**
+   * Set conditional execution based on expression
+   */
+  runIf(expression) {
+    this.phase.condition = {
+      type: "expression",
+      expression
+    };
+    return this;
+  }
+  /**
+   * Set conditional execution based on previous phase status
+   */
+  runAfter(status) {
+    this.phase.condition = {
+      type: "previous_phase_status",
+      required_status: status
+    };
+    return this;
+  }
+  /**
+   * Set failure behavior
+   */
+  onFailure(behavior) {
+    this.phase.on_failure = behavior;
+    return this;
+  }
+  /**
+   * Build the phase
+   */
+  build() {
+    return this.phase;
+  }
+};
+
+// src/index.ts
+var VERSION = "1.0.0";
+var DEFAULT_API_URL = "https://api.wave.online";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_API_URL,
+  ExecuteWorkflowRequestSchema,
+  VERSION,
+  WaveWorkflowClient,
+  WorkflowAgentSchema,
+  WorkflowBuilder,
+  WorkflowConfigSchema,
+  WorkflowDefinitionSchema,
+  WorkflowPhaseSchema,
+  createClient
+});

package/dist/index.mjs

@@ -0,0 +1,200 @@
+import {
+  WaveWorkflowClient,
+  createClient
+} from "./chunk-M3UAADWT.mjs";
+import {
+  ExecuteWorkflowRequestSchema,
+  WorkflowAgentSchema,
+  WorkflowConfigSchema,
+  WorkflowDefinitionSchema,
+  WorkflowPhaseSchema
+} from "./chunk-O4EIGRTS.mjs";
+
+// src/builder.ts
+var WorkflowBuilder = class {
+  definition = {
+    phases: [],
+    config: {},
+    tags: []
+  };
+  constructor(slug) {
+    this.definition.slug = slug;
+  }
+  /**
+   * Set the workflow name
+   */
+  name(name) {
+    this.definition.name = name;
+    return this;
+  }
+  /**
+   * Set the workflow description
+   */
+  description(description) {
+    this.definition.description = description;
+    return this;
+  }
+  /**
+   * Set the workflow category
+   */
+  category(category) {
+    this.definition.category = category;
+    return this;
+  }
+  /**
+   * Set the workflow version
+   */
+  version(version) {
+    this.definition.version = version;
+    return this;
+  }
+  /**
+   * Add tags to the workflow
+   */
+  tags(...tags) {
+    this.definition.tags = [...this.definition.tags || [], ...tags];
+    return this;
+  }
+  /**
+   * Add a phase to the workflow
+   */
+  phase(name, builder) {
+    const phaseBuilder = new PhaseBuilder(name, (this.definition.phases?.length || 0) + 1);
+    builder(phaseBuilder);
+    this.definition.phases = [...this.definition.phases || [], phaseBuilder.build()];
+    return this;
+  }
+  /**
+   * Set workflow configuration
+   */
+  config(config) {
+    this.definition.config = { ...this.definition.config, ...config };
+    return this;
+  }
+  /**
+   * Set timeout in seconds
+   */
+  timeout(seconds) {
+    this.definition.config = { ...this.definition.config, timeout_seconds: seconds };
+    return this;
+  }
+  /**
+   * Enable checkpointing
+   */
+  enableCheckpoints() {
+    this.definition.config = { ...this.definition.config, checkpoint_enabled: true };
+    return this;
+  }
+  /**
+   * Set max retries
+   */
+  maxRetries(retries) {
+    this.definition.config = { ...this.definition.config, max_retries: retries };
+    return this;
+  }
+  /**
+   * Build and validate the workflow definition
+   */
+  build() {
+    const result = WorkflowDefinitionSchema.safeParse(this.definition);
+    if (!result.success) {
+      const errors = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("\n");
+      throw new Error(`Invalid workflow definition:
+${errors}`);
+    }
+    return result.data;
+  }
+  /**
+   * Export as JSON
+   */
+  toJSON() {
+    return JSON.stringify(this.build(), null, 2);
+  }
+};
+var PhaseBuilder = class {
+  phase;
+  constructor(name, order) {
+    this.phase = {
+      name,
+      order,
+      agents: []
+    };
+  }
+  /**
+   * Set phase description
+   */
+  description(description) {
+    this.phase.description = description;
+    return this;
+  }
+  /**
+   * Add an agent to the phase
+   */
+  agent(type, config) {
+    const agent = { type };
+    if (config) agent.config = config;
+    this.phase.agents = [...this.phase.agents || [], agent];
+    return this;
+  }
+  /**
+   * Add an agent with full configuration
+   */
+  agentWithRetry(type, config, retryPolicy) {
+    const agent = {
+      type,
+      config,
+      retry_policy: retryPolicy
+    };
+    this.phase.agents = [...this.phase.agents || [], agent];
+    return this;
+  }
+  /**
+   * Set conditional execution based on expression
+   */
+  runIf(expression) {
+    this.phase.condition = {
+      type: "expression",
+      expression
+    };
+    return this;
+  }
+  /**
+   * Set conditional execution based on previous phase status
+   */
+  runAfter(status) {
+    this.phase.condition = {
+      type: "previous_phase_status",
+      required_status: status
+    };
+    return this;
+  }
+  /**
+   * Set failure behavior
+   */
+  onFailure(behavior) {
+    this.phase.on_failure = behavior;
+    return this;
+  }
+  /**
+   * Build the phase
+   */
+  build() {
+    return this.phase;
+  }
+};
+
+// src/index.ts
+var VERSION = "1.0.0";
+var DEFAULT_API_URL = "https://api.wave.online";
+export {
+  DEFAULT_API_URL,
+  ExecuteWorkflowRequestSchema,
+  VERSION,
+  WaveWorkflowClient,
+  WorkflowAgentSchema,
+  WorkflowBuilder,
+  WorkflowConfigSchema,
+  WorkflowDefinitionSchema,
+  WorkflowPhaseSchema,
+  createClient
+};