@visulima/email 1.0.0-alpha.8 → 1.0.0

package/dist/providers/sendgrid/index.d.ts

@@ -1,3 +1,84 @@
-export type { Provider, ProviderFactory } from "../provider.d.ts";
-export { default as sendGridProvider } from "./providers/sendgrid/provider.d.ts";
-export type { SendGridConfig, SendGridEmailOptions } from "./types.d.ts";
+import { P as ProviderFactory } from "../../packem_shared/provider.d-J-y6iogK.js";
+export type { a as Provider } from "../../packem_shared/provider.d-J-y6iogK.js";
+import { B as BaseConfig, E as EmailOptions } from "../../packem_shared/types.d-ejzh-xBP.js";
+import 'node:buffer';
+/**
+* SendGrid configuration
+*/
+interface SendGridConfig extends BaseConfig {
+  apiKey: string;
+  endpoint?: string;
+}
+/**
+* SendGrid-specific email options
+*/
+interface SendGridEmailOptions extends EmailOptions {
+  /**
+  * ASM (Advanced Suppression Management) group ID for unsubscribe
+  */
+  asmGroupId?: number;
+  /**
+  * Batch ID for batch sending
+  */
+  batchId?: string;
+  /**
+  * IP pool name
+  */
+  ipPoolName?: string;
+  /**
+  * Mail settings (click tracking, open tracking, etc.)
+  */
+  mailSettings?: {
+    bypassListManagement?: boolean;
+    footer?: {
+      enable?: boolean;
+      html?: string;
+      text?: string;
+    };
+    sandboxMode?: boolean;
+  };
+  /**
+  * Send at timestamp (Unix timestamp)
+  */
+  sendAt?: number;
+  /**
+  * Dynamic template data for SendGrid dynamic templates
+  */
+  templateData?: Record<string, unknown>;
+  /**
+  * SendGrid template ID for template-based emails
+  */
+  templateId?: string;
+  /**
+  * Tracking settings
+  */
+  trackingSettings?: {
+    clickTracking?: {
+      enable?: boolean;
+      enableText?: boolean;
+    };
+    ganalytics?: {
+      enable?: boolean;
+      utmCampaign?: string;
+      utmContent?: string;
+      utmMedium?: string;
+      utmSource?: string;
+      utmTerm?: string;
+    };
+    openTracking?: {
+      enable?: boolean;
+      substitutionTag?: string;
+    };
+    subscriptionTracking?: {
+      enable?: boolean;
+      html?: string;
+      substitutionTag?: string;
+      text?: string;
+    };
+  };
+}
+/**
+* SendGrid Provider for sending emails through SendGrid API
+*/
+declare const sendGridProvider: ProviderFactory<SendGridConfig>;
+export { type ProviderFactory, type SendGridConfig, type SendGridEmailOptions, sendGridProvider };

package/dist/providers/sendgrid/index.js

@@ -1 +1 @@
-import{default as e}from"../../packem_shared/sendGridProvider-BVI1sq3n.js";export{e as sendGridProvider};
+import{default as e}from"../../packem_shared/sendGridProvider-D8ZLgY62.js";export{e as sendGridProvider};

package/dist/providers/smtp/index.d.ts

