@burdenoff/be-sdk 2026.510.79

package/dist/chunk-Z4IRLBWO.js

@@ -0,0 +1,758 @@
+import { DEFAULT_LAYER_RESOURCES } from './chunk-NGMEI42S.js';
+import { logger } from './chunk-CBZNP6RF.js';
+import { __name } from './chunk-XE4OXN2W.js';
+
+// src/temporal/client.ts
+var temporalClientModule = null;
+async function getTemporalClientModule() {
+  if (!temporalClientModule) {
+    temporalClientModule = await import('@temporalio/client');
+  }
+  return temporalClientModule;
+}
+__name(getTemporalClientModule, "getTemporalClientModule");
+var TemporalClient = class {
+  static {
+    __name(this, "TemporalClient");
+  }
+  client = null;
+  connection = null;
+  config;
+  isConnected = false;
+  constructor(config) {
+    this.config = {
+      connectionTimeout: 1e4,
+      tls: false,
+      ...config
+    };
+  }
+  /**
+  * Connect to Temporal server
+  */
+  async connect() {
+    if (this.client && this.isConnected) {
+      return this.client;
+    }
+    try {
+      logger.info("Connecting to Temporal server", {
+        address: this.config.address,
+        namespace: this.config.namespace
+      });
+      const { Connection, Client } = await getTemporalClientModule();
+      this.connection = await Connection.connect({
+        address: this.config.address,
+        tls: this.config.tls ? this.config.tlsOptions : void 0
+      });
+      this.client = new Client({
+        connection: this.connection,
+        namespace: this.config.namespace
+      });
+      this.isConnected = true;
+      logger.info("Successfully connected to Temporal", {
+        address: this.config.address,
+        namespace: this.config.namespace
+      });
+      return this.client;
+    } catch (error) {
+      logger.error("Failed to connect to Temporal", {
+        error: error instanceof Error ? error.message : String(error),
+        address: this.config.address
+      });
+      throw error;
+    }
+  }
+  /**
+  * Disconnect from Temporal server
+  */
+  async disconnect() {
+    if (this.connection) {
+      await this.connection.close();
+      this.connection = null;
+      this.client = null;
+      this.isConnected = false;
+      logger.info("Disconnected from Temporal", {
+        address: this.config.address
+      });
+    }
+  }
+  /**
+  * Get the underlying Temporal client
+  */
+  async getClient() {
+    return this.connect();
+  }
+  /**
+  * Start a workflow execution using string workflow name
+  * Note: Since workflow is specified as string (not function reference),
+  * return type is WorkflowHandle without type parameter
+  */
+  async startWorkflow(workflowType, options) {
+    const client = await this.connect();
+    try {
+      logger.debug("Starting workflow", {
+        workflowType,
+        workflowId: options.workflowId,
+        taskQueue: options.taskQueue
+      });
+      const handle = await client.workflow.start(workflowType, {
+        workflowId: options.workflowId,
+        taskQueue: options.taskQueue,
+        args: options.args ?? [],
+        workflowExecutionTimeout: options.workflowExecutionTimeout,
+        workflowRunTimeout: options.workflowRunTimeout,
+        workflowTaskTimeout: options.workflowTaskTimeout,
+        cronSchedule: options.cronSchedule,
+        memo: options.memo,
+        searchAttributes: options.searchAttributes
+      });
+      logger.info("Workflow started successfully", {
+        workflowType,
+        workflowId: options.workflowId
+      });
+      return handle;
+    } catch (error) {
+      logger.error("Failed to start workflow", {
+        workflowType,
+        workflowId: options.workflowId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+  * Execute a workflow and wait for result using string workflow name
+  * Note: Since workflow is specified as string (not function reference),
+  * return type is unknown (caller must assert type if needed)
+  */
+  async executeWorkflow(workflowType, options) {
+    const client = await this.connect();
+    try {
+      logger.debug("Executing workflow", {
+        workflowType,
+        workflowId: options.workflowId,
+        taskQueue: options.taskQueue
+      });
+      const result = await client.workflow.execute(workflowType, {
+        workflowId: options.workflowId,
+        taskQueue: options.taskQueue,
+        args: options.args ?? [],
+        workflowExecutionTimeout: options.workflowExecutionTimeout,
+        workflowRunTimeout: options.workflowRunTimeout,
+        workflowTaskTimeout: options.workflowTaskTimeout,
+        memo: options.memo,
+        searchAttributes: options.searchAttributes
+      });
+      logger.info("Workflow executed successfully", {
+        workflowType,
+        workflowId: options.workflowId
+      });
+      return result;
+    } catch (error) {
+      logger.error("Failed to execute workflow", {
+        workflowType,
+        workflowId: options.workflowId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+  * Get workflow handle by ID
+  */
+  async getWorkflowHandle(workflowId, runId) {
+    const client = await this.connect();
+    return client.workflow.getHandle(workflowId, runId);
+  }
+  /**
+  * Signal a running workflow
+  */
+  async signalWorkflow(workflowId, signalName, args) {
+    const handle = await this.getWorkflowHandle(workflowId);
+    try {
+      await handle.signal(signalName, args);
+      logger.info("Workflow signal sent", {
+        workflowId,
+        signalName
+      });
+    } catch (error) {
+      logger.error("Failed to signal workflow", {
+        workflowId,
+        signalName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+  * Query a running workflow
+  */
+  async queryWorkflow(workflowId, queryName, args) {
+    const handle = await this.getWorkflowHandle(workflowId);
+    try {
+      const result = await handle.query(queryName, args);
+      logger.debug("Workflow query executed", {
+        workflowId,
+        queryName
+      });
+      return result;
+    } catch (error) {
+      logger.error("Failed to query workflow", {
+        workflowId,
+        queryName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+  * Cancel a running workflow
+  */
+  async cancelWorkflow(workflowId) {
+    const handle = await this.getWorkflowHandle(workflowId);
+    try {
+      await handle.cancel();
+      logger.info("Workflow cancelled", {
+        workflowId
+      });
+    } catch (error) {
+      logger.error("Failed to cancel workflow", {
+        workflowId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+  * Terminate a running workflow
+  */
+  async terminateWorkflow(workflowId, reason) {
+    const handle = await this.getWorkflowHandle(workflowId);
+    try {
+      await handle.terminate(reason);
+      logger.info("Workflow terminated", {
+        workflowId,
+        reason
+      });
+    } catch (error) {
+      logger.error("Failed to terminate workflow", {
+        workflowId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+  * Describe a workflow execution
+  */
+  async describeWorkflow(workflowId) {
+    const handle = await this.getWorkflowHandle(workflowId);
+    try {
+      const description = await handle.describe();
+      logger.debug("Workflow described", {
+        workflowId,
+        status: description.status.name
+      });
+      return description;
+    } catch (error) {
+      logger.error("Failed to describe workflow", {
+        workflowId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+  * Get workflow result
+  */
+  async getWorkflowResult(workflowId) {
+    const handle = await this.getWorkflowHandle(workflowId);
+    try {
+      const result = await handle.result();
+      logger.info("Workflow result retrieved", {
+        workflowId
+      });
+      return result;
+    } catch (error) {
+      logger.error("Failed to get workflow result", {
+        workflowId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+  * Check if client is connected
+  */
+  isClientConnected() {
+    return this.isConnected;
+  }
+  /**
+  * Get configuration
+  */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+};
+var TemporalClientFactory = class {
+  static {
+    __name(this, "TemporalClientFactory");
+  }
+  /**
+  * Create a Temporal client for workspace modules
+  */
+  static createWorkspaceClient(config) {
+    const address = config?.address || process.env["TEMPORAL_WORKSPACE_URL"] || "localhost:7233";
+    const namespace = config?.namespace || process.env["TEMPORAL_NAMESPACE"] || "workspace-default";
+    const taskQueue = config?.taskQueue || process.env["TEMPORAL_TASK_QUEUE"];
+    return new TemporalClient({
+      address,
+      namespace,
+      taskQueue,
+      ...config
+    });
+  }
+  /**
+  * Create a Temporal client for tenant modules
+  */
+  static createTenantClient(config) {
+    const address = config?.address || process.env["TEMPORAL_TENANT_URL"] || "localhost:7233";
+    const namespace = config?.namespace || process.env["TEMPORAL_NAMESPACE"] || "tenant-default";
+    const taskQueue = config?.taskQueue || process.env["TEMPORAL_TASK_QUEUE"];
+    return new TemporalClient({
+      address,
+      namespace,
+      taskQueue,
+      ...config
+    });
+  }
+  /**
+  * Create a Temporal client from environment variables
+  * Automatically detects workspace vs tenant based on TEMPORAL_MODULE_TYPE
+  */
+  static createFromEnv() {
+    const moduleType = process.env["TEMPORAL_MODULE_TYPE"] || "workspace";
+    if (moduleType === "tenant") {
+      return this.createTenantClient();
+    }
+    return this.createWorkspaceClient();
+  }
+  // ========================================================================
+  // Layer-Aware Factory Methods
+  // ========================================================================
+  /**
+  * Create a Temporal client for a specific layer
+  *
+  * @param layer - Service layer ('wspace' or 'global')
+  * @param serviceName - Service name for identification
+  * @param config - Optional configuration overrides
+  * @returns Temporal client configured for the layer
+  *
+  * @example
+  * ```typescript
+  * const client = TemporalClientFactory.createClientForLayer('wspace', 'wspace-tags-svc');
+  * await client.connect();
+  * await client.startWorkflow('processTagUpdate', {
+  *   workflowId: 'tag-update-123',
+  *   taskQueue: 'wspace-tags-queue',
+  * });
+  * ```
+  */
+  static createClientForLayer(layer, serviceName, config) {
+    const envPrefix = layer.toUpperCase();
+    const defaults = DEFAULT_LAYER_RESOURCES[layer];
+    const address = config?.address || process.env[`${envPrefix}_TEMPORAL_ADDRESS`] || process.env["TEMPORAL_ADDRESS"] || defaults.temporalAddress;
+    const layerPrefix = `${layer}-`;
+    const derivedNamespace = `${layer}-${serviceName.replace(layerPrefix, "").replace("-svc", "")}`;
+    const namespace = config?.namespace || process.env[`${envPrefix}_TEMPORAL_NAMESPACE`] || process.env["TEMPORAL_NAMESPACE"] || derivedNamespace;
+    const taskQueue = config?.taskQueue || process.env[`${envPrefix}_TEMPORAL_TASK_QUEUE`] || process.env["TEMPORAL_TASK_QUEUE"] || `${serviceName}-queue`;
+    logger.info("[TemporalClientFactory] Creating layer client", {
+      layer,
+      serviceName,
+      address,
+      namespace,
+      taskQueue
+    });
+    return new TemporalClient({
+      address,
+      namespace,
+      taskQueue,
+      ...config
+    });
+  }
+  /**
+  * Create a Temporal client from layer environment detection
+  *
+  * @param serviceName - Service name for identification
+  * @returns Temporal client configured based on detected layer
+  */
+  static createFromLayerEnv(serviceName) {
+    const layer = process.env["SERVICE_LAYER"] || (serviceName.startsWith("global-") ? "global" : "wspace");
+    return this.createClientForLayer(layer, serviceName);
+  }
+};
+
+// src/temporal/worker.ts
+var temporalWorkerModule = null;
+async function getTemporalWorkerModule() {
+  if (!temporalWorkerModule) {
+    temporalWorkerModule = await import('@temporalio/worker');
+  }
+  return temporalWorkerModule;
+}
+__name(getTemporalWorkerModule, "getTemporalWorkerModule");
+var TemporalWorker = class {
+  static {
+    __name(this, "TemporalWorker");
+  }
+  worker = null;
+  connection = null;
+  config;
+  isRunning = false;
+  constructor(config) {
+    this.config = {
+      maxConcurrentWorkflowTaskExecutions: 100,
+      maxConcurrentActivityTaskExecutions: 100,
+      debugMode: false,
+      ...config
+    };
+  }
+  /**
+  * Start the worker
+  */
+  async start() {
+    if (this.isRunning) {
+      logger.warn("Worker already running", {
+        taskQueue: this.config.taskQueue
+      });
+      return;
+    }
+    try {
+      logger.info("Starting Temporal worker", {
+        address: this.config.address,
+        namespace: this.config.namespace,
+        taskQueue: this.config.taskQueue
+      });
+      const { Worker, NativeConnection } = await getTemporalWorkerModule();
+      this.connection = await NativeConnection.connect({
+        address: this.config.address,
+        tls: this.config.tls
+      });
+      this.worker = await Worker.create({
+        connection: this.connection,
+        namespace: this.config.namespace,
+        taskQueue: this.config.taskQueue,
+        workflowsPath: this.config.workflowsPath,
+        activities: this.config.activities,
+        maxConcurrentWorkflowTaskExecutions: this.config.maxConcurrentWorkflowTaskExecutions,
+        maxConcurrentActivityTaskExecutions: this.config.maxConcurrentActivityTaskExecutions
+      });
+      this.isRunning = true;
+      logger.info("Temporal worker started successfully", {
+        taskQueue: this.config.taskQueue,
+        workflowsPath: this.config.workflowsPath
+      });
+      await this.worker.run();
+    } catch (error) {
+      logger.error("Failed to start Temporal worker", {
+        error: error instanceof Error ? error.message : String(error),
+        taskQueue: this.config.taskQueue
+      });
+      throw error;
+    }
+  }
+  /**
+  * Stop the worker
+  */
+  async stop() {
+    if (!this.isRunning || !this.worker) {
+      logger.warn("Worker not running", {
+        taskQueue: this.config.taskQueue
+      });
+      return;
+    }
+    try {
+      logger.info("Stopping Temporal worker", {
+        taskQueue: this.config.taskQueue
+      });
+      this.worker.shutdown();
+      this.isRunning = false;
+      if (this.connection) {
+        await this.connection.close();
+        this.connection = null;
+      }
+      this.worker = null;
+      logger.info("Temporal worker stopped successfully", {
+        taskQueue: this.config.taskQueue
+      });
+    } catch (error) {
+      logger.error("Failed to stop Temporal worker", {
+        error: error instanceof Error ? error.message : String(error),
+        taskQueue: this.config.taskQueue
+      });
+      throw error;
+    }
+  }
+  /**
+  * Check if worker is running
+  */
+  isWorkerRunning() {
+    return this.isRunning;
+  }
+  /**
+  * Get worker configuration
+  */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+};
+var TemporalWorkerFactory = class {
+  static {
+    __name(this, "TemporalWorkerFactory");
+  }
+  /**
+  * Create a Temporal worker for workspace modules
+  */
+  static createWorkspaceWorker(config) {
+    const address = config.address || process.env["TEMPORAL_WORKSPACE_URL"] || "localhost:7233";
+    const namespace = config.namespace || process.env["TEMPORAL_NAMESPACE"] || "workspace-default";
+    const taskQueue = config.taskQueue || process.env["TEMPORAL_TASK_QUEUE"] || "workspace-default-tasks";
+    return new TemporalWorker({
+      address,
+      namespace,
+      taskQueue,
+      workflowsPath: config.workflowsPath,
+      activities: config.activities
+    });
+  }
+  /**
+  * Create a Temporal worker for tenant modules
+  */
+  static createTenantWorker(config) {
+    const address = config.address || process.env["TEMPORAL_TENANT_URL"] || "localhost:7233";
+    const namespace = config.namespace || process.env["TEMPORAL_NAMESPACE"] || "tenant-default";
+    const taskQueue = config.taskQueue || process.env["TEMPORAL_TASK_QUEUE"] || "tenant-default-tasks";
+    return new TemporalWorker({
+      address,
+      namespace,
+      taskQueue,
+      workflowsPath: config.workflowsPath,
+      activities: config.activities
+    });
+  }
+  /**
+  * Create a Temporal worker from environment variables
+  * Automatically detects workspace vs tenant based on TEMPORAL_MODULE_TYPE
+  */
+  static createFromEnv(config) {
+    const moduleType = process.env["TEMPORAL_MODULE_TYPE"] || "workspace";
+    if (moduleType === "tenant") {
+      return this.createTenantWorker(config);
+    }
+    return this.createWorkspaceWorker(config);
+  }
+};
+var TemporalWorkerManager = class {
+  static {
+    __name(this, "TemporalWorkerManager");
+  }
+  workers = /* @__PURE__ */ new Map();
+  /**
+  * Register a worker
+  */
+  registerWorker(name, worker) {
+    if (this.workers.has(name)) {
+      logger.warn("Worker already registered, replacing", {
+        name
+      });
+    }
+    this.workers.set(name, worker);
+  }
+  /**
+  * Start all registered workers
+  */
+  async startAll() {
+    logger.info("Starting all Temporal workers", {
+      count: this.workers.size
+    });
+    const startPromises = Array.from(this.workers.entries()).map(async ([name, worker]) => {
+      try {
+        await worker.start();
+        logger.info("Worker started", {
+          name
+        });
+      } catch (error) {
+        logger.error("Failed to start worker", {
+          name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    });
+    await Promise.all(startPromises);
+  }
+  /**
+  * Stop all registered workers
+  */
+  async stopAll() {
+    logger.info("Stopping all Temporal workers", {
+      count: this.workers.size
+    });
+    const stopPromises = Array.from(this.workers.entries()).map(async ([name, worker]) => {
+      try {
+        await worker.stop();
+        logger.info("Worker stopped", {
+          name
+        });
+      } catch (error) {
+        logger.error("Failed to stop worker", {
+          name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+    await Promise.all(stopPromises);
+  }
+  /**
+  * Get a worker by name
+  */
+  getWorker(name) {
+    return this.workers.get(name);
+  }
+  /**
+  * Remove a worker
+  */
+  removeWorker(name) {
+    return this.workers.delete(name);
+  }
+  /**
+  * Get all registered worker names
+  */
+  getWorkerNames() {
+    return Array.from(this.workers.keys());
+  }
+};
+
+// src/temporal/module.ts
+var TemporalModule = class _TemporalModule {
+  static {
+    __name(this, "TemporalModule");
+  }
+  client;
+  workerManager;
+  config;
+  constructor(config) {
+    this.config = {
+      autoConnect: true,
+      ...config
+    };
+    if (config.moduleType === "tenant") {
+      this.client = TemporalClientFactory.createTenantClient({
+        address: config.address,
+        namespace: config.namespace,
+        taskQueue: config.taskQueue
+      });
+    } else {
+      this.client = TemporalClientFactory.createWorkspaceClient({
+        address: config.address,
+        namespace: config.namespace,
+        taskQueue: config.taskQueue
+      });
+    }
+    this.workerManager = new TemporalWorkerManager();
+    if (this.config.autoConnect) {
+      this.initialize();
+    }
+  }
+  /**
+  * Initialize the Temporal module (connect client)
+  * This is called automatically if autoConnect is true
+  */
+  initialize() {
+    this.client.connect().catch((error) => {
+      logger.error("Failed to auto-connect to Temporal", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  }
+  /**
+  * Get the Temporal client
+  */
+  getClient() {
+    return this.client;
+  }
+  /**
+  * Get the worker manager
+  */
+  getWorkerManager() {
+    return this.workerManager;
+  }
+  /**
+  * Create and register a worker
+  */
+  createWorker(config) {
+    const worker = this.config.moduleType === "tenant" ? TemporalWorkerFactory.createTenantWorker({
+      workflowsPath: config.workflowsPath,
+      activities: config.activities,
+      taskQueue: config.taskQueue,
+      namespace: this.config.namespace,
+      address: this.config.address
+    }) : TemporalWorkerFactory.createWorkspaceWorker({
+      workflowsPath: config.workflowsPath,
+      activities: config.activities,
+      taskQueue: config.taskQueue,
+      namespace: this.config.namespace,
+      address: this.config.address
+    });
+    this.workerManager.registerWorker(config.name, worker);
+    return worker;
+  }
+  /**
+  * Start all registered workers
+  */
+  async startWorkers() {
+    await this.workerManager.startAll();
+  }
+  /**
+  * Stop all registered workers
+  */
+  async stopWorkers() {
+    await this.workerManager.stopAll();
+  }
+  /**
+  * Disconnect from Temporal
+  */
+  async disconnect() {
+    await this.client.disconnect();
+  }
+  /**
+  * Get module configuration
+  */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+  /**
+  * Create a Temporal module from environment variables
+  */
+  static fromEnv() {
+    const moduleType = process.env["TEMPORAL_MODULE_TYPE"] || "workspace";
+    const address = moduleType === "tenant" ? process.env["TEMPORAL_TENANT_URL"] || "localhost:7233" : process.env["TEMPORAL_WORKSPACE_URL"] || "localhost:7233";
+    const namespace = process.env["TEMPORAL_NAMESPACE"];
+    const taskQueue = process.env["TEMPORAL_TASK_QUEUE"];
+    return new _TemporalModule({
+      moduleType,
+      address,
+      namespace,
+      taskQueue
+    });
+  }
+};
+
+export { TemporalClient, TemporalClientFactory, TemporalModule, TemporalWorker, TemporalWorkerFactory, TemporalWorkerManager };
+//# sourceMappingURL=chunk-Z4IRLBWO.js.map
+//# sourceMappingURL=chunk-Z4IRLBWO.js.map