@digilogiclabs/platform-core 1.0.0 → 1.1.1

package/dist/testing.mjs

@@ -329,65 +329,631 @@ var MemoryEmail = class {
   }
 };
 
+// src/interfaces/IQueue.ts
+function calculateBackoff(attempt, options) {
+  if (options.type === "fixed") {
+    return options.delay;
+  }
+  const delay = options.delay * Math.pow(2, attempt - 1);
+  const maxDelay = options.maxDelay ?? options.delay * 32;
+  return Math.min(delay, maxDelay);
+}
+function generateJobId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `job_${timestamp}_${random}`;
+}
+
+// src/context/CorrelationContext.ts
+import { AsyncLocalStorage } from "async_hooks";
+var CorrelationContextManager = class {
+  storage = new AsyncLocalStorage();
+  idGenerator;
+  constructor() {
+    this.idGenerator = () => {
+      const timestamp = Date.now().toString(36);
+      const random = Math.random().toString(36).substring(2, 10);
+      return `${timestamp}-${random}`;
+    };
+  }
+  /**
+   * Set custom ID generator
+   */
+  setIdGenerator(generator) {
+    this.idGenerator = generator;
+  }
+  /**
+   * Generate a new ID
+   */
+  generateId() {
+    return this.idGenerator();
+  }
+  /**
+   * Run a function with correlation context
+   */
+  run(data, fn) {
+    return this.storage.run(
+      {
+        ...data,
+        startTime: data.startTime ?? Date.now()
+      },
+      fn
+    );
+  }
+  /**
+   * Run an async function with correlation context
+   */
+  async runAsync(data, fn) {
+    return this.storage.run(
+      {
+        ...data,
+        startTime: data.startTime ?? Date.now()
+      },
+      fn
+    );
+  }
+  /**
+   * Get current correlation data
+   */
+  get() {
+    return this.storage.getStore();
+  }
+  /**
+   * Get current correlation data or empty object
+   */
+  getOrEmpty() {
+    return this.storage.getStore() ?? {};
+  }
+  /**
+   * Get trace ID from current context
+   */
+  getTraceId() {
+    return this.get()?.traceId;
+  }
+  /**
+   * Get correlation ID from current context
+   */
+  getCorrelationId() {
+    return this.get()?.correlationId ?? this.get()?.traceId;
+  }
+  /**
+   * Get request ID from current context
+   */
+  getRequestId() {
+    return this.get()?.requestId;
+  }
+  /**
+   * Get user ID from current context
+   */
+  getUserId() {
+    return this.get()?.userId;
+  }
+  /**
+   * Get tenant ID from current context
+   */
+  getTenantId() {
+    return this.get()?.tenantId;
+  }
+  /**
+   * Check if we're in a correlation context
+   */
+  isInContext() {
+    return this.storage.getStore() !== void 0;
+  }
+  /**
+   * Update current context (merge data)
+   * Note: This doesn't actually update the store, but returns merged data
+   * for use in nested contexts
+   */
+  extend(data) {
+    const current = this.get() ?? {};
+    return {
+      ...current,
+      ...data,
+      metadata: {
+        ...current.metadata,
+        ...data.metadata
+      }
+    };
+  }
+  /**
+   * Run a nested context with extended data
+   */
+  runNested(data, fn) {
+    return this.run(this.extend(data), fn);
+  }
+  /**
+   * Run a nested async context with extended data
+   */
+  async runNestedAsync(data, fn) {
+    return this.runAsync(this.extend(data), fn);
+  }
+  /**
+   * Get context as log metadata (for structured logging)
+   */
+  getLogMeta() {
+    const ctx = this.get();
+    if (!ctx) return {};
+    const meta = {};
+    if (ctx.traceId) meta.traceId = ctx.traceId;
+    if (ctx.spanId) meta.spanId = ctx.spanId;
+    if (ctx.requestId) meta.requestId = ctx.requestId;
+    if (ctx.correlationId) meta.correlationId = ctx.correlationId;
+    if (ctx.userId) meta.userId = ctx.userId;
+    if (ctx.tenantId) meta.tenantId = ctx.tenantId;
+    if (ctx.sessionId) meta.sessionId = ctx.sessionId;
+    if (ctx.operation) meta.operation = ctx.operation;
+    return meta;
+  }
+  /**
+   * Get context as HTTP headers (for propagation)
+   */
+  getHeaders() {
+    const ctx = this.get();
+    if (!ctx) return {};
+    const headers = {};
+    if (ctx.traceId) {
+      const spanId = ctx.spanId ?? this.generateId().substring(0, 16);
+      headers["traceparent"] = `00-${ctx.traceId}-${spanId}-01`;
+    }
+    if (ctx.requestId) {
+      headers["x-request-id"] = ctx.requestId;
+    }
+    if (ctx.correlationId) {
+      headers["x-correlation-id"] = ctx.correlationId;
+    }
+    return headers;
+  }
+  /**
+   * Parse context from HTTP headers
+   */
+  parseHeaders(headers) {
+    const data = {};
+    const traceparent = headers["traceparent"];
+    if (traceparent && typeof traceparent === "string") {
+      const parts = traceparent.split("-");
+      if (parts.length >= 3 && parts[0] === "00") {
+        data.traceId = parts[1];
+        data.spanId = parts[2];
+      }
+    }
+    const requestId = headers["x-request-id"];
+    if (requestId) {
+      data.requestId = Array.isArray(requestId) ? requestId[0] : requestId;
+    }
+    const correlationId = headers["x-correlation-id"];
+    if (correlationId) {
+      data.correlationId = Array.isArray(correlationId) ? correlationId[0] : correlationId;
+    }
+    return data;
+  }
+  /**
+   * Get elapsed time since context start (ms)
+   */
+  getElapsed() {
+    const ctx = this.get();
+    if (!ctx?.startTime) return 0;
+    return Date.now() - ctx.startTime;
+  }
+  /**
+   * Create a child span context
+   */
+  createChildSpan(operation) {
+    const current = this.get() ?? {};
+    return {
+      ...current,
+      spanId: this.generateId().substring(0, 16),
+      operation,
+      startTime: Date.now()
+    };
+  }
+};
+var correlationContext = new CorrelationContextManager();
+var runWithContext = correlationContext.run.bind(correlationContext);
+var runWithContextAsync = correlationContext.runAsync.bind(correlationContext);
+var getContext = correlationContext.get.bind(correlationContext);
+var getTraceId = correlationContext.getTraceId.bind(correlationContext);
+var getCorrelationId = correlationContext.getCorrelationId.bind(correlationContext);
+var getRequestId = correlationContext.getRequestId.bind(correlationContext);
+var getUserId = correlationContext.getUserId.bind(correlationContext);
+var getTenantId = correlationContext.getTenantId.bind(correlationContext);
+var getLogMeta = correlationContext.getLogMeta.bind(correlationContext);
+var isInContext = correlationContext.isInContext.bind(correlationContext);
+function createJobContext(job) {
+  return {
+    correlationId: job.correlationId ?? job.id,
+    traceId: correlationContext.generateId(),
+    operation: `job:${job.name}`,
+    metadata: job.metadata,
+    startTime: Date.now()
+  };
+}
+
 // src/adapters/memory/MemoryQueue.ts
 var MemoryQueue = class {
-  jobs = [];
+  jobs = /* @__PURE__ */ new Map();
   handlers = [];
+  eventHandlers = /* @__PURE__ */ new Map();
+  paused = false;
+  processingConcurrency = 1;
+  activeCount = 0;
+  repeatIntervals = /* @__PURE__ */ new Map();
+  queueName;
+  processingQueue = [];
+  isProcessing = false;
+  constructor(name = "default") {
+    this.queueName = name;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // CORE METHODS (IQueue interface)
+  // ═══════════════════════════════════════════════════════════════
   async add(name, data, options) {
-    const job = { id: "job_" + this.jobs.length, name, data, attemptsMade: 0, progress: 0, timestamp: Date.now() };
-    this.jobs.push(job);
-    this.handlers.forEach((h) => h(job));
-    return job;
+    const jobId = options?.jobId || generateJobId();
+    const now = Date.now();
+    const job = {
+      id: jobId,
+      name,
+      data,
+      attemptsMade: 0,
+      progress: 0,
+      timestamp: now,
+      state: options?.delay ? "delayed" : "waiting",
+      correlationId: options?.correlationId,
+      metadata: options?.metadata,
+      options
+    };
+    this.jobs.set(jobId, job);
+    if (options?.delay && options.delay > 0) {
+      setTimeout(() => {
+        const j = this.jobs.get(jobId);
+        if (j && j.state === "delayed") {
+          j.state = "waiting";
+          this.processNext();
+        }
+      }, options.delay);
+    } else {
+      this.processNext();
+    }
+    return this.toPublicJob(job);
   }
   async addBulk(jobs) {
     return Promise.all(jobs.map((j) => this.add(j.name, j.data, j.options)));
   }
-  process(handler) {
+  process(handler, options) {
     this.handlers.push(handler);
+    if (options?.concurrency) {
+      this.processingConcurrency = options.concurrency;
+    }
+    this.processNext();
   }
   async getJob(id) {
-    return this.jobs.find((j) => j.id === id) || null;
+    const job = this.jobs.get(id);
+    return job ? this.toPublicJob(job) : null;
   }
   async removeJob(id) {
-    this.jobs = this.jobs.filter((j) => j.id !== id);
+    this.jobs.delete(id);
   }
   async pause() {
+    this.paused = true;
   }
   async resume() {
+    this.paused = false;
+    this.processNext();
   }
   async getStats() {
-    return { waiting: 0, active: 0, completed: this.jobs.length, failed: 0, delayed: 0 };
+    const stats = {
+      waiting: 0,
+      active: 0,
+      completed: 0,
+      failed: 0,
+      delayed: 0
+    };
+    for (const job of this.jobs.values()) {
+      switch (job.state) {
+        case "waiting":
+          stats.waiting++;
+          break;
+        case "active":
+          stats.active++;
+          break;
+        case "completed":
+          stats.completed++;
+          break;
+        case "failed":
+          stats.failed++;
+          break;
+        case "delayed":
+          stats.delayed++;
+          break;
+      }
+    }
+    return stats;
   }
   async healthCheck() {
     return true;
   }
   async close() {
-    this.jobs = [];
+    for (const interval of this.repeatIntervals.values()) {
+      clearInterval(interval);
+    }
+    this.repeatIntervals.clear();
+    this.jobs.clear();
+    this.handlers = [];
+    this.eventHandlers.clear();
+    this.paused = true;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // OPTIONAL METHODS (new in enhanced interface)
+  // ═══════════════════════════════════════════════════════════════
+  async addRecurring(name, data, repeat, options) {
+    const repeatKey = `repeat:${name}:${Date.now()}`;
+    const job = await this.add(name, data, { ...options, jobId: repeatKey });
+    const internalJob = this.jobs.get(repeatKey);
+    if (internalJob) {
+      internalJob.repeatKey = repeatKey;
+    }
+    if (repeat.every) {
+      let execCount = 0;
+      const interval = setInterval(async () => {
+        if (repeat.limit && execCount >= repeat.limit) {
+          clearInterval(interval);
+          this.repeatIntervals.delete(repeatKey);
+          return;
+        }
+        execCount++;
+        await this.add(name, data, options);
+      }, repeat.every);
+      this.repeatIntervals.set(repeatKey, interval);
+    }
+    if (repeat.cron) {
+      console.warn(
+        "MemoryQueue: Cron expressions not supported, use 'every' for intervals"
+      );
+    }
+    return job;
+  }
+  async getJobs(state, start = 0, end = -1) {
+    const states = Array.isArray(state) ? state : [state];
+    const filtered = Array.from(this.jobs.values()).filter((j) => states.includes(j.state || "waiting")).sort((a, b) => a.timestamp - b.timestamp);
+    const endIndex = end === -1 ? filtered.length : end + 1;
+    return filtered.slice(start, endIndex).map((j) => this.toPublicJob(j));
+  }
+  async getFailedJobs(start = 0, end = -1) {
+    return this.getJobs("failed", start, end);
+  }
+  async retryJob(id) {
+    const job = this.jobs.get(id);
+    if (!job || job.state !== "failed") {
+      return;
+    }
+    job.state = "waiting";
+    job.attemptsMade = 0;
+    job.failedReason = void 0;
+    this.processNext();
+  }
+  async replayAllFailed() {
+    const failedJobs = Array.from(this.jobs.values()).filter(
+      (j) => j.state === "failed"
+    );
+    for (const job of failedJobs) {
+      job.state = "waiting";
+      job.attemptsMade = 0;
+      job.failedReason = void 0;
+    }
+    this.processNext();
+    return failedJobs.length;
+  }
+  async updateProgress(id, progress) {
+    const job = this.jobs.get(id);
+    if (job) {
+      job.progress = Math.min(100, Math.max(0, progress));
+      this.emitEvent("progress", job, { progress });
+    }
+  }
+  async clean(grace, limit, state) {
+    const now = Date.now();
+    const removed = [];
+    for (const [id, job] of this.jobs.entries()) {
+      if (removed.length >= limit) break;
+      if (job.state === state) {
+        const finishedTime = job.finishedOn || job.timestamp;
+        if (now - finishedTime > grace) {
+          this.jobs.delete(id);
+          removed.push(id);
+        }
+      }
+    }
+    return removed;
+  }
+  async obliterate(options) {
+    for (const interval of this.repeatIntervals.values()) {
+      clearInterval(interval);
+    }
+    this.repeatIntervals.clear();
+    this.jobs.clear();
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
   }
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  getName() {
+    return this.queueName;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // TESTING UTILITIES (not part of IQueue interface)
+  // ═══════════════════════════════════════════════════════════════
   /**
    * Clear all jobs (for testing)
    */
   clear() {
-    this.jobs = [];
+    for (const interval of this.repeatIntervals.values()) {
+      clearInterval(interval);
+    }
+    this.repeatIntervals.clear();
+    this.jobs.clear();
     this.handlers = [];
+    this.paused = false;
+    this.activeCount = 0;
   }
   /**
-   * Get all jobs (for testing)
+   * Get all jobs regardless of state (for testing)
    */
-  getJobs() {
-    return this.jobs;
+  getAllJobs() {
+    return Array.from(this.jobs.values()).map((j) => this.toPublicJob(j));
   }
   /**
-   * Get pending jobs (for testing)
+   * Get pending (waiting) jobs (for testing)
    */
   getPendingJobs() {
-    return this.jobs.filter((j) => j.progress < 100);
+    return Array.from(this.jobs.values()).filter((j) => j.state === "waiting").map((j) => this.toPublicJob(j));
   }
   /**
    * Get number of jobs (for testing)
    */
   get size() {
-    return this.jobs.length;
+    return this.jobs.size;
+  }
+  /**
+   * Wait for all jobs to complete (for testing)
+   */
+  async drain(timeout = 5e3) {
+    const start = Date.now();
+    while (this.activeCount > 0 || this.hasWaitingJobs()) {
+      if (Date.now() - start > timeout) {
+        throw new Error("Queue drain timeout");
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE METHODS
+  // ═══════════════════════════════════════════════════════════════
+  hasWaitingJobs() {
+    for (const job of this.jobs.values()) {
+      if (job.state === "waiting") return true;
+    }
+    return false;
+  }
+  async processNext() {
+    if (this.paused || this.handlers.length === 0 || this.isProcessing) {
+      return;
+    }
+    if (this.activeCount >= this.processingConcurrency) {
+      return;
+    }
+    let nextJob;
+    for (const job of this.jobs.values()) {
+      if (job.state === "waiting") {
+        nextJob = job;
+        break;
+      }
+    }
+    if (!nextJob) {
+      return;
+    }
+    this.activeCount++;
+    nextJob.state = "active";
+    nextJob.processedOn = Date.now();
+    this.emitEvent("active", nextJob);
+    try {
+      for (const handler of this.handlers) {
+        await this.executeWithTimeout(handler, nextJob);
+      }
+      nextJob.state = "completed";
+      nextJob.finishedOn = Date.now();
+      nextJob.progress = 100;
+      this.emitEvent("completed", nextJob);
+      if (nextJob.options?.removeOnComplete === true) {
+        this.jobs.delete(nextJob.id);
+      }
+    } catch (error) {
+      await this.handleJobFailure(nextJob, error);
+    } finally {
+      this.activeCount--;
+      setImmediate(() => this.processNext());
+    }
+  }
+  async executeWithTimeout(handler, job) {
+    const timeout = job.options?.timeout;
+    const publicJob = this.toPublicJob(job);
+    const jobContext = createJobContext({
+      id: job.id,
+      name: job.name,
+      correlationId: job.correlationId,
+      metadata: job.metadata
+    });
+    const executeHandler = () => runWithContext(jobContext, () => handler(publicJob));
+    if (!timeout) {
+      await executeHandler();
+      return;
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Job timeout")), timeout);
+    });
+    await Promise.race([executeHandler(), timeoutPromise]);
+  }
+  async handleJobFailure(job, error) {
+    job.attemptsMade++;
+    const maxAttempts = job.options?.attempts || 1;
+    if (job.attemptsMade < maxAttempts) {
+      job.state = "delayed";
+      const backoffDelay = job.options?.backoff ? calculateBackoff(job.attemptsMade, job.options.backoff) : 1e3;
+      setTimeout(() => {
+        const j = this.jobs.get(job.id);
+        if (j && j.state === "delayed") {
+          j.state = "waiting";
+          this.processNext();
+        }
+      }, backoffDelay);
+    } else {
+      job.state = "failed";
+      job.finishedOn = Date.now();
+      job.failedReason = error.message;
+      this.emitEvent("failed", job, { error });
+      if (job.options?.removeOnFail === true) {
+        this.jobs.delete(job.id);
+      }
+    }
+  }
+  emitEvent(type, job, extra) {
+    const handlers = this.eventHandlers.get(type);
+    if (!handlers) return;
+    const event = {
+      type,
+      job: this.toPublicJob(job),
+      timestamp: Date.now(),
+      ...extra
+    };
+    for (const handler of handlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  toPublicJob(job) {
+    return {
+      id: job.id,
+      name: job.name,
+      data: job.data,
+      attemptsMade: job.attemptsMade,
+      progress: job.progress,
+      timestamp: job.timestamp,
+      state: job.state,
+      processedOn: job.processedOn,
+      finishedOn: job.finishedOn,
+      failedReason: job.failedReason,
+      correlationId: job.correlationId,
+      metadata: job.metadata
+    };
   }
 };
 
@@ -1078,7 +1644,11 @@ var MemoryTracing = class {
     return Math.random().toString(16).substring(2, 34).padStart(32, "0");
   }
   startSpan(name, options) {
-    const span = new MemorySpan(name, this.traceId, this.currentSpan?.context.spanId);
+    const span = new MemorySpan(
+      name,
+      this.traceId,
+      this.currentSpan?.context.spanId
+    );
     if (options?.attributes) {
       span.setAttributes(options.attributes);
     }
@@ -1096,7 +1666,9 @@ var MemoryTracing = class {
       span.setStatus({ code: "ok" });
       return result;
     } catch (error) {
-      span.recordException(error instanceof Error ? error : new Error(String(error)));
+      span.recordException(
+        error instanceof Error ? error : new Error(String(error))
+      );
       throw error;
     } finally {
       span.end();
@@ -1109,7 +1681,9 @@ var MemoryTracing = class {
       span.setStatus({ code: "ok" });
       return result;
     } catch (error) {
-      span.recordException(error instanceof Error ? error : new Error(String(error)));
+      span.recordException(
+        error instanceof Error ? error : new Error(String(error))
+      );
       throw error;
     } finally {
       span.end();