@@ -1,3 +1,71 @@
-export type { Provider, ProviderFactory } from "../provider.d.ts";
-export { default as smtpProvider } from "./providers/smtp/provider.d.ts";
-export type { SmtpConfig, SmtpEmailOptions } from "./types.d.ts";
+import { P as ProviderFactory } from "../../packem_shared/provider.d-J-y6iogK.js";
+export type { a as Provider } from "../../packem_shared/provider.d-J-y6iogK.js";
+import { B as BaseConfig, E as EmailOptions } from "../../packem_shared/types.d-ejzh-xBP.js";
+import 'node:buffer';
+/**
+* SMTP configuration
+*/
+interface SmtpConfig extends BaseConfig {
+  authMethod?: "LOGIN" | "PLAIN" | "CRAM-MD5" | "OAUTH2";
+  dkim?: {
+    domainName: string;
+    keySelector: string;
+    privateKey: string;
+  };
+  host: string;
+  maxConnections?: number;
+  oauth2?: {
+    accessToken?: string;
+    clientId: string;
+    clientSecret: string;
+    expires?: number;
+    refreshToken: string;
+    user: string;
+  };
+  password?: string;
+  pool?: boolean;
+  port: number;
+  rejectUnauthorized?: boolean;
+  secure?: boolean;
+  user?: string;
+}
+/**
+* SMTP-specific email options
+*/
+interface SmtpEmailOptions extends EmailOptions {
+  /**
+  * Delivery Status Notification options
+  */
+  dsn?: {
+    /** Request notification on delay */
+    delay?: boolean;
+    /** Request notification on failure */
+    failure?: boolean;
+    /** Request successful delivery notification */
+    success?: boolean;
+  };
+  /** Special Google Mail headers */
+  googleMailHeaders?: {
+    /** Category for email organization */
+    category?: "primary" | "social" | "promotions" | "updates" | "forums";
+    /** Feedback ID for engagement tracking */
+    feedbackId?: string;
+    /** Mark as promotional content */
+    promotionalContent?: boolean;
+  };
+  /** Reference to a previous message ID (for threading) */
+  inReplyTo?: string;
+  /** List-Unsubscribe header for easy unsubscribe functionality */
+  listUnsubscribe?: string | string[];
+  /** Message priority: 'high', 'normal', or 'low' */
+  priority?: "high" | "normal" | "low";
+  /** References to related message IDs */
+  references?: string | string[];
+  /** Whether to sign the email with DKIM */
+  useDkim?: boolean;
+}
+/**
+* SMTP provider for sending emails via SMTP protocol
+*/
+declare const smtpProvider: ProviderFactory<SmtpConfig>;
+export { type ProviderFactory, type SmtpConfig, type SmtpEmailOptions, smtpProvider };

package/dist/providers/smtp/index.js

@@ -1 +1 @@
-import{default as o}from"../../packem_shared/smtpProvider-BV-ufR53.js";export{o as smtpProvider};
+import{default as o}from"../../packem_shared/smtpProvider-Bm0yP97W.js";export{o as smtpProvider};

package/dist/providers/sparkpost/index.d.ts

@@ -0,0 +1,43 @@
+import { P as ProviderFactory } from "../../packem_shared/provider.d-J-y6iogK.js";
+export type { a as Provider } from "../../packem_shared/provider.d-J-y6iogK.js";
+import { B as BaseConfig, E as EmailOptions } from "../../packem_shared/types.d-ejzh-xBP.js";
+import 'node:buffer';
+/**
+* SparkPost configuration.
+*/
+interface SparkPostConfig extends BaseConfig {
+  /**
+  * SparkPost API key (sent as the `Authorization` header).
+  */
+  apiKey: string;
+  /**
+  * API endpoint override. Use `https://api.eu.sparkpost.com/api/v1` for the EU region.
+  */
+  endpoint?: string;
+}
+/**
+* SparkPost-specific email options.
+*/
+interface SparkPostEmailOptions extends EmailOptions {
+  /**
+  * Campaign id applied to the transmission.
+  */
+  campaignId?: string;
+  /**
+  * Stored template id to send instead of inline content.
+  */
+  templateId?: string;
+  /**
+  * Whether click tracking is enabled.
+  */
+  trackClicks?: boolean;
+  /**
+  * Whether engagement tracking (opens/clicks) is enabled.
+  */
+  trackOpens?: boolean;
+}
+/**
+* SparkPost provider — sends email through the SparkPost Transmissions API.
+*/
+declare const sparkpostProvider: ProviderFactory<SparkPostConfig>;
+export { type ProviderFactory, type SparkPostConfig, type SparkPostEmailOptions, sparkpostProvider };

package/dist/providers/sparkpost/index.js

@@ -0,0 +1 @@
+import{default as a}from"../../packem_shared/sparkpostProvider-CTYfSRaV.js";export{a as sparkpostProvider};

package/dist/providers/sweego/index.d.ts

