@absolutejs/voice 0.0.22-beta.270 → 0.0.22-beta.271

package/dist/index.d.ts

@@ -161,12 +161,12 @@ export type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredV
 export { createTwilioMediaStreamBridge, createTwilioVoiceRoutes, createTwilioVoiceResponse, decodeTwilioMulawBase64, encodeTwilioMulawBase64, transcodePCMToTwilioOutboundPayload, transcodeTwilioInboundPayloadToPCM16 } from './telephony/twilio';
 export { evaluateVoiceTelephonyContract } from './telephony/contract';
 export { createTelnyxMediaStreamBridge, createTelnyxVoiceResponse, createTelnyxVoiceRoutes, verifyVoiceTelnyxWebhookSignature } from './telephony/telnyx';
-export { createMemoryVoicePlivoWebhookNonceStore, createPlivoMediaStreamBridge, createPlivoVoiceResponse, createPlivoVoiceRoutes, createVoicePlivoWebhookVerifier, signVoicePlivoWebhook, verifyVoicePlivoWebhookSignature } from './telephony/plivo';
+export { createMemoryVoicePlivoWebhookNonceStore, createPlivoMediaStreamBridge, createPlivoVoiceResponse, createPlivoVoiceRoutes, createVoicePostgresPlivoWebhookNonceStore, createVoicePlivoWebhookVerifier, createVoiceRedisPlivoWebhookNonceStore, createVoiceSQLitePlivoWebhookNonceStore, signVoicePlivoWebhook, verifyVoicePlivoWebhookSignature } from './telephony/plivo';
 export { createVoiceTelephonyCarrierMatrix, createVoiceTelephonyCarrierMatrixRoutes, renderVoiceTelephonyCarrierMatrixHTML } from './telephony/matrix';
 export type { TwilioInboundMessage, TwilioMediaStreamBridge, TwilioMediaStreamBridgeOptions, TwilioMediaStreamSocket, TwilioOutboundClearMessage, TwilioOutboundMarkMessage, TwilioOutboundMediaMessage, TwilioOutboundMessage, TwilioVoiceRouteParameters, TwilioVoiceResponseOptions, TwilioVoiceSmokeCheck, TwilioVoiceSmokeOptions, TwilioVoiceSmokeReport, TwilioVoiceSetupOptions, TwilioVoiceSetupStatus, TwilioVoiceRoutesOptions } from './telephony/twilio';
 export type { VoiceTelephonyContractIssue, VoiceTelephonyContractOptions, VoiceTelephonyContractReport, VoiceTelephonyContractRequirement, VoiceTelephonyProvider, VoiceTelephonySetupStatus, VoiceTelephonySmokeCheck, VoiceTelephonySmokeReport } from './telephony/contract';
 export type { TelnyxInboundMessage, TelnyxMediaPayload, TelnyxMediaStreamBridge, TelnyxMediaStreamBridgeOptions, TelnyxMediaStreamSocket, TelnyxOutboundClearMessage, TelnyxOutboundMarkMessage, TelnyxOutboundMediaMessage, TelnyxOutboundMessage, TelnyxVoiceResponseOptions, TelnyxVoiceRoutesOptions, TelnyxVoiceSetupOptions, TelnyxVoiceSetupStatus, TelnyxVoiceSmokeCheck, TelnyxVoiceSmokeOptions, TelnyxVoiceSmokeReport } from './telephony/telnyx';
