better-ship 0.8.0 → 0.11.0

package/src/infrastructure/http/index.ts

@@ -0,0 +1,6 @@
+export { WebhookHandler } from './webhook-handler.ts'
+export {
+  WebhookVerificationError,
+  type WebhookVerification,
+  type WebhookVerifier,
+} from './webhook-verification.ts'

package/src/infrastructure/http/webhook-handler.ts

@@ -0,0 +1,35 @@
+import { StatusCodes } from 'http-status-codes'
+
+import { createLogger, type Logger } from '@/core'
+
+import { WebhookVerificationError, type WebhookVerifier } from './webhook-verification.ts'
+
+/** Read raw webhook requests and acknowledge effects only after the callback completes. */
+export class WebhookHandler<Event> {
+  /** Inject provider verification and an optional logger with the application's module name. */
+  constructor(
+    private readonly verifier: WebhookVerifier<Event>,
+    private readonly logger: Pick<Logger, 'warn'> = createLogger('webhook'),
+  ) {}
+
+  /**
+   * Return 401 for authentication failure, 400 for invalid content, and 200 after callback completion or an ignored event.
+   * Operational and callback failures propagate to the route's error boundary without an acknowledgment.
+   */
+  async handle(request: Request, onEvent: (event: Event) => Promise<void>): Promise<Response> {
+    const body = await request.text()
+    const result = await this.verifier.verify(body, request.headers)
+    if (result.outcome === 'rejected') return this.reject(result.error)
+    if (result.outcome === 'event') await onEvent(result.event)
+    return new Response(null, { status: StatusCodes.OK })
+  }
+
+  private reject(error: WebhookVerificationError): Response {
+    this.logger.warn('Webhook rejected', { reason: error.reason })
+    const status =
+      error.reason === 'missing_headers' || error.reason === 'invalid_signature'
+        ? StatusCodes.UNAUTHORIZED
+        : StatusCodes.BAD_REQUEST
+    return new Response(null, { status })
+  }
+}

package/src/infrastructure/http/webhook-verification.ts

@@ -0,0 +1,27 @@
+import { AppError } from '@/core'
+
+/** A webhook cannot be trusted or parsed. The HTTP handler logs the rejection once. */
+export class WebhookVerificationError extends AppError {
+  readonly _tag = 'WebhookVerificationError'
+  readonly classification = 'terminal'
+
+  /** Keep secrets and payload details out of the public message. */
+  constructor(
+    readonly reason: 'missing_headers' | 'invalid_signature' | 'invalid_payload',
+    cause?: unknown,
+  ) {
+    super(`Webhook rejected: ${reason}`, { cause })
+  }
+}
+
+/** A verified event, an ignored event, or an invalid request. */
+export type WebhookVerification<Event> =
+  | { readonly outcome: 'event'; readonly event: Event }
+  | { readonly outcome: 'ignored'; readonly type: string }
+  | { readonly outcome: 'rejected'; readonly error: WebhookVerificationError }
+
+/** The provider owns signature verification, timestamp tolerance, and payload parsing. */
+export interface WebhookVerifier<Event> {
+  /** Verify the exact body before parsing it. Return invalid requests; throw operational failures. */
+  verify(body: string, headers: Headers): Promise<WebhookVerification<Event>>
+}

package/src/infrastructure/resend/email-event.ts

@@ -0,0 +1,142 @@
+import type { WebhookEventPayload } from 'resend'
+import { z } from 'zod'
+
+import { EmailAddressSchema, parseBounceType, type BounceType } from '@/core'
+
+const SIMPLE_EMAIL_TYPES = [
+  'email.sent',
+  'email.scheduled',
+  'email.delivered',
+  'email.delivery_delayed',
+  'email.complained',
+  'email.opened',
+  'email.received',
+  'email.suppressed',
+] as const
+
+/** Resend email event names supported by this module. */
+export type EmailEventType =
+  | (typeof SIMPLE_EMAIL_TYPES)[number]
+  | 'email.bounced'
+  | 'email.failed'
+  | 'email.clicked'
+
+const EMAIL_TYPES = {
+  'email.sent': true,
+  'email.scheduled': true,
+  'email.delivered': true,
+  'email.delivery_delayed': true,
+  'email.complained': true,
+  'email.opened': true,
+  'email.received': true,
+  'email.suppressed': true,
+  'email.bounced': true,
+  'email.failed': true,
+  'email.clicked': true,
+} satisfies Record<Extract<WebhookEventPayload['type'], `email.${string}`>, true>
+
+const BaseDataSchema = z.object({
+  email_id: z.string().min(1),
+  to: z.array(EmailAddressSchema).min(1),
+  subject: z.string(),
+  tags: z.record(z.string(), z.string()).default({}),
+})
+
+const EmailPayloadSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.enum(SIMPLE_EMAIL_TYPES), data: BaseDataSchema }),
+  z.object({
+    type: z.literal('email.bounced'),
+    data: BaseDataSchema.extend({
+      bounce: z.object({
+        type: z.string().optional(),
+        subType: z.string().nullable().optional(),
+        message: z.string(),
+      }),
+    }),
+  }),
+  z.object({
+    type: z.literal('email.failed'),
+    data: BaseDataSchema.extend({ failed: z.object({ reason: z.string() }) }),
+  }),
+  z.object({
+    type: z.literal('email.clicked'),
+    data: BaseDataSchema.extend({ click: z.object({ link: z.string() }) }),
+  }),
+])
+
+type EmailEventBase = {
+  readonly id: string
+  readonly emailId: string
+  readonly recipients: readonly string[]
+  readonly subject: string
+  readonly tags: Readonly<Record<string, string>>
+  readonly occurredAt: string
+}
+
+/** A verified event. `id` is the Svix identity; use `resend:event:${id}` as the command id. */
+export type EmailEvent =
+  | (EmailEventBase & {
+      readonly type: 'email.bounced'
+      readonly bounce: {
+        readonly type: BounceType
+        readonly subType: string | null
+        readonly message: string
+      }
+    })
+  | (EmailEventBase & { readonly type: 'email.failed'; readonly reason: string })
+  | (EmailEventBase & { readonly type: 'email.clicked'; readonly link: string })
+  | (EmailEventBase & { readonly type: (typeof SIMPLE_EMAIL_TYPES)[number] })
+
+const EventHeaderSchema = z.object({
+  type: z.string(),
+  created_at: z.iso.datetime({ offset: true }),
+})
+
+/** Validate signed provider data before projecting it into the public event contract. */
+export function parseEmailEvent(
+  payload: WebhookEventPayload,
+  id: string,
+):
+  | { readonly outcome: 'event'; readonly event: EmailEvent }
+  | { readonly outcome: 'ignored'; readonly type: string }
+  | { readonly outcome: 'invalid' } {
+  const header = EventHeaderSchema.safeParse(payload)
+  if (!header.success) return { outcome: 'invalid' }
+  if (!Object.hasOwn(EMAIL_TYPES, header.data.type))
+    return { outcome: 'ignored', type: header.data.type }
+  const parsed = EmailPayloadSchema.safeParse(payload)
+  if (!parsed.success) return { outcome: 'invalid' }
+  const event = parsed.data
+  const base: EmailEventBase = {
+    id,
+    emailId: event.data.email_id,
+    recipients: event.data.to,
+    subject: event.data.subject,
+    tags: event.data.tags,
+    occurredAt: header.data.created_at,
+  }
+  switch (event.type) {
+    case 'email.bounced':
+      return {
+        outcome: 'event',
+        event: {
+          ...base,
+          type: event.type,
+          bounce: {
+            type: parseBounceType(event.data.bounce.type),
+            subType: event.data.bounce.subType ?? null,
+            message: event.data.bounce.message,
+          },
+        },
+      }
+    case 'email.failed':
+      return {
+        outcome: 'event',
+        event: { ...base, type: event.type, reason: event.data.failed.reason },
+      }
+    case 'email.clicked':
+      return { outcome: 'event', event: { ...base, type: event.type, link: event.data.click.link } }
+    default:
+      return { outcome: 'event', event: { ...base, type: event.type } }
+  }
+}