@@ -1,3 +1,40 @@
-export type { Provider, ProviderFactory } from "../provider.d.ts";
-export { default as sweegoProvider } from "./providers/sweego/provider.d.ts";
-export type { SweegoConfig, SweegoEmailOptions } from "./types.d.ts";
+import { P as ProviderFactory } from "../../packem_shared/provider.d-J-y6iogK.js";
+export type { a as Provider } from "../../packem_shared/provider.d-J-y6iogK.js";
+import { B as BaseConfig, E as EmailOptions } from "../../packem_shared/types.d-ejzh-xBP.js";
+import 'node:buffer';
+/**
+* Sweego configuration
+*/
+interface SweegoConfig extends BaseConfig {
+  /**
+  * Sweego API key
+  */
+  apiKey: string;
+  /**
+  * Sweego API endpoint
+  * Defaults to: https://api.sweego.com
+  */
+  endpoint?: string;
+}
+/**
+* Sweego-specific email options
+*/
+interface SweegoEmailOptions extends EmailOptions {
+  /**
+  * Tags for categorization
+  */
+  tags?: string[];
+  /**
+  * Sweego template ID for template-based emails
+  */
+  templateId?: string;
+  /**
+  * Template variables for Sweego templates
+  */
+  templateVariables?: Record<string, unknown>;
+}
+/**
+* Sweego Provider for sending emails through Sweego API
+*/
+declare const sweegoProvider: ProviderFactory<SweegoConfig>;
+export { type ProviderFactory, type SweegoConfig, type SweegoEmailOptions, sweegoProvider };

package/dist/providers/sweego/index.js

@@ -1 +1 @@
-import{default as r}from"../../packem_shared/sweegoProvider-7419CSAq.js";export{r as sweegoProvider};
+import{default as r}from"../../packem_shared/sweegoProvider-DOoin_vi.js";export{r as sweegoProvider};

package/dist/providers/zeptomail/index.d.ts

@@ -1,3 +1,37 @@
-export type { Provider, ProviderFactory } from "../provider.d.ts";
-export { default as zeptomailProvider } from "./providers/zeptomail/provider.d.ts";
-export type { ZeptomailConfig, ZeptomailEmailOptions } from "./types.d.ts";
+import { P as ProviderFactory } from "../../packem_shared/provider.d-J-y6iogK.js";
+export type { a as Provider } from "../../packem_shared/provider.d-J-y6iogK.js";
+import { B as BaseConfig, E as EmailOptions } from "../../packem_shared/types.d-ejzh-xBP.js";
+import 'node:buffer';
+/**
+* Zeptomail configuration
+*/
+interface ZeptomailConfig extends BaseConfig {
+  endpoint?: string;
+  token: string;
+}
+/**
+* Zeptomail-specific email options
+*/
+interface ZeptomailEmailOptions extends EmailOptions {
+  /**
+  * Client reference - identifier set by the user to track a particular transaction
+  */
+  clientReference?: string;
+  /**
+  * MIME headers - additional headers sent in the email for reference
+  */
+  mimeHeaders?: Record<string, string>;
+  /**
+  * Track email clicks - enables tracking for click events
+  */
+  trackClicks?: boolean;
+  /**
+  * Track email opens - enables tracking for open events
+  */
+  trackOpens?: boolean;
+}
+/**
+* Zeptomail Provider for sending emails through Zeptomail API
+*/
+declare const zeptomailProvider: ProviderFactory<ZeptomailConfig>;
+export { type ProviderFactory, type ZeptomailConfig, type ZeptomailEmailOptions, zeptomailProvider };

package/dist/providers/zeptomail/index.js

@@ -1 +1 @@
-import{default as r}from"../../packem_shared/zeptomailProvider-C2lh0Xmo.js";export{r as zeptomailProvider};
+import{default as r}from"../../packem_shared/zeptomailProvider-DKBPSHPj.js";export{r as zeptomailProvider};

package/dist/queue/bullmq-queue.d.ts