-export type { PlivoInboundMessage, PlivoMediaStreamBridge, PlivoMediaStreamBridgeOptions, PlivoMediaStreamSocket, PlivoOutboundCheckpointMessage, PlivoOutboundClearAudioMessage, PlivoOutboundMessage, PlivoOutboundPlayAudioMessage, PlivoVoiceResponseOptions, PlivoVoiceRoutesOptions, PlivoVoiceSetupOptions, PlivoVoiceSetupStatus, PlivoVoiceSmokeCheck, PlivoVoiceSmokeOptions, PlivoVoiceSmokeReport, VoicePlivoWebhookNonceStore, VoicePlivoWebhookVerifierOptions } from './telephony/plivo';
+export type { PlivoInboundMessage, PlivoMediaStreamBridge, PlivoMediaStreamBridgeOptions, PlivoMediaStreamSocket, PlivoOutboundCheckpointMessage, PlivoOutboundClearAudioMessage, PlivoOutboundMessage, PlivoOutboundPlayAudioMessage, PlivoVoiceResponseOptions, PlivoVoiceRoutesOptions, PlivoVoiceSetupOptions, PlivoVoiceSetupStatus, PlivoVoiceSmokeCheck, PlivoVoiceSmokeOptions, PlivoVoiceSmokeReport, VoicePostgresPlivoWebhookNonceStoreOptions, VoicePlivoWebhookNonceStore, VoicePlivoWebhookNonceStoreOptions, VoicePlivoWebhookVerifierOptions, VoiceRedisPlivoWebhookNonceClient, VoiceRedisPlivoWebhookNonceStoreOptions, VoiceSQLitePlivoWebhookNonceStoreOptions } from './telephony/plivo';
 export type { VoiceTelephonyCarrierMatrix, VoiceTelephonyCarrierMatrixEntry, VoiceTelephonyCarrierMatrixInput, VoiceTelephonyCarrierMatrixOptions, VoiceTelephonyCarrierMatrixRoutesOptions, VoiceTelephonyCarrierMatrixStatus } from './telephony/matrix';
 export { shapeTelephonyAssistantText } from './telephony/response';
 export type { TelephonyResponseShapeMode, TelephonyResponseShapeOptions } from './telephony/response';

package/dist/index.js

@@ -18109,6 +18109,7 @@ import { Elysia as Elysia34 } from "elysia";
 
 // src/telephony/plivo.ts
 import { Buffer as Buffer5 } from "buffer";
+import { Database } from "bun:sqlite";
 import { Elysia as Elysia30 } from "elysia";
 
 // src/telephony/contract.ts