package/src/infrastructure/resend/index.ts

@@ -0,0 +1,3 @@
+export { ResendEmailService, type ResendEmailClient } from './resend-email-service.ts'
+export { ResendWebhook, type ResendWebhookClient } from './resend-webhook.ts'
+export type { EmailEvent, EmailEventType } from './email-event.ts'

package/src/infrastructure/resend/resend-email-service.ts

@@ -0,0 +1,125 @@
+import { Buffer } from 'node:buffer'
+
+import type { Attachment, CreateEmailOptions, ErrorResponse, Resend } from 'resend'
+
+import type { EmailAccepted, EmailAttachment, IEmailService, OutboundEmail } from '@/application'
+import { EmailServiceError, type EmailSendFailureReason } from '@/core'
+
+// SDK additions must receive an explicit classification before the package builds.
+const SDK_REASONS = {
+  invalid_idempotency_key: 'invalid_request',
+  validation_error: 'invalid_request',
+  missing_api_key: 'configuration',
+  restricted_api_key: 'configuration',
+  invalid_api_key: 'configuration',
+  not_found: 'invalid_request',
+  method_not_allowed: 'invalid_request',
+  invalid_idempotent_request: 'invalid_request',
+  concurrent_idempotent_requests: 'idempotency_conflict',
+  invalid_attachment: 'invalid_request',
+  invalid_from_address: 'invalid_request',
+  invalid_access: 'configuration',
+  invalid_parameter: 'invalid_request',
+  invalid_region: 'invalid_request',
+  missing_required_field: 'invalid_request',
+  monthly_quota_exceeded: 'quota_exceeded',
+  daily_quota_exceeded: 'quota_exceeded',
+  rate_limit_exceeded: 'rate_limited',
+  security_error: 'configuration',
+  application_error: 'provider_error',
+  internal_server_error: 'provider_error',
+} satisfies Record<ErrorResponse['name'], EmailSendFailureReason>
+
+// Resend documents these codes before its SDK includes them in ErrorResponse.
+const DOCUMENTED_REASONS = new Map<string, EmailSendFailureReason>([
+  ['email_above_quota', 'quota_exceeded'],
+  ['invalid_permission', 'configuration'],
+  ['suspended_api_key', 'configuration'],
+  ['resource_locked', 'idempotency_conflict'],
+  ['service_unavailable', 'provider_error'],
+  ['missing_required_parameter', 'invalid_request'],
+])
+
+function reasonFromResend(error: ErrorResponse): EmailSendFailureReason {
+  if (Object.hasOwn(SDK_REASONS, error.name)) return SDK_REASONS[error.name]
+  const reason = DOCUMENTED_REASONS.get(error.name)
+  if (reason !== undefined) return reason
+  if (error.statusCode === 429) return 'rate_limited'
+  if (error.statusCode !== null && error.statusCode >= 400 && error.statusCode < 500)
+    return 'invalid_request'
+  return 'provider_error'
+}
+
+function retryAfterSeconds(value: string | undefined): number | null {
+  if (value === undefined || !/^\d+$/.test(value)) return null
+  const seconds = Number(value)
+  return Number.isSafeInteger(seconds) ? seconds : null
+}
+
+function toAttachment(attachment: EmailAttachment): Attachment {
+  const result: Attachment = {
+    filename: attachment.filename,
+    content: ArrayBuffer.isView(attachment.content)
+      ? Buffer.from(attachment.content)
+      : attachment.content,
+  }
+  if (attachment.contentType !== undefined) result.contentType = attachment.contentType
+  return result
+}
+
+/** The SDK operations required by the adapter; a test factory can return a plain object. */
+export type ResendEmailClient = { readonly emails: Pick<Resend['emails'], 'send'> }
+
+/**
+ * Send without package retries or logs. Ported from Suparelay's resend-email-service.ts.
+ * The Resend SDK itself logs API errors outside production.
+ */
+export class ResendEmailService implements IEmailService {
+  /** Load the SDK on the first send. Constructing the service does not load it. */
+  static create(apiKey: string, fromAddress: string): ResendEmailService {
+    return new ResendEmailService(
+      () => import('resend').then(({ Resend }) => new Resend(apiKey)),
+      fromAddress,
+    )
+  }
+
+  private client: Promise<ResendEmailClient> | undefined
+
+  /** Supply an async factory. The service calls it once, on the first send, and keeps its promise. */
+  constructor(
+    private readonly createClient: () => Promise<ResendEmailClient>,
+    private readonly fromAddress: string,
+  ) {}
+
+  /** Resolve after acceptance. Provider failures throw EmailServiceError; SDK defects retain their identity. */
+  async sendEmail(email: OutboundEmail): Promise<EmailAccepted> {
+    if (this.client === undefined) {
+      // Cache synchronous factory throws as rejections too, so later sends cannot initialize again.
+      this.client = Promise.resolve().then(this.createClient)
+    }
+    const client = await this.client
+    const payload: CreateEmailOptions = {
+      from: this.fromAddress,
+      to: [email.to].flat(),
+      subject: email.subject,
+      html: email.html,
+    }
+    if (email.text !== undefined) payload.text = email.text
+    if (email.replyTo !== undefined) payload.replyTo = email.replyTo
+    if (email.tags !== undefined)
+      payload.tags = Object.entries(email.tags).map(([name, value]) => ({ name, value }))
+    if (email.attachments !== undefined) payload.attachments = email.attachments.map(toAttachment)
+    const result = await client.emails.send(payload, { idempotencyKey: email.idempotencyKey })
+    if (result.error !== null) {
+      throw new EmailServiceError({
+        reason: reasonFromResend(result.error),
+        provider: 'resend',
+        providerCode: result.error.name,
+        statusCode: result.error.statusCode,
+        retryAfter: retryAfterSeconds(result.headers?.['retry-after']),
+        cause: result.error,
+      })
+    }
+    return { providerId: result.data.id }
+  }
+}

