@parsrun/service 0.1.0

package/dist/transports/cloudflare/index.js

@@ -0,0 +1,746 @@
+// src/transports/cloudflare/binding.ts
+import { createLogger } from "@parsrun/core";
+
+// src/serialization/index.ts
+var jsonSerializer = {
+  encode(data) {
+    return JSON.stringify(data);
+  },
+  decode(raw) {
+    if (raw instanceof ArrayBuffer) {
+      const decoder = new TextDecoder();
+      return JSON.parse(decoder.decode(raw));
+    }
+    return JSON.parse(raw);
+  },
+  contentType: "application/json"
+};
+
+// src/rpc/errors.ts
+import { ParsError } from "@parsrun/core";
+var RpcError = class extends ParsError {
+  retryable;
+  retryAfter;
+  constructor(message, code, statusCode = 500, options) {
+    super(message, code, statusCode, options?.details);
+    this.name = "RpcError";
+    this.retryable = options?.retryable ?? false;
+    if (options?.retryAfter !== void 0) {
+      this.retryAfter = options.retryAfter;
+    }
+  }
+};
+var TransportError = class extends RpcError {
+  constructor(message, cause) {
+    const options = {
+      retryable: true
+    };
+    if (cause) {
+      options.details = { cause: cause.message };
+    }
+    super(message, "TRANSPORT_ERROR", 502, options);
+    this.name = "TransportError";
+  }
+};
+var SerializationError = class extends RpcError {
+  constructor(message, cause) {
+    const options = {
+      retryable: false
+    };
+    if (cause) {
+      options.details = { cause: cause.message };
+    }
+    super(message, "SERIALIZATION_ERROR", 400, options);
+    this.name = "SerializationError";
+  }
+};
+
+// src/rpc/transports/http.ts
+function parseTraceparent(header) {
+  const parts = header.split("-");
+  if (parts.length !== 4) {
+    return null;
+  }
+  const [version, traceId, spanId, flags] = parts;
+  if (version !== "00" || !traceId || !spanId || !flags) {
+    return null;
+  }
+  if (traceId.length !== 32 || spanId.length !== 16 || flags.length !== 2) {
+    return null;
+  }
+  return {
+    traceId,
+    spanId,
+    traceFlags: parseInt(flags, 16)
+  };
+}
+
+// src/transports/cloudflare/binding.ts
+var ServiceBindingTransport = class {
+  name = "service-binding";
+  serviceName;
+  binding;
+  serializer;
+  logger;
+  constructor(options) {
+    this.serviceName = options.serviceName;
+    this.binding = options.binding;
+    this.serializer = options.serializer ?? jsonSerializer;
+    this.logger = options.logger ?? createLogger({ name: `binding:${options.serviceName}` });
+  }
+  async call(request) {
+    const startTime = Date.now();
+    try {
+      let body;
+      try {
+        body = this.serializer.encode(request);
+      } catch (error) {
+        throw new SerializationError(
+          "Failed to serialize request",
+          error instanceof Error ? error : void 0
+        );
+      }
+      const headers = {
+        "Content-Type": this.serializer.contentType,
+        Accept: this.serializer.contentType,
+        "X-Request-ID": request.id,
+        "X-Service": request.service,
+        "X-Method": request.method,
+        "X-Method-Type": request.type
+      };
+      if (request.version) {
+        headers["X-Service-Version"] = request.version;
+      }
+      if (request.traceContext) {
+        headers["traceparent"] = formatTraceparent(request.traceContext);
+        if (request.traceContext.traceState) {
+          headers["tracestate"] = request.traceContext.traceState;
+        }
+      }
+      if (request.metadata?.tenantId) {
+        headers["X-Tenant-ID"] = String(request.metadata.tenantId);
+      }
+      const response = await this.binding.fetch("http://internal/rpc", {
+        method: "POST",
+        headers,
+        body: typeof body === "string" ? body : body
+      });
+      let responseData;
+      try {
+        const contentType = response.headers.get("Content-Type") ?? "";
+        if (contentType.includes("msgpack")) {
+          const buffer = await response.arrayBuffer();
+          responseData = this.serializer.decode(buffer);
+        } else {
+          const text = await response.text();
+          responseData = this.serializer.decode(text);
+        }
+      } catch (error) {
+        throw new SerializationError(
+          "Failed to deserialize response",
+          error instanceof Error ? error : void 0
+        );
+      }
+      const duration = Date.now() - startTime;
+      this.logger.debug(`RPC call completed`, {
+        service: this.serviceName,
+        method: request.method,
+        durationMs: duration,
+        success: responseData.success
+      });
+      return responseData;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      if (error instanceof SerializationError) {
+        throw error;
+      }
+      this.logger.error(`RPC call failed`, error, {
+        service: this.serviceName,
+        method: request.method,
+        durationMs: duration
+      });
+      throw new TransportError(
+        `Service binding call failed: ${error.message}`,
+        error
+      );
+    }
+  }
+  async close() {
+  }
+};
+function createServiceBindingTransport(options) {
+  return new ServiceBindingTransport(options);
+}
+function createServiceBindingHandler(server, options) {
+  const serializer = options?.serializer ?? jsonSerializer;
+  const logger = options?.logger ?? createLogger({ name: "binding-handler" });
+  return async (request) => {
+    const url = new URL(request.url);
+    if (request.method !== "POST" || url.pathname !== "/rpc") {
+      return new Response("Not Found", { status: 404 });
+    }
+    try {
+      const contentType = request.headers.get("Content-Type") ?? "";
+      let body;
+      if (contentType.includes("msgpack")) {
+        const buffer = await request.arrayBuffer();
+        body = serializer.decode(buffer);
+      } else {
+        const text = await request.text();
+        body = serializer.decode(text);
+      }
+      const traceparent = request.headers.get("traceparent");
+      if (traceparent) {
+        const parsedTrace = parseTraceparent(traceparent);
+        if (parsedTrace) {
+          body.traceContext = parsedTrace;
+          const tracestate = request.headers.get("tracestate");
+          if (tracestate) {
+            body.traceContext.traceState = tracestate;
+          }
+        }
+      }
+      const tenantId = request.headers.get("X-Tenant-ID");
+      if (tenantId) {
+        body.metadata = { ...body.metadata, tenantId };
+      }
+      const response = await server.handle(body);
+      const responseBody = serializer.encode(response);
+      return new Response(
+        typeof responseBody === "string" ? responseBody : responseBody,
+        {
+          status: response.success ? 200 : getHttpStatus(response.error?.code),
+          headers: {
+            "Content-Type": serializer.contentType,
+            "X-Request-ID": body.id
+          }
+        }
+      );
+    } catch (error) {
+      logger.error("Handler error", error);
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error: {
+            code: "INTERNAL_ERROR",
+            message: error.message
+          }
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+  };
+}
+function formatTraceparent(ctx) {
+  const flags = ctx.traceFlags.toString(16).padStart(2, "0");
+  return `00-${ctx.traceId}-${ctx.spanId}-${flags}`;
+}
+function getHttpStatus(code) {
+  switch (code) {
+    case "METHOD_NOT_FOUND":
+    case "SERVICE_NOT_FOUND":
+      return 404;
+    case "VERSION_MISMATCH":
+    case "VALIDATION_ERROR":
+      return 400;
+    case "UNAUTHORIZED":
+      return 401;
+    case "FORBIDDEN":
+      return 403;
+    case "TIMEOUT":
+      return 504;
+    case "CIRCUIT_OPEN":
+    case "BULKHEAD_REJECTED":
+      return 503;
+    default:
+      return 500;
+  }
+}
+
+// src/transports/cloudflare/queue.ts
+import { createLogger as createLogger3 } from "@parsrun/core";
+
+// src/events/format.ts
+import { generateId } from "@parsrun/core";
+function toCompactEvent(event) {
+  const compact = {
+    e: event.type,
+    s: event.source,
+    i: event.id,
+    t: new Date(event.time).getTime(),
+    d: event.data
+  };
+  if (event.parstracecontext) compact.ctx = event.parstracecontext;
+  if (event.parstenantid) compact.tid = event.parstenantid;
+  return compact;
+}
+function fromCompactEvent(compact, source) {
+  const event = {
+    specversion: "1.0",
+    type: compact.e,
+    source: source ?? compact.s,
+    id: compact.i,
+    time: new Date(compact.t).toISOString(),
+    datacontenttype: "application/json",
+    data: compact.d
+  };
+  if (compact.ctx) event.parstracecontext = compact.ctx;
+  if (compact.tid) event.parstenantid = compact.tid;
+  return event;
+}
+function matchEventType(type, pattern) {
+  if (pattern === "*" || pattern === "**") {
+    return true;
+  }
+  const typeParts = type.split(".");
+  const patternParts = pattern.split(".");
+  let ti = 0;
+  let pi = 0;
+  while (ti < typeParts.length && pi < patternParts.length) {
+    const pp = patternParts[pi];
+    if (pp === "**") {
+      if (pi === patternParts.length - 1) {
+        return true;
+      }
+      for (let i = ti; i <= typeParts.length; i++) {
+        const remaining = typeParts.slice(i).join(".");
+        const remainingPattern = patternParts.slice(pi + 1).join(".");
+        if (matchEventType(remaining, remainingPattern)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    if (pp === "*") {
+      ti++;
+      pi++;
+      continue;
+    }
+    if (pp !== typeParts[ti]) {
+      return false;
+    }
+    ti++;
+    pi++;
+  }
+  return ti === typeParts.length && pi === patternParts.length;
+}
+
+// src/events/handler.ts
+import { createLogger as createLogger2 } from "@parsrun/core";
+var EventHandlerRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  logger;
+  deadLetterQueue;
+  defaultOptions;
+  constructor(options = {}) {
+    this.logger = options.logger ?? createLogger2({ name: "event-handler" });
+    if (options.deadLetterQueue) {
+      this.deadLetterQueue = options.deadLetterQueue;
+    }
+    const defaultOpts = {
+      retries: options.defaultOptions?.retries ?? 3,
+      backoff: options.defaultOptions?.backoff ?? "exponential",
+      maxDelay: options.defaultOptions?.maxDelay ?? 3e4,
+      onExhausted: options.defaultOptions?.onExhausted ?? "log"
+    };
+    if (options.defaultOptions?.deadLetter) {
+      defaultOpts.deadLetter = options.defaultOptions.deadLetter;
+    }
+    this.defaultOptions = defaultOpts;
+  }
+  /**
+   * Register an event handler
+   */
+  register(pattern, handler, options) {
+    const registration = {
+      pattern,
+      handler,
+      options: {
+        ...this.defaultOptions,
+        ...options
+      }
+    };
+    const handlers = this.handlers.get(pattern) ?? [];
+    handlers.push(registration);
+    this.handlers.set(pattern, handlers);
+    this.logger.debug(`Handler registered for pattern: ${pattern}`);
+    return () => {
+      const currentHandlers = this.handlers.get(pattern);
+      if (currentHandlers) {
+        const index = currentHandlers.indexOf(registration);
+        if (index !== -1) {
+          currentHandlers.splice(index, 1);
+          if (currentHandlers.length === 0) {
+            this.handlers.delete(pattern);
+          }
+          this.logger.debug(`Handler unregistered for pattern: ${pattern}`);
+        }
+      }
+    };
+  }
+  /**
+   * Handle an event
+   */
+  async handle(event) {
+    const matchingHandlers = this.getMatchingHandlers(event.type);
+    if (matchingHandlers.length === 0) {
+      this.logger.debug(`No handlers for event type: ${event.type}`, {
+        eventId: event.id
+      });
+      return;
+    }
+    this.logger.debug(`Handling event: ${event.type}`, {
+      eventId: event.id,
+      handlerCount: matchingHandlers.length
+    });
+    const results = await Promise.allSettled(
+      matchingHandlers.map((reg) => this.executeHandler(event, reg))
+    );
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result?.status === "rejected") {
+        this.logger.error(
+          `Handler failed for ${event.type}`,
+          result.reason,
+          { eventId: event.id, pattern: matchingHandlers[i]?.pattern }
+        );
+      }
+    }
+  }
+  /**
+   * Execute a single handler with retry logic
+   */
+  async executeHandler(event, registration) {
+    const { handler, options } = registration;
+    const maxAttempts = options.retries + 1;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const context = {
+          logger: this.logger.child({
+            eventId: event.id,
+            pattern: registration.pattern,
+            attempt
+          }),
+          attempt,
+          maxAttempts,
+          isRetry: attempt > 1
+        };
+        if (event.parstracecontext) {
+          const traceCtx = parseTraceContext(event.parstracecontext);
+          if (traceCtx) {
+            context.traceContext = traceCtx;
+          }
+        }
+        await handler(event, context);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (attempt < maxAttempts) {
+          const delay = this.calculateBackoff(attempt, options);
+          this.logger.warn(
+            `Handler failed, retrying in ${delay}ms`,
+            { eventId: event.id, attempt, maxAttempts }
+          );
+          await sleep(delay);
+        }
+      }
+    }
+    await this.handleExhausted(event, registration, lastError);
+  }
+  /**
+   * Calculate backoff delay
+   */
+  calculateBackoff(attempt, options) {
+    const baseDelay = 100;
+    if (options.backoff === "exponential") {
+      return Math.min(baseDelay * Math.pow(2, attempt - 1), options.maxDelay);
+    }
+    return Math.min(baseDelay * attempt, options.maxDelay);
+  }
+  /**
+   * Handle exhausted retries
+   */
+  async handleExhausted(event, registration, error) {
+    const { options } = registration;
+    if (options.deadLetter && this.deadLetterQueue) {
+      await this.deadLetterQueue.add({
+        event,
+        error: error.message,
+        pattern: registration.pattern,
+        attempts: options.retries + 1
+      });
+    }
+    switch (options.onExhausted) {
+      case "alert":
+        this.logger.error(
+          `[ALERT] Event handler exhausted all retries`,
+          error,
+          {
+            eventId: event.id,
+            eventType: event.type,
+            pattern: registration.pattern
+          }
+        );
+        break;
+      case "discard":
+        this.logger.debug(`Event discarded after exhausted retries`, {
+          eventId: event.id
+        });
+        break;
+      case "log":
+      default:
+        this.logger.warn(`Event handler exhausted all retries`, {
+          eventId: event.id,
+          error: error.message
+        });
+    }
+  }
+  /**
+   * Get handlers matching an event type
+   */
+  getMatchingHandlers(eventType) {
+    const matching = [];
+    for (const [pattern, handlers] of this.handlers) {
+      if (matchEventType(eventType, pattern)) {
+        matching.push(...handlers);
+      }
+    }
+    return matching;
+  }
+  /**
+   * Get all registered patterns
+   */
+  getPatterns() {
+    return Array.from(this.handlers.keys());
+  }
+  /**
+   * Check if a pattern has handlers
+   */
+  hasHandlers(pattern) {
+    return this.handlers.has(pattern);
+  }
+  /**
+   * Clear all handlers
+   */
+  clear() {
+    this.handlers.clear();
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseTraceContext(traceparent) {
+  const parts = traceparent.split("-");
+  if (parts.length !== 4) return void 0;
+  const [, traceId, spanId, flags] = parts;
+  if (!traceId || !spanId || !flags) return void 0;
+  return {
+    traceId,
+    spanId,
+    traceFlags: parseInt(flags, 16)
+  };
+}
+
+// src/transports/cloudflare/queue.ts
+var CloudflareQueueTransport = class {
+  name = "cloudflare-queue";
+  queue;
+  queueName;
+  compact;
+  logger;
+  batchSize;
+  flushInterval;
+  registry;
+  buffer = [];
+  flushTimer = null;
+  constructor(options) {
+    this.queue = options.queue;
+    this.queueName = options.queueName ?? "events";
+    this.compact = options.compact ?? true;
+    this.logger = options.logger ?? createLogger3({ name: `queue:${this.queueName}` });
+    this.batchSize = options.batchSize ?? 100;
+    this.flushInterval = options.flushInterval ?? 1e3;
+    this.registry = new EventHandlerRegistry({ logger: this.logger });
+    this.flushTimer = setInterval(() => this.flush(), this.flushInterval);
+  }
+  /**
+   * Emit an event to the queue
+   */
+  async emit(event) {
+    this.buffer.push(event);
+    if (this.buffer.length >= this.batchSize) {
+      await this.flush();
+    }
+  }
+  /**
+   * Subscribe to events (for local handler registration)
+   */
+  subscribe(eventType, handler, options) {
+    return this.registry.register(eventType, handler, options);
+  }
+  /**
+   * Flush buffered events to the queue
+   */
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const events = this.buffer.splice(0, this.batchSize);
+    try {
+      if (events.length === 1) {
+        const body = this.compact ? toCompactEvent(events[0]) : events[0];
+        await this.queue.send(body);
+      } else {
+        const messages = events.map((event) => ({
+          body: this.compact ? toCompactEvent(event) : event
+        }));
+        await this.queue.sendBatch(messages);
+      }
+      this.logger.debug(`Sent ${events.length} events to queue`, {
+        queue: this.queueName
+      });
+    } catch (error) {
+      this.buffer.unshift(...events);
+      this.logger.error("Failed to send events to queue", error);
+      throw error;
+    }
+  }
+  /**
+   * Handle a queue message (called by queue consumer)
+   */
+  async handleMessage(message) {
+    try {
+      const event = this.parseEvent(message.body);
+      await this.registry.handle(event);
+      message.ack();
+    } catch (error) {
+      this.logger.error("Failed to handle queue message", error, {
+        messageId: message.id
+      });
+      message.retry();
+    }
+  }
+  /**
+   * Handle a batch of queue messages
+   */
+  async handleBatch(batch) {
+    const results = await Promise.allSettled(
+      batch.messages.map((msg) => this.handleMessage(msg))
+    );
+    const failures = results.filter((r) => r.status === "rejected");
+    if (failures.length > 0) {
+      this.logger.warn(`${failures.length}/${batch.messages.length} messages failed`);
+    }
+  }
+  /**
+   * Parse event from message body
+   */
+  parseEvent(body) {
+    if (this.compact && isCompactEvent(body)) {
+      return fromCompactEvent(body);
+    }
+    return body;
+  }
+  /**
+   * Close the transport
+   */
+  async close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+    this.registry.clear();
+  }
+};
+function createCloudflareQueueTransport(options) {
+  return new CloudflareQueueTransport(options);
+}
+function createQueueConsumer(registry, options) {
+  const compact = options?.compact ?? true;
+  const logger = options?.logger ?? createLogger3({ name: "queue-consumer" });
+  return async (batch) => {
+    logger.info(`Processing batch of ${batch.messages.length} messages`, {
+      queue: batch.queue
+    });
+    for (const message of batch.messages) {
+      try {
+        let event;
+        if (compact && isCompactEvent(message.body)) {
+          event = fromCompactEvent(message.body);
+        } else {
+          event = message.body;
+        }
+        await registry.handle(event);
+        message.ack();
+      } catch (error) {
+        logger.error("Failed to process message", error, {
+          messageId: message.id
+        });
+        message.retry();
+      }
+    }
+  };
+}
+function isCompactEvent(body) {
+  if (!body || typeof body !== "object") return false;
+  const obj = body;
+  return typeof obj["e"] === "string" && typeof obj["s"] === "string" && typeof obj["i"] === "string" && typeof obj["t"] === "number";
+}
+
+// src/transports/cloudflare/durable-object.ts
+import { createLogger as createLogger4 } from "@parsrun/core";
+var DurableObjectTransport = class {
+  name = "durable-object";
+  namespace;
+  objectIdResolver;
+  serializer;
+  logger;
+  constructor(options) {
+    this.namespace = options.namespace;
+    this.objectIdResolver = typeof options.objectId === "function" ? options.objectId : () => options.objectId;
+    this.serializer = options.serializer ?? jsonSerializer;
+    this.logger = options.logger ?? createLogger4({ name: "durable-object" });
+  }
+  async call(request) {
+    try {
+      const objectIdName = this.objectIdResolver(request);
+      const id = this.namespace.idFromName(objectIdName);
+      const stub = this.namespace.get(id);
+      const body = this.serializer.encode(request);
+      const response = await stub.fetch("http://internal/rpc", {
+        method: "POST",
+        headers: {
+          "Content-Type": this.serializer.contentType
+        },
+        body: typeof body === "string" ? body : body
+      });
+      const text = await response.text();
+      return this.serializer.decode(text);
+    } catch (error) {
+      this.logger.error("Durable Object call failed", error);
+      throw new TransportError(
+        `Durable Object call failed: ${error.message}`,
+        error
+      );
+    }
+  }
+  async close() {
+  }
+};
+function createDurableObjectTransport(options) {
+  return new DurableObjectTransport(options);
+}
+export {
+  CloudflareQueueTransport,
+  DurableObjectTransport,
+  ServiceBindingTransport,
+  createCloudflareQueueTransport,
+  createDurableObjectTransport,
+  createQueueConsumer,
+  createServiceBindingHandler,
+  createServiceBindingTransport
+};
+//# sourceMappingURL=index.js.map