@@ -0,0 +1,46 @@
+import { E as EmailOptions, a as EmailResult, R as Result } from "../packem_shared/types.d-ejzh-xBP.js";
+import { E as EnqueueOptions } from "../packem_shared/types.d-lcJZmwRK.js";
+import 'node:buffer';
+/**
+* The subset of a [BullMQ](https://docs.bullmq.io/) `Queue` this adapter uses.
+*/
+interface BullmqQueueLike {
+  add: (name: string, data: unknown, options?: {
+    delay?: number;
+  }) => Promise<{
+    id?: string;
+  }>;
+}
+/**
+* A BullMQ job, narrowed to its `data` payload.
+*/
+interface BullmqJobLike {
+  data: EmailOptions;
+}
+/**
+* A BullMQ `Worker` processor that sends a job's message and resolves with the send result.
+*/
+type BullmqProcessor = (job: BullmqJobLike) => Promise<EmailResult>;
+/**
+* Adds a message to a BullMQ queue.
+*
+* BullMQ is push-based — jobs are consumed by a BullMQ `Worker`, not the pull-based reserve/ack model
+* of `EmailQueue`. Use this to enqueue and {@link createBullmqProcessor} to consume.
+* @param queue A BullMQ `Queue` instance to add the job to (optional peer).
+* @param message The email payload stored as the BullMQ job data.
+* @param options Optional scheduling — `scheduledAt` maps to a BullMQ `delay`.
+* @param jobName The name to enqueue the job under.
+* @returns The id of the created BullMQ job.
+*/
+declare const enqueueToBullmq: (queue: BullmqQueueLike, message: EmailOptions, options?: EnqueueOptions, jobName?: string) => Promise<string>;
+/**
+* Builds a BullMQ `Worker` processor that sends each job's message via the given send function.
+*
+* Pass it to `new Worker(queueName, createBullmqProcessor(mail.send.bind(mail)), { concurrency })`.
+* BullMQ then handles concurrency, retries (via the job's `attempts`/`backoff`) and dead-lettering. A
+* failed send throws so BullMQ records the attempt.
+* @param send The send function — typically `mail.send.bind(mail)`.
+* @returns A BullMQ processor function.
+*/
+declare const createBullmqProcessor: (send: (message: EmailOptions) => Promise<Result<EmailResult>>) => BullmqProcessor;
+export { BullmqJobLike, BullmqProcessor, BullmqQueueLike, createBullmqProcessor, enqueueToBullmq };

package/dist/queue/bullmq-queue.js

@@ -0,0 +1 @@
+const s=async(a,t,e={},d="email")=>{let r;if(e.scheduledAt!==void 0){const o=e.scheduledAt instanceof Date?e.scheduledAt.getTime():e.scheduledAt;r=Math.max(0,o-Date.now())}return(await a.add(d,t,r===void 0?void 0:{delay:r})).id??""},c=a=>async t=>{const e=await a(t.data);if(!e.success||!e.data)throw e.error instanceof Error?e.error:new Error("Email send failed");return e.data};export{c as createBullmqProcessor,s as enqueueToBullmq};

package/dist/queue/index.d.ts