package/src/infrastructure/resend/resend-webhook.ts

@@ -0,0 +1,70 @@
+import type { Resend } from 'resend'
+import { z } from 'zod'
+
+import {
+  WebhookVerificationError,
+  type WebhookVerification,
+  type WebhookVerifier,
+} from '../http/webhook-verification.ts'
+import { parseEmailEvent, type EmailEvent } from './email-event.ts'
+
+// Separate standardwebhooks versions have different prototypes; its error name remains the same.
+const SignatureErrorSchema = z
+  .instanceof(Error)
+  .refine((error) => error.name === 'WebhookVerificationError')
+
+/** The SDK's local signature verifier. It makes no API request. */
+export type ResendWebhookClient = Pick<Resend['webhooks'], 'verify'>
+
+/** Verify Svix signatures and map Resend email events. Ported from Typist's Resend route. */
+export class ResendWebhook implements WebhookVerifier<EmailEvent> {
+  /** Load the SDK on the first verification. Only the webhook secret is required. */
+  static create(webhookSecret: string): ResendWebhook {
+    return new ResendWebhook(webhookSecret, async () => {
+      const { Resend } = await import('resend')
+      // The SDK requires a nonempty key even though its local verifier never uses that key.
+      return new Resend('re_webhook_verification_only').webhooks
+    })
+  }
+
+  private client: Promise<ResendWebhookClient> | undefined
+
+  /** Inject the local SDK verifier when testing. */
+  constructor(
+    private readonly webhookSecret: string,
+    private readonly verifier: () => Promise<ResendWebhookClient>,
+  ) {}
+
+  /** Verify the raw body and Svix headers. Invalid requests return rejected; configuration and SDK defects propagate. */
+  async verify(body: string, headers: Headers): Promise<WebhookVerification<EmailEvent>> {
+    const id = headers.get('svix-id')
+    const timestamp = headers.get('svix-timestamp')
+    const signature = headers.get('svix-signature')
+    if (!id || !timestamp || !signature)
+      return { outcome: 'rejected', error: new WebhookVerificationError('missing_headers') }
+    const client = await (this.client ??= this.verifier())
+    let payload: ReturnType<ResendWebhookClient['verify']>
+    try {
+      payload = client.verify({
+        payload: body,
+        headers: { id, timestamp, signature },
+        webhookSecret: this.webhookSecret,
+      })
+    } catch (cause) {
+      if (cause instanceof SyntaxError)
+        return {
+          outcome: 'rejected',
+          error: new WebhookVerificationError('invalid_payload', cause),
+        }
+      if (!SignatureErrorSchema.safeParse(cause).success) throw cause
+      return {
+        outcome: 'rejected',
+        error: new WebhookVerificationError('invalid_signature', cause),
+      }
+    }
+    const result = parseEmailEvent(payload, id)
+    if (result.outcome === 'invalid')
+      return { outcome: 'rejected', error: new WebhookVerificationError('invalid_payload') }
+    return result
+  }
+}

package/src/infrastructure/tanstack/auth.middleware.ts

@@ -1,9 +1,10 @@
-import { createMiddleware, type Register, type RequestServerOptions } from '@tanstack/react-start'
-import { getRequestHeaders } from '@tanstack/react-start/server'
+import { createMiddleware } from '@tanstack/react-start'
 import { getSessionCookie } from 'better-auth/cookies'
 
 import { AuthenticationError, StaleSessionError, createLogger } from '@/core'
 
+import type { RequestContext } from './request-context.ts'
+
 const logger = createLogger('auth-middleware')
 
 /** The fields middleware reads; generic callers retain every additional session and user field. */