@@ -19125,12 +19126,148 @@ var verifyVoicePlivoWebhookSignature = async (input) => {
 var createMemoryVoicePlivoWebhookNonceStore = () => {
   const nonces = new Set;
   return {
+    claim: (nonce) => {
+      if (nonces.has(nonce)) {
+        return false;
+      }
+      nonces.add(nonce);
+      return true;
+    },
     has: (nonce) => nonces.has(nonce),
     set: (nonce) => {
       nonces.add(nonce);
     }
   };
 };
+var normalizePlivoStoreIdentifierSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
+var quotePlivoStoreIdentifier = (value) => `"${value.replace(/"/g, '""')}"`;
+var resolvePlivoNonceTableName = (input) => {
+  if (input.tableName) {
+    return normalizePlivoStoreIdentifierSegment(input.tableName);
+  }
+  return `${normalizePlivoStoreIdentifierSegment(input.tablePrefix ?? "voice")}_${normalizePlivoStoreIdentifierSegment(input.fallback)}`;
+};
+var getPlivoNonceExpiresAt = (ttlSeconds) => typeof ttlSeconds === "number" && ttlSeconds > 0 ? Date.now() + Math.ceil(ttlSeconds * 1000) : null;
+var createVoiceSQLitePlivoWebhookNonceStore = (options) => {
+  const database = options.database ?? new Database(options.path ?? ":memory:", {
+    create: true
+  });
+  const tableName = resolvePlivoNonceTableName({
+    fallback: "plivo_webhook_nonces",
+    tableName: options.tableName,
+    tablePrefix: options.tablePrefix
+  });
+  database.exec(`CREATE TABLE IF NOT EXISTS "${tableName}" (
+			nonce TEXT PRIMARY KEY,
+			created_at INTEGER NOT NULL,
+			expires_at INTEGER
+		)`);
+  const pruneExpired = database.query(`DELETE FROM "${tableName}" WHERE expires_at IS NOT NULL AND expires_at <= ?1`);
+  const select = database.query(`SELECT nonce FROM "${tableName}" WHERE nonce = ?1 AND (expires_at IS NULL OR expires_at > ?2) LIMIT 1`);
+  const insert = database.query(`INSERT OR IGNORE INTO "${tableName}" (nonce, created_at, expires_at) VALUES (?1, ?2, ?3)`);
+  const upsert = database.query(`INSERT INTO "${tableName}" (nonce, created_at, expires_at) VALUES (?1, ?2, ?3)
+		 ON CONFLICT(nonce) DO UPDATE SET expires_at = excluded.expires_at`);
+  return {
+    claim: (nonce) => {
+      const now = Date.now();
+      pruneExpired.run(now);
+      const result = insert.run(nonce, now, getPlivoNonceExpiresAt(options.ttlSeconds));
+      return result.changes > 0;
+    },
+    has: (nonce) => Boolean(select.get(nonce, Date.now())),
+    set: (nonce) => {
+      upsert.run(nonce, Date.now(), getPlivoNonceExpiresAt(options.ttlSeconds));
+    }
+  };
+};
+var createVoicePlivoPostgresClient = async (options) => {
+  if (options.sql) {
+    return options.sql;
+  }
+  if (!options.connectionString) {
+    throw new Error("createVoicePostgresPlivoWebhookNonceStore requires either options.sql or options.connectionString.");
+  }
+  const sql = new Bun.SQL(options.connectionString);
+  return {
+    unsafe: sql.unsafe.bind(sql)
+  };
+};
+var resolvePlivoNonceQualifiedTableName = (options) => {
+  const schema = normalizePlivoStoreIdentifierSegment(options.schemaName ?? "public");
+  const table = resolvePlivoNonceTableName({
+    fallback: "plivo_webhook_nonces",
+    tableName: options.tableName,
+    tablePrefix: options.tablePrefix
+  });
+  return `${quotePlivoStoreIdentifier(schema)}.${quotePlivoStoreIdentifier(table)}`;
+};
+var createVoicePostgresPlivoWebhookNonceStore = (options = {}) => {
+  const qualifiedTableName = resolvePlivoNonceQualifiedTableName(options);
+  const schemaMatch = qualifiedTableName.match(/^"([^"]+)"\./);
+  const client = createVoicePlivoPostgresClient(options);
+  const initialized = (async () => {
+    const sql = await client;
+    if (schemaMatch?.[1]) {
+      await sql.unsafe(`CREATE SCHEMA IF NOT EXISTS ${quotePlivoStoreIdentifier(schemaMatch[1])}`);
+    }
+    await sql.unsafe(`CREATE TABLE IF NOT EXISTS ${qualifiedTableName} (
+				nonce TEXT PRIMARY KEY,
+				created_at BIGINT NOT NULL,
+				expires_at BIGINT
+			)`);
+  })();
+  const pruneExpired = async () => {
+    await initialized;
+    const sql = await client;
+    await sql.unsafe(`DELETE FROM ${qualifiedTableName} WHERE expires_at IS NOT NULL AND expires_at <= $1`, [Date.now()]);
+  };
+  return {
+    claim: async (nonce) => {
+      await pruneExpired();
+      const sql = await client;
+      const rows = await sql.unsafe(`INSERT INTO ${qualifiedTableName} (nonce, created_at, expires_at)
+				 VALUES ($1, $2, $3)
+				 ON CONFLICT (nonce) DO NOTHING
+				 RETURNING nonce`, [nonce, Date.now(), getPlivoNonceExpiresAt(options.ttlSeconds)]);
+      return rows.length > 0;
+    },
+    has: async (nonce) => {
+      await initialized;
+      const sql = await client;
+      const rows = await sql.unsafe(`SELECT nonce FROM ${qualifiedTableName}
+				 WHERE nonce = $1 AND (expires_at IS NULL OR expires_at > $2)
+				 LIMIT 1`, [nonce, Date.now()]);
+      return rows.length > 0;
+    },
+    set: async (nonce) => {
+      await initialized;
+      const sql = await client;
+      await sql.unsafe(`INSERT INTO ${qualifiedTableName} (nonce, created_at, expires_at)
+				 VALUES ($1, $2, $3)
+				 ON CONFLICT (nonce) DO UPDATE SET expires_at = EXCLUDED.expires_at`, [nonce, Date.now(), getPlivoNonceExpiresAt(options.ttlSeconds)]);
+    }
+  };
+};
+var getPlivoRedisNonceKey = (keyPrefix, nonce) => `${keyPrefix}:${nonce}`;
+var createVoiceRedisPlivoWebhookNonceStore = (options = {}) => {
+  const client = options.client ?? new Bun.RedisClient(options.url);
+  const keyPrefix = options.keyPrefix?.trim() || "voice:plivo-webhook-nonce";
+  const ttlSeconds = options.ttlSeconds;
+  const setNonce = async (nonce, nx) => {
+    const key = getPlivoRedisNonceKey(keyPrefix, nonce);
+    if (typeof ttlSeconds === "number" && ttlSeconds > 0) {
+      return client.set(key, "1", "EX", String(Math.ceil(ttlSeconds)), ...nx ? ["NX"] : []);
+    }
+    return client.set(key, "1", ...nx ? ["NX"] : []);
+  };
+  return {
+    claim: async (nonce) => await setNonce(nonce, true) === "OK",
+    has: async (nonce) => Boolean(await client.exists(getPlivoRedisNonceKey(keyPrefix, nonce))),
+    set: async (nonce) => {
+      await setNonce(nonce, false);
+    }
+  };
+};
 var createVoicePlivoWebhookVerifier = (options) => async (input) => {
   const verificationUrl = options.verificationUrl;
   const verification = await verifyVoicePlivoWebhookSignature({
@@ -19150,7 +19287,16 @@ var createVoicePlivoWebhookVerifier = (options) => async (input) => {
     return verification;
   }
   const nonce = input.headers.get("x-plivo-signature-v3-nonce");
-  if (!nonce || await nonceStore.has(nonce)) {
+  if (!nonce) {
+    return { ok: false, reason: "invalid-signature" };
+  }
+  if (nonceStore.claim) {
+    if (!await nonceStore.claim(nonce)) {
+      return { ok: false, reason: "invalid-signature" };
+    }
+    return verification;
+  }
+  if (await nonceStore.has(nonce)) {
     return { ok: false, reason: "invalid-signature" };
   }
   await nonceStore.set(nonce);
@@ -23844,7 +23990,7 @@ var createVoiceOpsRecoveryRoutes = (options = {}) => {
 
 // src/observabilityExport.ts
 import { Elysia as Elysia41 } from "elysia";
-import { Database } from "bun:sqlite";
+import { Database as Database2 } from "bun:sqlite";
 import { createHash } from "crypto";
 import { mkdir as mkdir4, readFile as readFile2, stat, unlink } from "fs/promises";
 import { join as join3 } from "path";
@@ -25074,7 +25220,7 @@ var loadVoiceObservabilityExportReplaySource = async (source) => {
     if (!source.database && !source.path) {
       throw new Error("SQLite observability export replay requires source.database or source.path.");
     }
-    const database = source.database ?? new Database(source.path, { create: false });
+    const database = source.database ?? new Database2(source.path, { create: false });
     const table2 = quoteObservabilityIdentifier(normalizeObservabilityIdentifier(source.tableName));
     const row2 = database.query(`SELECT manifest_json, artifact_index_json, payload_json FROM ${table2} WHERE run_id = $runId`).get({ $runId: source.runId });
     if (!row2) {
@@ -25151,7 +25297,7 @@ var deliverObservabilityExportToSQLite = async (input) => {
   if (!input.destination.database && !input.destination.path) {
     throw new Error("SQLite observability export delivery requires destination.database or destination.path.");
   }
-  const database = input.destination.database ?? new Database(input.destination.path, { create: true });
+  const database = input.destination.database ?? new Database2(input.destination.path, { create: true });
   const table = quoteObservabilityIdentifier(normalizeObservabilityIdentifier(input.destination.tableName));
   const record = buildObservabilityExportDatabaseRecord(input);
   database.exec(`CREATE TABLE IF NOT EXISTS ${table} (
@@ -29261,7 +29407,7 @@ var createVoiceTraceDeliveryRoutes = (options) => {
   return routes;
 };
 // src/sqliteStore.ts
-import { Database as Database2 } from "bun:sqlite";
+import { Database as Database3 } from "bun:sqlite";
 var normalizeTableNameSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
 var resolveTableName = (input) => {
   if (input.options.tableName) {
@@ -29272,7 +29418,7 @@ var resolveTableName = (input) => {
   return `${prefix}_${fallback}`;
 };
 var openVoiceSQLiteDatabase = (path) => {
-  const database = new Database2(path, {
+  const database = new Database3(path, {
     create: true
   });
   database.exec("PRAGMA journal_mode = WAL;");
@@ -31662,6 +31808,7 @@ export {
   createVoiceSQLiteSessionStore,
   createVoiceSQLiteRuntimeStorage,
   createVoiceSQLiteReviewStore,
+  createVoiceSQLitePlivoWebhookNonceStore,
   createVoiceSQLiteIntegrationEventStore,
   createVoiceSQLiteExternalObjectMapStore,
   createVoiceSQLiteDeliverySink,
@@ -31675,6 +31822,7 @@ export {
   createVoiceResilienceRoutes,
   createVoiceRedisTelephonyWebhookIdempotencyStore,
   createVoiceRedisTaskLeaseCoordinator,
+  createVoiceRedisPlivoWebhookNonceStore,
   createVoiceRedisIdempotencyStore,
   createVoiceReconnectContractRoutes,
   createVoiceReadinessProfile,
@@ -31700,6 +31848,7 @@ export {
   createVoicePostgresSessionStore,
   createVoicePostgresRuntimeStorage,
   createVoicePostgresReviewStore,
+  createVoicePostgresPlivoWebhookNonceStore,
   createVoicePostgresIntegrationEventStore,
   createVoicePostgresExternalObjectMapStore,
   createVoicePostgresDeliverySink,

package/dist/telephony/plivo.d.ts

@@ -1,7 +1,10 @@
+import { Database } from 'bun:sqlite';
+import type { RedisClient } from 'bun';
 import { Elysia } from 'elysia';
 import { type VoiceTelephonyContractReport, type VoiceTelephonySetupStatus, type VoiceTelephonySmokeCheck, type VoiceTelephonySmokeReport } from './contract';
 import { type VoiceTelephonyOutcomePolicy, type VoiceTelephonyWebhookRoutesOptions, type VoiceTelephonyWebhookVerificationResult } from '../telephonyOutcome';
 import type { VoiceServerMessage, VoiceSessionRecord } from '../types';
+import type { VoicePostgresClient } from '../postgresStore';
 import { type TwilioMediaStreamBridgeOptions } from './twilio';
 export type PlivoInboundMessage = {
     event: 'start';
@@ -132,9 +135,32 @@ export type PlivoVoiceSmokeOptions = {
     title?: string;
 };
 export type VoicePlivoWebhookNonceStore = {
+    claim?: (nonce: string) => Promise<boolean> | boolean;
     has: (nonce: string) => Promise<boolean> | boolean;
     set: (nonce: string) => Promise<void> | void;
 };
+export type VoicePlivoWebhookNonceStoreOptions = {
+    ttlSeconds?: number;
+};
+export type VoiceSQLitePlivoWebhookNonceStoreOptions = VoicePlivoWebhookNonceStoreOptions & {
+    database?: Database;
+    path?: string;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoicePostgresPlivoWebhookNonceStoreOptions = VoicePlivoWebhookNonceStoreOptions & {
+    connectionString?: string;
+    schemaName?: string;
+    sql?: VoicePostgresClient;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoiceRedisPlivoWebhookNonceClient = Pick<RedisClient, 'exists' | 'set'>;
+export type VoiceRedisPlivoWebhookNonceStoreOptions = VoicePlivoWebhookNonceStoreOptions & {
+    client?: VoiceRedisPlivoWebhookNonceClient;
+    keyPrefix?: string;
+    url?: string;
+};
 export type VoicePlivoWebhookVerifierOptions = {
     authToken?: string;
     nonceStore?: VoicePlivoWebhookNonceStore;
@@ -186,6 +212,9 @@ export declare const verifyVoicePlivoWebhookSignature: (input: {
     url: string;
 }) => Promise<VoiceTelephonyWebhookVerificationResult>;
 export declare const createMemoryVoicePlivoWebhookNonceStore: () => VoicePlivoWebhookNonceStore;
+export declare const createVoiceSQLitePlivoWebhookNonceStore: (options: VoiceSQLitePlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
+export declare const createVoicePostgresPlivoWebhookNonceStore: (options?: VoicePostgresPlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
+export declare const createVoiceRedisPlivoWebhookNonceStore: (options?: VoiceRedisPlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
 export declare const createVoicePlivoWebhookVerifier: (options: VoicePlivoWebhookVerifierOptions) => (input: {
     body: unknown;
     headers: Headers;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.270",
+	"version": "0.0.22-beta.271",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",