@@ -0,0 +1,147 @@
+import { E as EmailOptions, a as EmailResult, R as Result } from "../packem_shared/types.d-ejzh-xBP.js";
+import { E as EnqueueOptions, Q as QueueJob, a as EmailQueue } from "../packem_shared/types.d-lcJZmwRK.js";
+export { UnstorageQueue, type UnstorageQueueOptions, createUnstorageQueue } from "./unstorage-queue.js";
+import 'node:buffer';
+/**
+* Options for {@link MemoryQueue}.
+*/
+interface MemoryQueueOptions {
+  /**
+  * Time source in milliseconds — injectable for tests. Defaults to `Date.now`.
+  */
+  now?: () => number;
+  /**
+  * How long, in milliseconds, a reserved job stays hidden before it becomes deliverable again
+  * (in case the worker crashed mid-process).
+  * @default 30000
+  */
+  visibilityTimeout?: number;
+}
+/**
+* An in-memory {@link EmailQueue} with `scheduledAt` support and a reservation visibility timeout.
+*
+* Suitable for tests, single-process apps, and as a reference for adapter authors. Jobs do not survive
+* a process restart — use a durable adapter in production.
+*/
+declare class MemoryQueue implements EmailQueue {
+  private readonly jobs;
+  private readonly visibilityTimeout;
+  private readonly now;
+  private sequence;
+  /**
+  * @param options Queue options. See {@link MemoryQueueOptions}.
+  */
+  constructor(options?: MemoryQueueOptions);
+  /**
+  * Adds a message to the queue.
+  * @param message The message to send later.
+  * @param options Optional scheduling. See {@link EnqueueOptions}.
+  * @returns The new job id.
+  */
+  enqueue(message: EmailOptions, options?: EnqueueOptions): string;
+  /**
+  * Reserves the next ready job, hiding it for the visibility window.
+  * @returns The next deliverable job, or `undefined` when none is ready.
+  */
+  reserve(): QueueJob | undefined;
+  /**
+  * Marks a reserved job as processed and removes it.
+  * @param id The job id.
+  */
+  ack(id: string): void;
+  /**
+  * Returns a job to the queue after a delay, incrementing its attempt count.
+  * @param id The job id.
+  * @param delayMs Milliseconds to wait before the job becomes ready again.
+  */
+  retry(id: string, delayMs?: number): void;
+  /**
+  * Reports how many jobs remain (ready plus reserved).
+  * @returns The count of ready and reserved jobs.
+  */
+  size(): number;
+}
+/**
+* Options for {@link createWorker}.
+*/
+interface WorkerOptions {
+  /**
+  * Retry backoff: returns the delay (ms) before re-attempting after `attempts` failures.
+  * @default attempts => 1000 * 2 ** (attempts - 1)
+  */
+  backoff?: (attempts: number) => number;
+  /**
+  * How many jobs to process concurrently.
+  * @default 1
+  */
+  concurrency?: number;
+  /**
+  * Maximum delivery attempts before a job is dead-lettered.
+  * @default 3
+  */
+  maxAttempts?: number;
+  /**
+  * Called when a job exhausts its attempts and is dropped.
+  * @param job The dead-lettered job.
+  * @param result The final failed result.
+  */
+  onDeadLetter?: (job: QueueJob, result: Result<EmailResult>) => void;
+  /**
+  * Called on every failed attempt (before any retry).
+  * @param job The job that failed.
+  * @param result The failed result (or thrown error wrapped).
+  */
+  onError?: (job: QueueJob, result: Result<EmailResult>) => void;
+  /**
+  * Called when `queue.reserve()` itself rejects (e.g. a transient store error). The poll loop keeps
+  * running regardless; this hook just surfaces the failure.
+  * @param error The reserve error.
+  */
+  onReserveError?: (error: Error) => void;
+  /**
+  * Idle poll interval, in milliseconds, when no job is ready.
+  * @default 1000
+  */
+  pollInterval?: number;
+  /**
+  * The queue to consume.
+  */
+  queue: EmailQueue;
+  /**
+  * The send function — typically `mail.send.bind(mail)`.
+  */
+  send: (message: EmailOptions) => Promise<Result<EmailResult>>;
+}
+/**
+* A running queue worker.
+*/
+interface Worker {
+  /**
+  * Processes ready jobs until the queue has none currently deliverable, then resolves.
+  *
+  * Does not wait for future-scheduled jobs. Useful in tests and one-shot drains.
+  */
+  drain: () => Promise<void>;
+  /**
+  * Begins polling and processing jobs in the background.
+  */
+  start: () => void;
+  /**
+  * Stops polling. In-flight jobs are allowed to finish.
+  */
+  stop: () => void;
+}
+/**
+* Creates a worker that durably processes queued messages with bounded concurrency, retry/backoff, and
+* dead-lettering.
+* @param options Worker configuration. See {@link WorkerOptions}.
+* @returns The worker handle. See {@link Worker}.
+* @example
+* ```ts
+* const queue = new MemoryQueue();
+* const worker = createWorker({ queue, send: mail.send.bind(mail), concurrency: 5 });
+* worker.start();
+* ```
+*/
+declare const createWorker: (options: WorkerOptions) => Worker;
+export { type EmailQueue, type EnqueueOptions, MemoryQueue, type MemoryQueueOptions, type QueueJob, type Worker, type WorkerOptions, createWorker };