@@ -28,13 +29,19 @@ export type AuthContext<Session extends AuthSession> =
 
 /** Select the current request's Better Auth instance from TanStack's registered context. */
 export type AuthMiddlewareOptions<Session extends AuthSession> = {
-  readonly getAuth: (context: RequestServerOptions<Register, undefined>['context']) => {
+  readonly getAuth: (context: RequestContext) => {
     readonly api: {
       readonly getSession: (options: { headers: Headers }) => Promise<Session | null>
     }
   }
 }
 
+// The server entry loads react-dom/server; the browser evaluates this module, so it loads lazily inside `.server()`.
+const requestHeaders = async () => {
+  const { getRequestHeaders } = await import('@tanstack/react-start/server')
+  return getRequestHeaders()
+}
+
 /**
  * Preserve Porte's function and request middleware contracts with application-owned services.
  * Optional lookup failures log once and continue as guests. Required lookup failures propagate.
@@ -46,7 +53,8 @@ export function createAuthMiddleware<Session extends AuthSession>(
     async ({ next, context }) => {
       let resolved: Session | null
       try {
-        resolved = await options.getAuth(context).api.getSession({ headers: getRequestHeaders() })
+        const headers = await requestHeaders()
+        resolved = await options.getAuth(context).api.getSession({ headers })
       } catch (error) {
         logger.error('get_session_failed', { error })
         resolved = null
@@ -60,7 +68,7 @@ export function createAuthMiddleware<Session extends AuthSession>(
   )
 
   async function resolveRequiredSession(
-    context: RequestServerOptions<Register, undefined>['context'],
+    context: RequestContext,
     headers: Headers,
   ): Promise<Session> {
     const resolved = await options.getAuth(context).api.getSession({ headers })
@@ -72,7 +80,7 @@ export function createAuthMiddleware<Session extends AuthSession>(
   }
 
   const requireAuth = createMiddleware({ type: 'function' }).server(async ({ next, context }) => {
-    const resolved = await resolveRequiredSession(context, getRequestHeaders())
+    const resolved = await resolveRequiredSession(context, await requestHeaders())
     return next<RequiredAuthContext<Session>>({
       context: { user: resolved.user, session: resolved.session },
     })

package/src/infrastructure/tanstack/error.middleware.ts

@@ -1,15 +1,14 @@
-import { isNotFound, isRedirect, type AnyRedirect } from '@tanstack/react-router'
-import { createMiddleware, type Register, type RequestServerOptions } from '@tanstack/react-start'
+import { isNotFound, isRedirect, redirect } from '@tanstack/react-router'
+import { createMiddleware } from '@tanstack/react-start'
 import type { BetterAuthCookies } from 'better-auth'
 
 import { StaleSessionError, type ErrorTable } from '@/core'
 
 import { createHttpErrorResponseConverter } from './http-error-response.ts'
+import type { RequestContext } from './request-context.ts'
 import { clearStaleSessionCookies } from './session-cookies.ts'
 import { createErrorPayloadConverter } from './to-error-payload.ts'
 
-type RequestContext = RequestServerOptions<Register, undefined>['context']
-
 /** The part of a Better Auth instance the boundary reads: its computed cookie definitions. */
 export type AuthCookieSource = {
   readonly $context: Promise<{ readonly authCookies: BetterAuthCookies }>
@@ -18,8 +17,8 @@ export type AuthCookieSource = {
 /** The application's error table, its stale-session redirect, and its Better Auth instance. */
 export type ErrorMiddlewareOptions<Entries> = {
   readonly errors: ErrorTable<Entries>
-  /** Build the redirect a server function throws for a stale session. */
-  readonly signIn: () => AnyRedirect
+  /** The path a server function redirects to for a stale session, with any search string. */
+  readonly signIn: string
   /** Select the request's Better Auth instance; its cookie definitions say what to clear. */
   readonly getAuth: (context: RequestContext) => AuthCookieSource
 }
@@ -34,7 +33,7 @@ export function createErrorMiddleware<Entries>(options: ErrorMiddlewareOptions<E
 
   async function clearSession(context: RequestContext): Promise<void> {
     const { authCookies } = await options.getAuth(context).$context
-    clearStaleSessionCookies(authCookies)
+    await clearStaleSessionCookies(authCookies)
   }
 
   async function handleFunctionError(cause: unknown, context: RequestContext): Promise<never> {
@@ -43,7 +42,7 @@ export function createErrorMiddleware<Entries>(options: ErrorMiddlewareOptions<E
     if (cause instanceof StaleSessionError) {
       await clearSession(context)
       // oxlint-disable-next-line typescript/only-throw-error -- Router redirects by throwing this.
-      throw options.signIn()
+      throw redirect({ href: options.signIn })
     }
     // oxlint-disable-next-line typescript/only-throw-error -- The client rejects with this and reads its tag.
     throw toErrorPayload(cause)

package/src/infrastructure/tanstack/index.ts

@@ -10,4 +10,3 @@ export {
   type AuthCookieSource,
   type ErrorMiddlewareOptions,
 } from './error.middleware.ts'
-export { getLastUsedLoginMethod } from './last-login-method.ts'

package/src/infrastructure/tanstack/request-context.ts

@@ -0,0 +1,11 @@
+import type { Register } from '@tanstack/react-start'
+
+/**
+ * The request context an application registers as `Register.server.requestContext`.
+ * TanStack's own request context type also reads `Register.config`, which lists the middleware
+ * whose options carry this type, so using it here would make every application's types circular.
+ * Without a registration TanStack passes no context, so the fallback is `undefined`.
+ */
+export type RequestContext = Register extends { server: { requestContext: infer Context } }
+  ? Context
+  : undefined

package/src/infrastructure/tanstack/server.ts

@@ -0,0 +1,7 @@
+/**
+ * Server-only helpers for TanStack Start. This entry evaluates `@tanstack/react-start/server`,
+ * so only code the Start compiler keeps on the server may import it: a `.server()` callback,
+ * a route loader's server function, or a request handler. `better-ship/tanstack` stays safe for
+ * a module the browser evaluates.
+ */
+export { getLastUsedLoginMethod } from './last-login-method.ts'

package/src/infrastructure/tanstack/session-cookies.ts

@@ -1,4 +1,4 @@
-import { deleteCookie, getRequestHeaders } from '@tanstack/react-start/server'
+import type { deleteCookie } from '@tanstack/react-start/server'
 import type { BetterAuthCookies } from 'better-auth'
 import { parseCookies } from 'better-auth/cookies'
 
@@ -9,8 +9,10 @@ type DeleteCookieOptions = NonNullable<Parameters<typeof deleteCookie>[1]>
  * Delete the session, session cache, account cache, and remember-me cookies of one instance.
  * Chunks present on the request go too. Names and attributes come from the instance, so custom prefixes and domain cookies clear.
  */
-export function clearStaleSessionCookies(cookies: BetterAuthCookies): void {
-  const present = [...parseCookies(getRequestHeaders().get('cookie') ?? '').keys()]
+export async function clearStaleSessionCookies(cookies: BetterAuthCookies): Promise<void> {
+  // The server entry loads react-dom/server; the browser evaluates this module, so it loads lazily here.
+  const server = await import('@tanstack/react-start/server')
+  const present = [...parseCookies(server.getRequestHeaders().get('cookie') ?? '').keys()]
   const definitions = [
     cookies.sessionToken,
     cookies.sessionData,
@@ -21,7 +23,7 @@ export function clearStaleSessionCookies(cookies: BetterAuthCookies): void {
     // Better Auth names a chunk `${name}.${index}`, so a missed chunk would resurrect the value.
     const chunks = present.filter((name) => name.startsWith(`${cookie.name}.`))
     for (const name of new Set([cookie.name, ...chunks]))
-      deleteCookie(name, deletionOf(cookie.attributes))
+      server.deleteCookie(name, deletionOf(cookie.attributes))
   }
 }
 

package/dist/application-DYfcAy-Q.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"application-DYfcAy-Q.js","names":[],"sources":["../src/application/message-already-processed.error.ts","../src/application/message-bus.ts","../src/application/unit-of-work.ts","../src/application/unit-of-work.errors.ts"],"sourcesContent":["import { AppError, DatabaseError, type MessageId } from '@/core'\n\n/** The message's effects already committed. A caller can skip duplicate delivery without repeating those effects. */\nexport class MessageAlreadyProcessedError extends AppError {\n  readonly _tag = 'MessageAlreadyProcessedError'\n  readonly classification = 'terminal'\n\n  constructor(\n    readonly messageId: MessageId,\n    options?: { readonly cause: unknown },\n  ) {\n    super(`message ${messageId} already processed`, options)\n  }\n\n  /** Recognize only the processed-message primary key; preserve other failures unchanged at the call site. */\n  static from(cause: unknown, messageId: MessageId): MessageAlreadyProcessedError | undefined {\n    if (cause instanceof MessageAlreadyProcessedError) return cause\n    if (!(cause instanceof DatabaseError)) return undefined\n    const details = cause.details\n    const duplicate =\n      details.database === 'd1'\n        ? details.kind === 'unique' &&\n          details.table === 'processed_messages' &&\n          details.column === 'message_id'\n        : details.code === '23505' &&\n          details.table_name === 'processed_messages' &&\n          details.constraint_name === 'processed_messages_pkey'\n    if (!duplicate) return undefined\n    return new MessageAlreadyProcessedError(messageId, { cause })\n  }\n}\n","import { panic } from 'better-result'\n\nimport {\n  createLogger,\n  unreachable,\n  type DomainCommand,\n  type DomainEvent,\n  type DomainMessage,\n  type DomainQuery,\n} from '@/core'\n\nimport { MessageAlreadyProcessedError } from './message-already-processed.error.ts'\nimport type { Handlers, MessageResult, RegistryMessage } from './registry.ts'\n\nconst logger = createLogger('message-bus')\n\n/** The port an entrypoint dispatches through. `AppDeps` names this as `IMessageBus<typeof registry>`. */\nexport interface IMessageBus<TRegistry extends Handlers<never>> {\n  handle<TMessage extends DomainMessage & RegistryMessage<TRegistry>>(\n    message: TMessage,\n  ): Promise<MessageResult<TMessage, TRegistry>>\n}\n\n/**\n * Routes one message to its slot. The bus opens no transaction and keeps no outbox:\n * a handler that writes opens the unit of work itself.\n */\nexport class MessageBus<Deps, TRegistry extends Handlers<Deps>> implements IMessageBus<TRegistry> {\n  constructor(\n    private readonly deps: Deps,\n    private readonly registry: TRegistry,\n  ) {}\n\n  /** Resolves to the handler's own value for a command or query, and to void for an event. */\n  async handle<TMessage extends DomainMessage & RegistryMessage<TRegistry>>(\n    message: TMessage,\n  ): Promise<MessageResult<TMessage, TRegistry>> {\n    // SAFETY: the slot for this name is what `MessageResult` names, and dispatch returns its value.\n    return (await this.dispatch(message)) as MessageResult<TMessage, TRegistry>\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- one table holds every slot's value; `handle` names it.\n  private dispatch(message: DomainMessage): Promise<unknown> {\n    if (message.type === 'command') return this.handleCommand(message)\n    if (message.type === 'query') return this.handleQuery(message)\n    if (message.type === 'event') return this.handleEvent(message)\n    // A message parsed at a boundary cannot reach here; one that does must not resolve silently.\n    return unreachable(message)\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- see dispatch.\n  private handleCommand(command: DomainCommand): Promise<unknown> {\n    // `satisfies` proved the registry complete, so a missing slot is a broken registry object.\n    const handler = this.registry.commands[command.name]\n    if (handler === undefined) return panic(`No handler for command ${command.name}`)\n    logger.debug('handling_command', { name: command.name, id: command.id })\n    return handler(command, this.deps)\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-returns -- see dispatch.\n  private handleQuery(query: DomainQuery): Promise<unknown> {\n    const handler = this.registry.queries[query.name]\n    if (handler === undefined) return panic(`No handler for query ${query.name}`)\n    return handler(query, this.deps)\n  }\n\n  /**\n   * Every subscriber runs to completion. One failure is rethrown as is. Several are thrown as\n   * one `AggregateError`. A `MessageAlreadyProcessedError` means that subscriber already committed on\n   * an earlier delivery, so it counts as delivered.\n   */\n  private async handleEvent(event: DomainEvent): Promise<void> {\n    const subscriptions = this.registry.events[event.name] ?? []\n    const outcomes = await Promise.allSettled(\n      subscriptions.map((subscription) => subscription(event, this.deps)),\n    )\n    const failures: unknown[] = []\n    for (const [subscriber, outcome] of outcomes.entries()) {\n      if (outcome.status === 'fulfilled') continue\n      if (outcome.reason instanceof MessageAlreadyProcessedError) {\n        // The bus swallows this error, so this line is the only record that the skip happened.\n        logger.info('duplicate_subscriber_ignored', { event: event.name, id: event.id, subscriber })\n        continue\n      }\n      failures.push(outcome.reason)\n    }\n    if (failures.length === 1) throw failures[0]\n    if (failures.length > 1) {\n      throw new AggregateError(failures, `${event.name}: ${failures.length} subscribers failed`)\n    }\n  }\n}\n","import type { MessageId } from '@/core'\n\nimport type { IEventCollector } from './event-collector.ts'\nimport { MessageAlreadyProcessedError } from './message-already-processed.error.ts'\nimport type { IMessageStore } from './message-store.ts'\nimport type { IOutboxRelay } from './outbox-relay.ts'\nimport type { ITransaction } from './transaction.ts'\n\n/**\n * Commits the processed-message record, repository writes, and emitted events together before resolving.\n * An existing record rejects with `MessageAlreadyProcessedError`; external effects must run through the outbox after commit.\n * Nested calls reject with `UnitOfWorkAlreadyActiveError`; independent concurrent calls are allowed.\n */\nexport interface IUnitOfWork<Repos> {\n  run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T>\n}\n\nexport type UnitOfWorkDeps<Tx, Repos> = {\n  readonly transaction: ITransaction<Tx>\n  /** The processed-messages and outbox repository for this transaction. */\n  readonly messageStore: (tx: Tx) => IMessageStore\n  /** Repositories participate in the current transaction. */\n  readonly createRepositories: (tx: Tx) => Repos\n  readonly eventCollector: IEventCollector\n  readonly relay: IOutboxRelay\n}\n\n/** The unit of work: the boundary, the repositories, the events. Every database call is a port. */\nexport class UnitOfWork<Tx, Repos> implements IUnitOfWork<Repos> {\n  constructor(private readonly deps: UnitOfWorkDeps<Tx, Repos>) {}\n\n  async run<T>(messageId: MessageId, work: (repos: Repos) => Promise<T>): Promise<T> {\n    const { transaction, messageStore, createRepositories, eventCollector, relay } = this.deps\n    let written = 0\n\n    let value: T\n    try {\n      value = await transaction.transaction(async (tx) => {\n        const store = messageStore(tx)\n        await store.claim(messageId)\n        const repos = createRepositories(tx)\n        const result = await work(repos)\n        const pending = eventCollector.collect()\n        await store.persistEvents(pending)\n        written = pending.length\n        return result\n      })\n    } catch (error) {\n      throw MessageAlreadyProcessedError.from(error, messageId) ?? error\n    }\n\n    if (written > 0) relay.wake()\n    return value\n  }\n}\n","import { AppError } from '@/core'\n\n/** A boundary was opened inside another. One message, one atomic scope. */\nexport class UnitOfWorkAlreadyActiveError extends AppError {\n  readonly _tag = 'UnitOfWorkAlreadyActiveError'\n  readonly classification = 'terminal'\n\n  constructor() {\n    super('a unit of work is already active')\n  }\n}\n"],"mappings":";;;;;AAGA,IAAa,+BAAb,MAAa,qCAAqC,SAAS;CAK9C;CAJX,AAAS,OAAO;CAChB,AAAS,iBAAiB;CAE1B,YACE,AAAS,WACT,SACA;EACA,MAAM,WAAW,UAAU,qBAAqB,OAAO;EAH9C;CAIX;;CAGA,OAAO,KAAK,OAAgB,WAAgE;EAC1F,IAAI,iBAAiB,8BAA8B,OAAO;EAC1D,IAAI,EAAE,iBAAiB,gBAAgB,OAAO;EAC9C,MAAM,UAAU,MAAM;EAStB,IAAI,EAPF,QAAQ,aAAa,OACjB,QAAQ,SAAS,YACjB,QAAQ,UAAU,wBAClB,QAAQ,WAAW,eACnB,QAAQ,SAAS,WACjB,QAAQ,eAAe,wBACvB,QAAQ,oBAAoB,4BAClB,OAAO;EACvB,OAAO,IAAI,6BAA6B,WAAW,EAAE,MAAM,CAAC;CAC9D;AACF;;;;AChBA,MAAM,SAAS,aAAa,aAAa;;;;;AAazC,IAAa,aAAb,MAAkG;CAE7E;CACA;CAFnB,YACE,AAAiB,MACjB,AAAiB,UACjB;EAFiB;EACA;CAChB;;CAGH,MAAM,OACJ,SAC6C;EAE7C,OAAQ,MAAM,KAAK,SAAS,OAAO;CACrC;CAGA,AAAQ,SAAS,SAA0C;EACzD,IAAI,QAAQ,SAAS,WAAW,OAAO,KAAK,cAAc,OAAO;EACjE,IAAI,QAAQ,SAAS,SAAS,OAAO,KAAK,YAAY,OAAO;EAC7D,IAAI,QAAQ,SAAS,SAAS,OAAO,KAAK,YAAY,OAAO;EAE7D,OAAO,YAAY,OAAO;CAC5B;CAGA,AAAQ,cAAc,SAA0C;EAE9D,MAAM,UAAU,KAAK,SAAS,SAAS,QAAQ;EAC/C,IAAI,YAAY,QAAW,OAAO,MAAM,0BAA0B,QAAQ,MAAM;EAChF,OAAO,MAAM,oBAAoB;GAAE,MAAM,QAAQ;GAAM,IAAI,QAAQ;EAAG,CAAC;EACvE,OAAO,QAAQ,SAAS,KAAK,IAAI;CACnC;CAGA,AAAQ,YAAY,OAAsC;EACxD,MAAM,UAAU,KAAK,SAAS,QAAQ,MAAM;EAC5C,IAAI,YAAY,QAAW,OAAO,MAAM,wBAAwB,MAAM,MAAM;EAC5E,OAAO,QAAQ,OAAO,KAAK,IAAI;CACjC;;;;;;CAOA,MAAc,YAAY,OAAmC;EAC3D,MAAM,gBAAgB,KAAK,SAAS,OAAO,MAAM,SAAS,CAAC;EAC3D,MAAM,WAAW,MAAM,QAAQ,WAC7B,cAAc,KAAK,iBAAiB,aAAa,OAAO,KAAK,IAAI,CAAC,CACpE;EACA,MAAM,WAAsB,CAAC;EAC7B,KAAK,MAAM,CAAC,YAAY,YAAY,SAAS,QAAQ,GAAG;GACtD,IAAI,QAAQ,WAAW,aAAa;GACpC,IAAI,QAAQ,kBAAkB,8BAA8B;IAE1D,OAAO,KAAK,gCAAgC;KAAE,OAAO,MAAM;KAAM,IAAI,MAAM;KAAI;IAAW,CAAC;IAC3F;GACF;GACA,SAAS,KAAK,QAAQ,MAAM;EAC9B;EACA,IAAI,SAAS,WAAW,GAAG,MAAM,SAAS;EAC1C,IAAI,SAAS,SAAS,GACpB,MAAM,IAAI,eAAe,UAAU,GAAG,MAAM,KAAK,IAAI,SAAS,OAAO,oBAAoB;CAE7F;AACF;;;;;AC/DA,IAAa,aAAb,MAAiE;CAClC;CAA7B,YAAY,AAAiB,MAAiC;EAAjC;CAAkC;CAE/D,MAAM,IAAO,WAAsB,MAAgD;EACjF,MAAM,EAAE,aAAa,cAAc,oBAAoB,gBAAgB,UAAU,KAAK;EACtF,IAAI,UAAU;EAEd,IAAI;EACJ,IAAI;GACF,QAAQ,MAAM,YAAY,YAAY,OAAO,OAAO;IAClD,MAAM,QAAQ,aAAa,EAAE;IAC7B,MAAM,MAAM,MAAM,SAAS;IAE3B,MAAM,SAAS,MAAM,KADP,mBAAmB,EACH,CAAC;IAC/B,MAAM,UAAU,eAAe,QAAQ;IACvC,MAAM,MAAM,cAAc,OAAO;IACjC,UAAU,QAAQ;IAClB,OAAO;GACT,CAAC;EACH,SAAS,OAAO;GACd,MAAM,6BAA6B,KAAK,OAAO,SAAS,KAAK;EAC/D;EAEA,IAAI,UAAU,GAAG,MAAM,KAAK;EAC5B,OAAO;CACT;AACF;;;;;ACnDA,IAAa,+BAAb,cAAkD,SAAS;CACzD,AAAS,OAAO;CAChB,AAAS,iBAAiB;CAE1B,cAAc;EACZ,MAAM,kCAAkC;CAC1C;AACF"}

package/dist/index-6XMPJu7u.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-6XMPJu7u.d.ts","names":[],"sources":["../src/core/failure-classification.ts","../src/core/app-error.ts","../src/core/authentication.error.ts","../src/core/rate-limit.error.ts","../src/core/stale-session.error.ts","../src/core/not-authorized.error.ts","../src/core/internal.errors.ts","../src/core/problem-details.ts","../src/core/request.errors.ts","../src/core/error-table.ts","../src/core/database.error.ts","../src/core/defects.ts","../src/core/identity.ts","../src/core/messages.ts","../src/core/define-messages.ts","../src/core/entity.ts","../src/core/transport-classification.ts","../src/core/cloudflare-classification.ts","../src/core/classify-failure.ts","../src/core/backoff.ts","../src/core/logger.ts"],"mappings":";;;;;;;;KAMY;;;;;;;KAQA;;iBAGI,mBAAmB;WACxB,gBAAgB;WAChB;WACA,OAAO;;;;;;;;;;;;uBCVI,iBAAiB;oBACnB;oBACA,gBAAgB;MAErB;;;;;cCXF,4BAA4B;WAC9B;WACA;EAET;;;;;cCJW,uBAAuB;WAKb;WAJZ;WACA;WACA;EAET,YAAqB;;;;;cCLV,0BAA0B;WAC5B;WACA;EAET;;;;;cCJW,2BAA2B;WAC7B;WACA;EAET;;;;;cCJW,4BAA4B;WAC9B;WACA;EAET;;;cAMW,gCAAgC;WAClC;WACA;EAET;;;;;;;;;cCVW,sBAAoB,EAAA;;;;;GAqB/B,EAAA,KAAA;;KAGU,iBAAiB,EAAE,aAAa;;cAG/B,8BAA4B,EAAA;;;GAWvC,EAAA,KAAA;;KAGU,yBAAyB,EAAE,aAAa;;cAGvC,gCAA8B,EAAA;;;;;;;;;GAEzC,EAAA,KAAA;;KAGU,2BAA2B,EAAE,aAAa;;;;KClD1C;WACD;WACA,eAAe;;;cAIb,wBAAwB;WAKxB,iBAAiB;WAJnB;WACA;EAET,YACW,iBAAiB,0BAC1B;;SAMK,QAAQ,OAAO,EAAE,UAAU,mBAAmB;;SAK9C,WAAW,iBAAiB,mBAAmB,mBAAmB;;;cAS9D,8BAA8B;WAChC;WACA;EAET,YAAY;IAAQ;;;;cAMT,8BAA8B;WAChC;WACA;EAET;;;cAMW,6BAA6B;WAC/B;WACA;EAET;;;cAMW,4BAA4B;WAC9B;WACA;EAET;;;;KCtDG,eAAe,EAAE;;;;;KAMV,WAAW,oBAAoB,eAAe,eAAe;WAC9D,wBAAwB,kBAAkB;aAAsB,MAAM;;WACtE;WACA,SAAS;;;KAMR,aAAa,uBACb,aAAa,mBAAmB,WAAW;KAGlD,aAAa,oBAAoB,SAAS;WACpC,cAAc,eAAe,EAAE;;WAE3B,MAAM;WAAc;IAAoB,EAAE,OAAO;WACjD,MAAM;WAAc;;KAE9B,iBAAiB,cACnB,aAAa,mBAAmB,aAAa,KAAK,QAAQ,eACrD;;KAGI,cAAc;WACf;WACA,SAAS;;;;;;KAOR,WAAW;WACZ,SAAS;;WAET,eAAe,EAAE,QAAQ,iBAAiB;;WAE1C,SAAS,iBAAiB;;EAEnC,MAAM,iBAAiB,iBAAiB;;EAExC,GAAG,kBAAkB,kBACnB,gBACA,KAAK,MACJ,SAAS,QAAQ,iBAAiB;aAAqB,MAAM;;;EAEhE,QAAQ,iBAAiB,cAAc,iBAAiB;;EAExD,SAAS,iBAAiB,cAAc,iBAAiB;;;KAI/C,eAAe,SACzB,cAAc,iBAAiB,WAAW,iBAAiB;;KAGjD,WAAW,SACrB,cAAc,iBAAiB,iBAAiB;;cAUrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAcR,cAAc,WAAW,YAAY,oBAAoB,WAAW;;;;;iBA4BzD,mBAAmB,gBAAgB,aAAa,UAC9D,SAAS,UACR,WAAW,cAAc;;;;KCpIhB;;KAGA;WAEG;WACA;WACA,MAAM;WACN;WACA;WACA;;WAGA;WACA;WACA;WACA;WACA;;;cAIF,sBAAsB;WAItB;WACA,gBAAgB;WAChB,SAAS;WALX;EAET,YACW,mBACA,gBAAgB,uBAChB,SAAS,iBAClB;aAAoB;;;;;;;;;;iBCzBR,YAAY;;;;;;;iBAUZ,eAAe;;;;KCbnB,GAAG,iCAAiC,EAAE,KAAK,OAAO;;KAGlD,aAAa;WACd,QAAQ,EAAE,KAAK,YAAY,EAAE,SAAS;;EAE/C,UAAU,GAAG;;;KAIH,KAAK,mBAAmB,wBAAwB,EAAE,OAAO;;;;;iBAMrD,eAAe,sBAAsB,OAAO,QAAQ,aAAa;;;;;;;;;;KCbrE;;KAGA,cAAc;WACf;WACA,MAAM;WACN,IAAI;;;KAIH,YAAY;WACb;WACA,MAAM;;;KAIL,YAAY;WACb;WACA,MAAM;WACN,IAAI;;;KAIH,gBAAgB,gBAAgB,cAAc;;;;KCxB9C,iBAAiB,SAAS,eAAe,EAAE;;KAG3C;WACD,UAAU;WACV,QAAQ;WACR,SAAS;;KAGf;WAAyB,YAAY;;KACrC,IAAI,iBAAiB,eAAe;KACpC,QAAQ,gBAAgB,gBAAgB,mBAAmB,WAAW,EAAE,OAAO,QAAQ;;KAGhF,UAAU,iBAAiB,kBACpC,cAAc,IAAI,iCAAiC,cAAc,QAChE,QAAQ,IAAI,uBAAuB,eAC/B,IAAI;;KAGA,QAAQ,iBAAiB,kBAClC,cAAc,IAAI,+BAA+B,YAAY,QAC5D,QAAQ,IAAI,qBAAqB,eAC7B,IAAI;;KAGA,QAAQ,iBAAiB,kBAClC,cAAc,IAAI,gCAAgC,YAAY,QAC7D,QAAQ,IAAI,sBAAsB,eAC9B,IAAI;;KAGA,UAAU,iBAAiB,eACnC,UAAU,YACV,QAAQ,YACR,QAAQ;;;;;KAMA,YAAY,mBAAmB;WAChC,YAAY;;EAErB,cAAc,mBAAmB,iCAC/B,MAAM,MACN,SAAS,QAAQ,wBAAwB,OACzC,KAAK,YACJ,cAAc,QAAQ,QAAQ,wBAAwB;;EAEzD,YAAY,mBAAmB,+BAC7B,MAAM,MACN,SAAS,QAAQ,sBAAsB,OACvC,KAAK,YACJ,YAAY,QAAQ,QAAQ,sBAAsB;;EAErD,YAAY,mBAAmB,gCAC7B,MAAM,MACN,SAAS,QAAQ,uBAAuB,QACvC,YAAY,QAAQ,QAAQ,uBAAuB;WAC7C,eAAe,EAAE,QAAQ,UAAU,YAAY;WAC/C,aAAa,EAAE,QAAQ,QAAQ,YAAY;WAC3C,aAAa,EAAE,QAAQ,QAAQ,YAAY;;WAE3C,aAAa,EAAE,QACtB,UAAU,YAAY,eAAe,QAAQ,YAAY;;KAIxD;;KAGA,qBAAqB,gBAAgB,8BAC9B,cAAc,gBAAgB,EAAE,OAAO,QAAQ,SAAS,6BAC9D,QAAQ;;KAKT,gBAAgB,mBAAmB;WAC7B,UAAU,qBAAqB;WAC/B,QAAQ,qBAAqB;WAC7B,SAAS,qBAAqB;;;;;;iBA6BzB,qBAAqB,mBAAmB,mBACtD,YAAY,aAAa,gBAAgB,cACxC,YAAY;;;;KCpHH;WAAwB;;;;;;;uBAOd,OAAO,aAAa,YAAY,eAAe,cAAc;UACzE;oBAEU,IAAI;;YAGZ,SAAS,OAAO;;EAK1B,iBAAiB,cAAc;;EAK/B;;WAKS,iBAAiB;;;;;iBCbZ,aAAa;;iBAKb,0BAA0B;;;;cCpB7B;WACX,uBAAqB;WACrB,aAAW;WACX,iBAAe;WACf,aAAW;WACX,mBAAiB;;;iBAgBH,2BAA2B;;iBAK3B,4BAA4B;;iBAK5B,6BAA6B;;iBAK7B,kCAAkC;;;;KC3BtC,2BAA2B,mBAAmB;;;;;iBAM1C,sBAAsB;WAC3B;WACA,kBAAkB;WAClB;IACP;;;;;iBAwBY,gBAAgB,iBAAiB;;iBAUjC,oBAAoB;;;;iBCrDpB,eAAe;;;;;iBAWf,yBACd,qBACA,oBACA;;;;;;;;;;KCTU,0DAMR,cAAc,YACd;;KAGQ;YAAwB,cAAc;;;;;;;cAOrC;WACX;WACA;WACA;WACA;;KAEU,mBAAmB,uBAAuB;;KAG1C;WACD;WACA;WACA;WACA,SAAS;WACT,QAAQ;WACR,SAAS,cAAc;;;KAItB;WACD;WACA,OAAO;WACP;WACA;WACA,SAAS;WACT;;WAEA,QAAQ;;;KAIP;WACD;WACA;WACA,UAAU;;;KAIT,eAAe;;UAGV;WACN,QAAQ;;;KAIP;;;;;;;UAQK,uBAAuB;WAC7B,SAAS;;;;;;iBAgBJ,gBAAgB,QAAQ;;UAQvB;WACN;WACA;WACA,SAAS;;;KAIR,mBAAmB,OAAO;;KAG1B,WAAW,OAAO;;;;;;iBASd,mBAAmB,IAAI;;;;;cA0C1B,aAAa;;;;;;;iBA6BV,WAAW,IAAI;;cAyDlB;mBAKQ;mBAJF;;EAGjB,YACmB,gBACjB,iBAAiB;UAKX;;EAuBR,MAAM,iBAAiB,UAAS;;EAKhC,KAAK,iBAAiB,UAAS;;EAK/B,KAAK,iBAAiB,UAAS;;;;;;;EAU/B,MAAM,iBAAiB,UAAS;;;iBAyBlB,aAAa,gBAAgB,SAAS,eAAe"}

package/dist/index-_Cihfq1J.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-_Cihfq1J.d.ts","names":[],"sources":["../src/application/handlers.ts","../src/application/message-store.ts","../src/application/registry.ts","../src/application/message-bus.ts","../src/application/outbox-relay.ts","../src/application/transaction.ts","../src/application/event-collector.ts","../src/application/unit-of-work.ts","../src/application/message-already-processed.error.ts","../src/application/unit-of-work.errors.ts"],"mappings":";;;;;;KAMY,eAAe,iBAAiB,eAAe,MAAM,UAC/D,SAAS,UACT,MAAM,SACH,QAAQ;;;;;KAMD,aAAa,eAAe,aAAa,WAAW,UAC9D,OAAO,QACP,MAAM,cACH,QAAQ;;KAGD,aAAa,eAAe,aAAa,SACnD,OAAO,QACP,MAAM,SACH;;;;;;;UClBY;;EAEf,MAAM,WAAW,YAAY;;EAE7B,cAAc,QAAQ,cAAc,eAAe;;;;;KCLzC,gBAAgB,iBAAiB,eAAe,oBAChD,KAAK,YAAY,YAAY,eAAe,GAAG;;KAI/C,cAAc,eAAe,aAAa,yBAC1C,KAAK,UAAU,YAAY,aAAa,GAAG;;;;;KAO3C,cAAc,eAAe,aAAa,oBAC1C,KAAK,UAAU,aAAa,cAAc,aAAa,GAAG;;;;;;KAQ1D,gBAAgB,iBAAiB,eAAe,aAAa,WAAW;WACzE,UAAU,gBAAgB,QAAQ,UAAU,gBAAgB;WAC5D,SAAS,cAAc,QAAQ,UAAU,cAAc;WACvD,QAAQ,cAAc,QAAQ,UAAU,cAAc;;KAK5D,KAAK;EAAU,OAAO,SAAS,eAAe,MAAM,OAAO;;KAC3D,aAAa;EAAU,OAAO,OAAO,aAAa,MAAM,OAAO;;;;;;KAMxD,SAAS;WACV,UAAU,SAAS,eAAe,KAAK;WACvC,SAAS,SAAS,eAAe,KAAK;WACtC,QAAQ,SAAS,QAAQ,eAAe,cAAc,aAAa;;KAGzE,YAAY,UAAU,WAAW,QAAQ,aAAa,SAAS;KAE/D,oBAAoB,UACvB,YAAY,aAAa,iBAAiB,oBAAoB,iBAC1D,WAAW,QAAQ,eAAe;;KAI5B,gBAAgB,kBAAkB,mBAC1C,YAAY,yBACZ,YAAY,wBACZ,oBAAoB;KAEnB,UAAU,QAAQ,wBAAwB,oBAAoB,SAC/D,QAAQ,WAAW,QAAQ,OAAO,QAAQ;;KAIlC,cACV,iBAAiB,eACjB,kBAAkB,mBAChB,iBAAiB,gBACjB,UAAU,uBAAuB,oBACjC,iBAAiB,cACf,UAAU,sBAAsB;;;;UCvDrB,YAAY,kBAAkB;EAC7C,OAAO,iBAAiB,gBAAgB,gBAAgB,YACtD,SAAS,WACR,QAAQ,cAAc,UAAU;;;;;;cAOxB,WAAW,MAAM,kBAAkB,SAAS,kBAAkB,YAAY;mBAElE;mBACA;EAFnB,YACmB,MAAM,MACN,UAAU;;EAIvB,OAAO,iBAAiB,gBAAgB,gBAAgB,YAC5D,SAAS,WACR,QAAQ,cAAc,UAAU;UAM3B;UASA;UASA;;;;;;UAWM;;;;;;;;;UClEC;EACf;;;;;;;;;UCDe,aAAa;EAC5B,YAAY,GAAG,OAAO,IAAI,OAAO,QAAQ,KAAK,QAAQ;;;;;UCHvC;EACf,KAAK,OAAO;EACZ,WAAW,cAAc;;;;;;;;;UCQV,YAAY;EAC3B,IAAI,GAAG,WAAW,WAAW,OAAO,OAAO,UAAU,QAAQ,KAAK,QAAQ;;KAGhE,eAAe,IAAI;WACpB,aAAa,aAAa;;WAE1B,eAAe,IAAI,OAAO;;WAE1B,qBAAqB,IAAI,OAAO;WAChC,gBAAgB;WAChB,OAAO;;;cAIL,WAAW,IAAI,kBAAkB,YAAY;mBAC3B;EAA7B,YAA6B,MAAM,eAAe,IAAI;EAEhD,IAAI,GAAG,WAAW,WAAW,OAAO,OAAO,UAAU,QAAQ,KAAK,QAAQ;;;;;cC5BrE,qCAAqC;WAKrC,WAAW;WAJb;WACA;EAET,YACW,WAAW,WACpB;aAAqB;;;SAMhB,KAAK,gBAAgB,WAAW,YAAY;;;;;cCZxC,qCAAqC;WACvC;WACA;EAET"}