@crvouga/mockingbird-service-twilio 3.0.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;
-};
-/**
- * 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";
+type MountedAPI = FetchAPI$1 & {
+    readonly prefix: string;
+    GET: FetchHandler;
+    POST: FetchHandler;
+    PUT: FetchHandler;
+    PATCH: FetchHandler;
+    DELETE: FetchHandler;
+    HEAD: FetchHandler;
+    OPTIONS: FetchHandler;
 };
-/**
- * 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;
     /**
@@ -1208,7 +1239,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;
@@ -1275,7 +1308,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;
@@ -1284,9 +1317,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;
 };
@@ -1295,10 +1328,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.
@@ -1306,9 +1339,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;
 }
 
@@ -1322,6 +1355,121 @@ 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 TwilioSeedConfig {
+    port?: number;
+    account?: {
+        sid?: string;
+        auth_token?: string;
+        friendly_name?: string;
+        status?: "active" | "suspended" | "closed";
+    };
+    api_keys?: Array<{
+        sid?: string;
+        secret: string;
+        friendly_name?: string;
+    }>;
+    phone_numbers?: Array<{
+        sid?: string;
+        phone_number: string;
+        friendly_name?: string;
+        sms_url?: string;
+        sms_method?: string;
+        voice_url?: string;
+        voice_method?: string;
+        status_callback?: string;
+    }>;
+    messaging_services?: Array<{
+        sid?: string;
+        friendly_name: string;
+        phone_numbers?: string[];
+        status_callback?: string;
+        inbound_request_url?: string;
+    }>;
+    verify_services?: Array<{
+        sid?: string;
+        friendly_name: string;
+        code?: string;
+        default_channel?: string;
+    }>;
+    conversations?: {
+        services?: Array<{
+            sid?: string;
+            friendly_name: string;
+        }>;
+    };
+}
+
+type ProviderOptions = APIOptions & {
+    baseUrl?: string;
+    tokens?: Record<string, AuthUser>;
+    fallbackUser?: AuthFallback;
+    publicNamespace?: string;
+    adminPrefix?: string;
+};
+
 /**
  * Lookup v2 number validation, modelled on what the live API answers (it is libphonenumber:
  * the validation errors are libphonenumber's reasons). Verified live for fictional 555-01xx
@@ -1371,17 +1519,17 @@ type MessageRecord = {
     to: string;
     from: string | null;
     messaging_service_sid: string | null;
-    status: "queued" | "accepted";
-    direction: "outbound-api";
+    status: "accepted" | "scheduled" | "canceled" | "queued" | "sending" | "sent" | "failed" | "delivered" | "undelivered" | "receiving" | "received" | "read";
+    direction: "inbound" | "outbound-api" | "outbound-call" | "outbound-reply";
     num_segments: string;
     num_media: string;
-    price: null;
+    price: string | null;
     price_unit: "USD";
-    error_code: null;
-    error_message: null;
+    error_code: number | null;
+    error_message: string | null;
     date_created: string;
     date_updated: string;
-    date_sent: null;
+    date_sent: string | null;
     uri: string;
     subresource_uris: {
         media: string;
@@ -1438,7 +1586,7 @@ declare class TwilioState {
     readonly settings: Collection<VerifySettings>;
     readonly outbox: OutboxStore<TwilioOutboxItem>;
     private readonly ids;
-    constructor(sqlite: SqliteClient, namespace: string, seed?: Partial<VerifySettings>);
+    constructor(sqlite: SqliteClient$1, namespace: string, seed?: Partial<VerifySettings>);
     /** A Twilio sid: two-letter prefix plus 32 hex characters, deterministic per history. */
     sid(prefix: string): string;
     /** A random-looking but reproducible 6-digit code for a new verification. */
@@ -1449,7 +1597,8 @@ declare class TwilioState {
     verificationsTo(to: string, serviceSid?: string): VerificationRecord[];
 }
 
-type TwilioAPIOptions = APIOptions & {
+type TwilioAPIOptions = APIOptions$1 & Pick<ProviderOptions, "tokens" | "baseUrl" | "publicNamespace" | "adminPrefix"> & {
+    fixtures?: TwilioSeedConfig;
     /** Initial Verify settings for the namespace (fixed code, expiry, attempt limits). */
     verify?: Partial<VerifySettings>;
     /**
@@ -1486,13 +1635,16 @@ type PutRecordingInput = {
  */
 declare class TwilioAPI implements FetchAPI {
     readonly app: Hono;
-    readonly sqlite: SqliteClient;
+    readonly sqlite: SqliteClient$1;
     readonly state: TwilioState;
+    private tail;
+    private readonly expansion;
     private readonly service;
     private readonly now;
     private readonly accounts;
     constructor(options?: TwilioAPIOptions);
     fetch(request: Request): Promise<Response>;
+    private handleFetch;
     reset(): Promise<void>;
     private authenticate;
     /** The account a request acts for: the path's, else the Basic username when it is one. */
@@ -1548,8 +1700,8 @@ type TwilioAppWebhooks = {
     /** `MessagingServiceSid` of inbound SMS, when the number belongs to one. */
     messagingServiceSid?: string;
 };
-type TwilioRuntimeOptions = {
-    sqlite?: SqliteClient;
+type TwilioRuntimeOptions = Pick<TwilioAPIOptions, "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-OINOWAF7.js";
-import "./chunk-64B2VD5D.js";
+} from "./chunk-JGQUWBT2.js";
+import "./chunk-SOEDG3O2.js";
+import "./chunk-M73LWCCP.js";
 export {
   DEFAULT_PORT,
   createServer,