package/dist/queue/index.js

@@ -0,0 +1 @@
+import{MemoryQueue as o}from"../packem_shared/MemoryQueue-Dl1Fa6OJ.js";import{UnstorageQueue as u,createUnstorageQueue as a}from"./unstorage-queue.js";import{createWorker as f}from"../packem_shared/createWorker-_-yMWcNQ.js";export{o as MemoryQueue,u as UnstorageQueue,a as createUnstorageQueue,f as createWorker};

package/dist/queue/pg-boss-queue.d.ts

@@ -0,0 +1,41 @@
+import { a as EmailQueue } from "../packem_shared/types.d-lcJZmwRK.js";
+import "../packem_shared/types.d-ejzh-xBP.js";
+import 'node:buffer';
+interface PgBossJob {
+  data: unknown;
+  id: string;
+  /** pg-boss retry count (present when fetched with `includeMetadata`). */
+  retryCount?: number;
+}
+/**
+* The subset of a [pg-boss](https://github.com/timgit/pg-boss) instance this adapter uses (v10 API).
+*/
+interface PgBossLike {
+  complete: (name: string, id: string) => Promise<unknown>;
+  fail: (name: string, id: string) => Promise<unknown>;
+  fetch: (name: string, options?: {
+    batchSize?: number;
+    includeMetadata?: boolean;
+  }) => Promise<PgBossJob[] | PgBossJob | null>;
+  getQueueSize: (name: string) => Promise<number>;
+  send: (name: string, data: object, options?: {
+    startAfter?: Date | number | string;
+  }) => Promise<null | string>;
+}
+/**
+* Options for {@link createPgBossQueue}.
+*/
+interface PgBossQueueOptions {
+  /**
+  * The pg-boss queue name.
+  */
+  queueName: string;
+}
+/**
+* Creates an {@link EmailQueue} backed by pg-boss.
+* @param boss A started pg-boss instance (optional peer).
+* @param options Queue options. See {@link PgBossQueueOptions}.
+* @returns The pg-boss-backed queue.
+*/
+declare const createPgBossQueue: (boss: PgBossLike, options: PgBossQueueOptions) => EmailQueue;
+export { type PgBossLike, type PgBossQueueOptions, createPgBossQueue };

package/dist/queue/pg-boss-queue.js

@@ -0,0 +1 @@
+class u{boss;queueName;constructor(e,s){this.boss=e,this.queueName=s.queueName}async enqueue(e,s={}){const a=s.scheduledAt;return await this.boss.send(this.queueName,e,a===void 0?void 0:{startAfter:a})??""}async reserve(){const e=await this.boss.fetch(this.queueName,{batchSize:1,includeMetadata:!0});if(!e)return;const s=Array.isArray(e)?e[0]:e;if(s)return{attempts:s.retryCount??0,id:s.id,message:s.data,scheduledAt:0}}async ack(e){await this.boss.complete(this.queueName,e)}async retry(e){await this.boss.fail(this.queueName,e)}async size(){return this.boss.getQueueSize(this.queueName)}}const i=(t,e)=>new u(t,e);export{i as createPgBossQueue};

package/dist/queue/sqs-queue.d.ts

