@crvouga/mockingbird-service-resend 3.1.0 → 3.2.0

package/dist/server.d.ts

@@ -1,34 +1,16 @@
 import { Server } from 'node:http';
 import { Hono } from 'hono';
 
-/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
-type SqliteValue$2 = null | number | bigint | string | Uint8Array | boolean;
-/** Mutation counters returned by {@link SqliteStatement.run}. */
-type SqliteRunResult$2 = {
-    changes: number;
-    lastInsertRowid: number | bigint;
+type MountedAPI$1 = FetchAPI$2 & {
+    readonly prefix: string;
+    GET: FetchHandler$1;
+    POST: FetchHandler$1;
+    PUT: FetchHandler$1;
+    PATCH: FetchHandler$1;
+    DELETE: FetchHandler$1;
+    HEAD: FetchHandler$1;
+    OPTIONS: FetchHandler$1;
 };
-/**
- * Prepared statement bound to a {@link SqliteClient}.
- *
- * Pass bind values as rest arguments on each call (no sticky `bind()`).
- */
-interface SqliteStatement$2 {
-    run(...params: SqliteValue$2[]): SqliteRunResult$2;
-    all<T = Record<string, unknown>>(...params: SqliteValue$2[]): T[];
-    get<T = Record<string, unknown>>(...params: SqliteValue$2[]): T | undefined;
-}
-/**
- * Sync SQLite client port owned by Mockingbird.
- *
- * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
- * `bun:sqlite` instances all work when they expose this surface.
- */
-interface SqliteClient$2 {
-    exec(sql: string): void;
-    prepare(sql: string): SqliteStatement$2;
-    transaction<T>(fn: () => T): T;
-}
 
 /** A stable identifier for a point in a {@link Timeline}. */
 type CheckpointId$1 = string;
@@ -119,6 +101,37 @@ declare class Timeline$1<T> {
 interface FetchAPI$2 {
     fetch(request: Request): Promise<Response>;
 }
+/** A bare function form of {@link FetchAPI}, compatible with `Bun.serve`, workerd, and Deno. */
+type FetchHandler$1 = (request: Request) => Promise<Response>;
+
+/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
+type SqliteValue$3 = null | number | bigint | string | Uint8Array | boolean;
+/** Mutation counters returned by {@link SqliteStatement.run}. */
+type SqliteRunResult$3 = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/**
+ * Prepared statement bound to a {@link SqliteClient}.
+ *
+ * Pass bind values as rest arguments on each call (no sticky `bind()`).
+ */
+interface SqliteStatement$3 {
+    run(...params: SqliteValue$3[]): SqliteRunResult$3;
+    all<T = Record<string, unknown>>(...params: SqliteValue$3[]): T[];
+    get<T = Record<string, unknown>>(...params: SqliteValue$3[]): T | undefined;
+}
+/**
+ * Sync SQLite client port owned by Mockingbird.
+ *
+ * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
+ * `bun:sqlite` instances all work when they expose this surface.
+ */
+interface SqliteClient$3 {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement$3;
+    transaction<T>(fn: () => T): T;
+}
 
 /**
  * The single source of time for a service.
@@ -535,7 +548,9 @@ type ServiceRuntime$1<T extends ServiceInstance$1> = FetchAPI$2 & {
     /** Stop package-owned lifecycle timers when a supervisor closes the runtime. */
     stop?(): void;
     readonly name: string;
-    readonly sqlite: SqliteClient$2;
+    /** Same-origin Fetch handler and App Router method exports, sharing this runtime. */
+    mount(prefix: string): MountedAPI$1;
+    readonly sqlite: SqliteClient$3;
     readonly clock: Clock$1;
     readonly faults: FaultRegistry$1;
     readonly metrics: Metrics$1;
@@ -601,6 +616,9 @@ type CommonServeOptions = {
     adminKey: string | undefined;
     seed: string | undefined;
     onLog: ((entry: RequestLog$1) => void) | undefined;
+    /** Synthetic provider fixture objects supplied by a fleet entry. */
+    fixtures?: Record<string, unknown>;
+    baseUrl?: string;
 };
 /**
  * What a service contributes to `serve`: how to build its runtime from CLI flags,
@@ -619,76 +637,16 @@ type ServeTarget = {
     listening?(server: Listening): void;
 };
 
-/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
-type SqliteValue$1 = null | number | bigint | string | Uint8Array | boolean;
-/** Mutation counters returned by {@link SqliteStatement.run}. */
-type SqliteRunResult$1 = {
-    changes: number;
-    lastInsertRowid: number | bigint;
+type MountedAPI = FetchAPI$1 & {
+    readonly prefix: string;
+    GET: FetchHandler;
+    POST: FetchHandler;
+    PUT: FetchHandler;
+    PATCH: FetchHandler;
+    DELETE: FetchHandler;
+    HEAD: FetchHandler;
+    OPTIONS: FetchHandler;
 };
-/**
- * Prepared statement bound to a {@link SqliteClient}.
- *
- * Pass bind values as rest arguments on each call (no sticky `bind()`).
- */
-interface SqliteStatement$1 {
-    run(...params: SqliteValue$1[]): SqliteRunResult$1;
-    all<T = Record<string, unknown>>(...params: SqliteValue$1[]): T[];
-    get<T = Record<string, unknown>>(...params: SqliteValue$1[]): T | undefined;
-}
-/**
- * Sync SQLite client port owned by Mockingbird.
- *
- * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
- * `bun:sqlite` instances all work when they expose this surface.
- */
-interface SqliteClient$1 {
-    exec(sql: string): void;
-    prepare(sql: string): SqliteStatement$1;
-    transaction<T>(fn: () => T): T;
-}
-
-/** Every stored record carries a monotonically increasing sequence for stable ordering. */
-type Stored<T> = {
-    seq: number;
-    value: T;
-};
-type ListRecordsOptions<T> = {
-    /** Keep only records passing the predicate. */
-    where?: (value: T, seq: number) => boolean;
-    /** Sort order; default newest first. */
-    order?: "newest" | "oldest";
-};
-/**
- * A SQLite-backed table of JSON records addressed by id. Ordering is by insertion
- * sequence, never by id lexicographic order, so list semantics stay stable.
- */
-declare class Collection<T> {
-    private readonly sqlite;
-    /** Storage namespace. Admin introspection uses this to ignore another namespace's tables. */
-    readonly namespace: string;
-    /** Table name inside the namespace. Stable across resets of the rows themselves. */
-    readonly collectionName: string;
-    constructor(sqlite: SqliteClient$1, 
-    /** Storage namespace. Admin introspection uses this to ignore another namespace's tables. */
-    namespace: string, 
-    /** Table name inside the namespace. Stable across resets of the rows themselves. */
-    collectionName: string);
-    private bumpCollectionSeq;
-    nextSequence(): number;
-    get(id: string): T | undefined;
-    has(id: string): boolean;
-    /** Insert a new record, assigning it the next sequence number. */
-    insert(id: string, value: T): Stored<T>;
-    /** Replace an existing record's value, keeping its position. */
-    update(id: string, value: T): Stored<T> | undefined;
-    delete(id: string): boolean;
-    /** How many records the collection holds, without reading them. */
-    count(): number;
-    list(options?: ListRecordsOptions<T>): Array<Stored<T> & {
-        id: string;
-    }>;
-}
 
 /** A stable identifier for a point in a {@link Timeline}. */
 type CheckpointId = string;
@@ -779,11 +737,84 @@ declare class Timeline<T> {
 interface FetchAPI$1 {
     fetch(request: Request): Promise<Response>;
 }
+/** A bare function form of {@link FetchAPI}, compatible with `Bun.serve`, workerd, and Deno. */
+type FetchHandler = (request: Request) => Promise<Response>;
+
+/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
+type SqliteValue$2 = null | number | bigint | string | Uint8Array | boolean;
+/** Mutation counters returned by {@link SqliteStatement.run}. */
+type SqliteRunResult$2 = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/**
+ * Prepared statement bound to a {@link SqliteClient}.
+ *
+ * Pass bind values as rest arguments on each call (no sticky `bind()`).
+ */
+interface SqliteStatement$2 {
+    run(...params: SqliteValue$2[]): SqliteRunResult$2;
+    all<T = Record<string, unknown>>(...params: SqliteValue$2[]): T[];
+    get<T = Record<string, unknown>>(...params: SqliteValue$2[]): T | undefined;
+}
+/**
+ * Sync SQLite client port owned by Mockingbird.
+ *
+ * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
+ * `bun:sqlite` instances all work when they expose this surface.
+ */
+interface SqliteClient$2 {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement$2;
+    transaction<T>(fn: () => T): T;
+}
+
+/** Every stored record carries a monotonically increasing sequence for stable ordering. */
+type Stored<T> = {
+    seq: number;
+    value: T;
+};
+type ListRecordsOptions<T> = {
+    /** Keep only records passing the predicate. */
+    where?: (value: T, seq: number) => boolean;
+    /** Sort order; default newest first. */
+    order?: "newest" | "oldest";
+};
+/**
+ * A SQLite-backed table of JSON records addressed by id. Ordering is by insertion
+ * sequence, never by id lexicographic order, so list semantics stay stable.
+ */
+declare class Collection<T> {
+    private readonly sqlite;
+    /** Storage namespace. Admin introspection uses this to ignore another namespace's tables. */
+    readonly namespace: string;
+    /** Table name inside the namespace. Stable across resets of the rows themselves. */
+    readonly collectionName: string;
+    constructor(sqlite: SqliteClient$2, 
+    /** Storage namespace. Admin introspection uses this to ignore another namespace's tables. */
+    namespace: string, 
+    /** Table name inside the namespace. Stable across resets of the rows themselves. */
+    collectionName: string);
+    private bumpCollectionSeq;
+    nextSequence(): number;
+    get(id: string): T | undefined;
+    has(id: string): boolean;
+    /** Insert a new record, assigning it the next sequence number. */
+    insert(id: string, value: T): Stored<T>;
+    /** Replace an existing record's value, keeping its position. */
+    update(id: string, value: T): Stored<T> | undefined;
+    delete(id: string): boolean;
+    /** How many records the collection holds, without reading them. */
+    count(): number;
+    list(options?: ListRecordsOptions<T>): Array<Stored<T> & {
+        id: string;
+    }>;
+}
 
 /** Options every provider constructor accepts. */
-type APIOptions = {
+type APIOptions$1 = {
     /** Sync SQLite client. Defaults to `@crvouga/mockingbird-service-sqlite`. */
-    sqlite?: SqliteClient$1;
+    sqlite?: SqliteClient$2;
     /** Clock used for `created`-style fields. Default `Date.now`. */
     now?: () => number;
     /**
@@ -1067,7 +1098,7 @@ type IdempotencyErrors = {
 declare class IdempotencyStore {
     private readonly namespace;
     private readonly responses;
-    constructor(sqlite: SqliteClient$1, namespace: string, name?: string);
+    constructor(sqlite: SqliteClient$2, namespace: string, name?: string);
     /**
      * Run `handler` once per `key`. `fingerprint` identifies the request's parameters (e.g.
      * the method, path and canonical body). Only `replayable` responses are stored (default:
@@ -1226,7 +1257,9 @@ type ServiceRuntime<T extends ServiceInstance> = FetchAPI$1 & {
     /** Stop package-owned lifecycle timers when a supervisor closes the runtime. */
     stop?(): void;
     readonly name: string;
-    readonly sqlite: SqliteClient$1;
+    /** Same-origin Fetch handler and App Router method exports, sharing this runtime. */
+    mount(prefix: string): MountedAPI;
+    readonly sqlite: SqliteClient$2;
     readonly clock: Clock;
     readonly faults: FaultRegistry;
     readonly metrics: Metrics;
@@ -1293,7 +1326,7 @@ type OutboxQuery = {
 };
 declare class OutboxStore<T extends OutboxItem = OutboxItem> {
     private readonly items;
-    constructor(sqlite: SqliteClient$1, namespace: string, name?: string);
+    constructor(sqlite: SqliteClient$2, namespace: string, name?: string);
     record(item: T): T;
     get(id: string): T | undefined;
     update(id: string, item: T): void;
@@ -1302,9 +1335,9 @@ declare class OutboxStore<T extends OutboxItem = OutboxItem> {
 }
 
 /** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
-type SqliteValue = null | number | bigint | string | Uint8Array | boolean;
+type SqliteValue$1 = null | number | bigint | string | Uint8Array | boolean;
 /** Mutation counters returned by {@link SqliteStatement.run}. */
-type SqliteRunResult = {
+type SqliteRunResult$1 = {
     changes: number;
     lastInsertRowid: number | bigint;
 };
@@ -1313,10 +1346,10 @@ type SqliteRunResult = {
  *
  * Pass bind values as rest arguments on each call (no sticky `bind()`).
  */
-interface SqliteStatement {
-    run(...params: SqliteValue[]): SqliteRunResult;
-    all<T = Record<string, unknown>>(...params: SqliteValue[]): T[];
-    get<T = Record<string, unknown>>(...params: SqliteValue[]): T | undefined;
+interface SqliteStatement$1 {
+    run(...params: SqliteValue$1[]): SqliteRunResult$1;
+    all<T = Record<string, unknown>>(...params: SqliteValue$1[]): T[];
+    get<T = Record<string, unknown>>(...params: SqliteValue$1[]): T | undefined;
 }
 /**
  * Sync SQLite client port owned by Mockingbird.
@@ -1324,9 +1357,9 @@ interface SqliteStatement {
  * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
  * `bun:sqlite` instances all work when they expose this surface.
  */
-interface SqliteClient {
+interface SqliteClient$1 {
     exec(sql: string): void;
-    prepare(sql: string): SqliteStatement;
+    prepare(sql: string): SqliteStatement$1;
     transaction<T>(fn: () => T): T;
 }
 
@@ -1340,6 +1373,91 @@ interface FetchAPI {
     fetch(request: Request): Promise<Response>;
 }
 
+/** Bind values accepted by Mockingbird's SQLite port (matches sqlite-mem / better-sqlite3). */
+type SqliteValue = null | number | bigint | string | Uint8Array | boolean;
+/** Mutation counters returned by {@link SqliteStatement.run}. */
+type SqliteRunResult = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/**
+ * Prepared statement bound to a {@link SqliteClient}.
+ *
+ * Pass bind values as rest arguments on each call (no sticky `bind()`).
+ */
+interface SqliteStatement {
+    run(...params: SqliteValue[]): SqliteRunResult;
+    all<T = Record<string, unknown>>(...params: SqliteValue[]): T[];
+    get<T = Record<string, unknown>>(...params: SqliteValue[]): T | undefined;
+}
+/**
+ * Sync SQLite client port owned by Mockingbird.
+ *
+ * Duck-typed so `@crvouga/mockingbird-service-sqlite` `Database`, better-sqlite3, and wrapped
+ * `bun:sqlite` instances all work when they expose this surface.
+ */
+interface SqliteClient {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement;
+    transaction<T>(fn: () => T): T;
+}
+
+/** Options every provider constructor accepts. */
+type APIOptions = {
+    /** Sync SQLite client. Defaults to `@crvouga/mockingbird-service-sqlite`. */
+    sqlite?: SqliteClient;
+    /** Clock used for `created`-style fields. Default `Date.now`. */
+    now?: () => number;
+    /**
+     * Storage namespace for this instance's records. Instances sharing one SQLite
+     * client stay isolated when their namespaces differ. Defaults to the service name.
+     */
+    namespace?: string;
+};
+
+interface AuthUser {
+    login: string;
+    id: number;
+    scopes: string[];
+    installation?: AuthInstallation;
+}
+interface AuthInstallation {
+    installationId: number;
+    appId: number;
+    accountId: number;
+    accountType: "User" | "Organization";
+    permissions: Record<string, string>;
+    repositoryIds: number[];
+    repositorySelection: "all" | "selected";
+}
+interface AuthFallback {
+    login: string;
+    id: number;
+    scopes: string[];
+}
+
+interface ResendSeedConfig {
+    port?: number;
+    domains?: Array<{
+        name: string;
+        region?: string;
+    }>;
+    contacts?: Array<{
+        email: string;
+        first_name?: string;
+        last_name?: string;
+        audience?: string;
+    }>;
+}
+
+type ProviderOptions = APIOptions & {
+    baseUrl?: string;
+    tokens?: Record<string, AuthUser>;
+    fallbackUser?: AuthFallback;
+    publicNamespace?: string;
+    adminPrefix?: string;
+};
+
 /**
  * One email the app "sent" (`POST /emails`): what `GET /__admin/outbox` returns. `to`, `cc` and
  * `bcc` hold bare lower-cased addresses (so `?to=` matches `Name <a@b.co>` recipients);
@@ -1369,6 +1487,7 @@ type SentEmail = {
     idempotencyKey: string | null;
     scheduledAt: string | null;
     createdAt: string;
+    lastEvent?: string;
 };
 type ReceivedAttachmentRecord = {
     id: string;
@@ -1405,7 +1524,7 @@ declare class ResendState {
     }>;
     readonly idempotency: IdempotencyStore;
     private readonly ids;
-    constructor(sqlite: SqliteClient, namespace: string);
+    constructor(sqlite: SqliteClient$1, namespace: string);
     /** A UUID-shaped id, deterministic for a given history (Resend ids are UUIDs). */
     nextId(kind: "email" | "received" | "attachment"): string;
 }
@@ -1474,7 +1593,8 @@ type SendOutcomeEvent = {
     namespace: string;
     emailId?: string;
 };
-type ResendAPIOptions = APIOptions & {
+type ResendAPIOptions = APIOptions$1 & Pick<ProviderOptions, "tokens" | "baseUrl" | "publicNamespace" | "adminPrefix"> & {
+    fixtures?: ResendSeedConfig;
     /** The public namespace name, for `/__admin/ns/<name>` download URLs. Default: the default namespace. */
     adminPrefix?: string;
     publicNamespace?: string;
@@ -1490,8 +1610,10 @@ type ResendAPIOptions = APIOptions & {
  */
 declare class ResendAPI implements FetchAPI {
     readonly app: Hono;
-    readonly sqlite: SqliteClient;
+    readonly sqlite: SqliteClient$1;
     readonly state: ResendState;
+    private tail;
+    private readonly expansion;
     private readonly service;
     private readonly now;
     private readonly adminPrefix;
@@ -1502,6 +1624,7 @@ declare class ResendAPI implements FetchAPI {
     private readonly outcomeCounts;
     constructor(options?: ResendAPIOptions);
     fetch(request: Request): Promise<Response>;
+    private handleFetch;
     reset(): Promise<void>;
     /** Accepted sends whose response was lost, those lost responses, and idempotent replays. */
     sendOutcomes(): Record<SendOutcome, number>;
@@ -1546,8 +1669,8 @@ type ForwardStats = {
     failed: number;
     lastError: string | null;
 };
-type ResendRuntimeOptions = {
-    sqlite?: SqliteClient;
+type ResendRuntimeOptions = Pick<ResendAPIOptions, "fixtures" | "baseUrl" | "tokens"> & {
+    sqlite?: SqliteClient$1;
     clock?: Clock;
     seed?: number | string;
     adminPrefix?: string;

package/dist/server.js

@@ -2,8 +2,9 @@ import {
   DEFAULT_PORT,
   createServer,
   serveTarget
-} from "./chunk-3M4FZIUL.js";
-import "./chunk-IYURTCBJ.js";
+} from "./chunk-WMQIKI4U.js";
+import "./chunk-XQ4BQDIK.js";
+import "./chunk-M73LWCCP.js";
 export {
   DEFAULT_PORT,
   createServer,