@@ -0,0 +1,72 @@
+import { a as EmailQueue } from "../packem_shared/types.d-lcJZmwRK.js";
+import "../packem_shared/types.d-ejzh-xBP.js";
+import 'node:buffer';
+/**
+* The subset of the `@aws-sdk/client-sqs` `SQS` client this adapter uses. The `SQS` class (not the
+* lower-level `SQSClient`) exposes these operation methods directly.
+*/
+interface SqsClientLike {
+  changeMessageVisibility: (input: {
+    QueueUrl: string;
+    ReceiptHandle: string;
+    VisibilityTimeout: number;
+  }) => Promise<unknown>;
+  deleteMessage: (input: {
+    QueueUrl: string;
+    ReceiptHandle: string;
+  }) => Promise<unknown>;
+  getQueueAttributes: (input: {
+    AttributeNames: string[];
+    QueueUrl: string;
+  }) => Promise<{
+    Attributes?: Record<string, string>;
+  }>;
+  receiveMessage: (input: {
+    AttributeNames?: string[];
+    MaxNumberOfMessages?: number;
+    QueueUrl: string;
+    VisibilityTimeout?: number;
+    WaitTimeSeconds?: number;
+  }) => Promise<{
+    Messages?: {
+      Attributes?: Record<string, string>;
+      Body?: string;
+      MessageId?: string;
+      ReceiptHandle?: string;
+    }[];
+  }>;
+  sendMessage: (input: {
+    DelaySeconds?: number;
+    MessageBody: string;
+    QueueUrl: string;
+  }) => Promise<{
+    MessageId?: string;
+  }>;
+}
+/**
+* Options for {@link createSqsQueue}.
+*/
+interface SqsQueueOptions {
+  /**
+  * The SQS queue URL.
+  */
+  queueUrl: string;
+  /**
+  * Visibility timeout (seconds) applied when reserving a message.
+  * @default 30
+  */
+  visibilityTimeout?: number;
+  /**
+  * Long-poll wait time (seconds) for `reserve`.
+  * @default 0
+  */
+  waitTimeSeconds?: number;
+}
+/**
+* Creates an {@link EmailQueue} backed by Amazon SQS.
+* @param client An `@aws-sdk/client-sqs` `SQS` instance (optional peer).
+* @param options Queue options. See {@link SqsQueueOptions}.
+* @returns The SQS-backed queue.
+*/
+declare const createSqsQueue: (client: SqsClientLike, options: SqsQueueOptions) => EmailQueue;
+export { type SqsClientLike, type SqsQueueOptions, createSqsQueue };

package/dist/queue/sqs-queue.js

@@ -0,0 +1 @@
+const a="ApproximateNumberOfMessages",u="ApproximateNumberOfMessagesNotVisible",r=(i,e)=>{if(i===void 0)return 0;const t=i instanceof Date?i.getTime():i,s=Math.ceil((t-e)/1e3);return Math.max(0,s)};class n{client;queueUrl;visibilityTimeout;waitTimeSeconds;constructor(e,t){this.client=e,this.queueUrl=t.queueUrl,this.visibilityTimeout=t.visibilityTimeout??30,this.waitTimeSeconds=t.waitTimeSeconds??0}async enqueue(e,t={}){const s=r(t.scheduledAt,Date.now());if(s>900)throw new RangeError(`SQS supports a maximum scheduling delay of ${String(900)}s (15 minutes); use a scheduler for longer delays`);return(await this.client.sendMessage({DelaySeconds:s,MessageBody:JSON.stringify(e),QueueUrl:this.queueUrl})).MessageId??""}async reserve(){const e=(await this.client.receiveMessage({AttributeNames:["ApproximateReceiveCount"],MaxNumberOfMessages:1,QueueUrl:this.queueUrl,VisibilityTimeout:this.visibilityTimeout,WaitTimeSeconds:this.waitTimeSeconds})).Messages?.[0];if(!e?.ReceiptHandle)return;const t=Number(e.Attributes?.ApproximateReceiveCount??"1");let s;try{s=JSON.parse(e.Body??"{}")}catch{await this.client.deleteMessage({QueueUrl:this.queueUrl,ReceiptHandle:e.ReceiptHandle});return}return{attempts:Math.max(0,t-1),id:e.ReceiptHandle,message:s,scheduledAt:0}}async ack(e){await this.client.deleteMessage({QueueUrl:this.queueUrl,ReceiptHandle:e})}async retry(e,t=0){await this.client.changeMessageVisibility({QueueUrl:this.queueUrl,ReceiptHandle:e,VisibilityTimeout:Math.min(900,Math.max(0,Math.ceil(t/1e3)))})}async size(){const e=await this.client.getQueueAttributes({AttributeNames:[a,u],QueueUrl:this.queueUrl});return Number(e.Attributes?.[a]??0)+Number(e.Attributes?.[u]??0)}}const l=(i,e)=>new n(i,e);export{l as createSqsQueue};