@deepgram/sdk 5.0.0-beta.4 → 5.1.0

package/dist/esm/middleware/core/jwt.mjs

@@ -1,99 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import * as jose from "jose";
-/**
- * Creates a proxy token signed with the Deepgram API key.
- * This token should be generated on the backend and sent to browser clients.
- * The browser uses this token to connect to the proxy middleware.
- *
- * @param apiKey - Deepgram API key (used as signing secret)
- * @param options - Token configuration options
- * @returns JWT token string
- *
- * @example
- * ```typescript
- * const token = await createProxyToken(process.env.DEEPGRAM_API_KEY, {
- *   identity: 'user-123',
- *   ttl: '1h',
- *   scopes: ['listen', 'speak']
- * });
- * ```
- */
-export function createProxyToken(apiKey_1) {
-    return __awaiter(this, arguments, void 0, function* (apiKey, options = {}) {
-        const { identity, ttl = "1h", scopes, metadata } = options;
-        const projectId = extractProjectId(apiKey);
-        const secret = new TextEncoder().encode(apiKey);
-        const payload = {};
-        if (scopes !== undefined) {
-            payload.scopes = scopes;
-        }
-        if (metadata !== undefined) {
-            payload.metadata = metadata;
-        }
-        const expirationTime = typeof ttl === "number"
-            ? Math.floor(Date.now() / 1000) + ttl
-            : ttl;
-        const jwt = new jose.SignJWT(payload)
-            .setProtectedHeader({ alg: "HS256" })
-            .setIssuer(projectId)
-            .setIssuedAt()
-            .setNotBefore(new Date())
-            .setExpirationTime(expirationTime);
-        if (identity !== undefined) {
-            jwt.setSubject(identity);
-        }
-        return jwt.sign(secret);
-    });
-}
-/**
- * Verifies a proxy token and returns the decoded payload.
- * This should be called by the proxy middleware to validate tokens from clients.
- *
- * @param token - JWT token to verify
- * @param apiKey - Deepgram API key (used to verify signature)
- * @returns Decoded token payload
- * @throws Error if token is invalid, expired, or signature doesn't match
- *
- * @example
- * ```typescript
- * try {
- *   const payload = await verifyProxyToken(token, process.env.DEEPGRAM_API_KEY);
- *   console.log('Valid token for user:', payload.sub);
- * } catch (error) {
- *   console.error('Invalid token:', error);
- * }
- * ```
- */
-export function verifyProxyToken(token, apiKey) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const secret = new TextEncoder().encode(apiKey);
-        const projectId = extractProjectId(apiKey);
-        const { payload } = yield jose.jwtVerify(token, secret, {
-            algorithms: ["HS256"],
-            issuer: projectId,
-        });
-        return payload;
-    });
-}
-/**
- * Extracts the project ID from a Deepgram API key.
- * API keys are formatted as: {project_id}:{secret}
- *
- * @param apiKey - Deepgram API key
- * @returns Project ID portion of the API key
- */
-function extractProjectId(apiKey) {
-    const parts = apiKey.split(":");
-    if (parts.length < 2) {
-        throw new Error("Invalid API key format");
-    }
-    return parts[0];
-}

package/dist/esm/middleware/core/types.d.mts

@@ -1,37 +0,0 @@
-/**
- * Options for configuring the Deepgram proxy middleware
- */
-export interface MiddlewareOptions {
-    /** Deepgram API key for server-side authentication */
-    apiKey: string;
-    /** Enable temporary token generation endpoint (GET /token) */
-    enableTokenAuth?: boolean;
-    /**
-     * Token mode: how tokens are generated and verified
-     * - "deepgram": Use Deepgram's native temporary token API (legacy)
-     * - "jwt": Use JWT tokens signed with API key (recommended for browser clients)
-     *
-     * @default "deepgram"
-     */
-    tokenMode?: "deepgram" | "jwt";
-    /** Custom Deepgram API base URL (e.g., for EU endpoint) */
-    baseUrl?: string;
-    /** Default token expiration in seconds (default: 3600 = 1 hour) */
-    defaultTokenExpiration?: number;
-}
-/**
- * Request body for token generation
- */
-export interface TokenRequest {
-    /** Token time-to-live in seconds */
-    ttlSeconds?: number;
-}
-/**
- * Response from token generation
- */
-export interface TokenResponse {
-    /** The generated access token */
-    token: string;
-    /** Token expiration time in seconds */
-    expiresIn: number;
-}

package/dist/esm/middleware/index.d.mts

@@ -1,55 +0,0 @@
-/**
- * Deepgram SDK Middleware
- *
- * This module provides middleware for integrating Deepgram API proxying
- * into Node.js web frameworks like Express and Fastify.
- *
- * ## Features
- * - Server-side API key injection (hide keys from clients)
- * - Temporary token generation (client requests token, uses it temporarily)
- * - WebSocket proxying for Live/Agent APIs
- * - Framework integration (Raw Node.js, Express, Fastify)
- *
- * @example Express
- * ```typescript
- * import express from 'express';
- * import { createDeepgramProxy, createWebSocketHandler } from '@deepgram/sdk';
- *
- * const app = express();
- * const options = {
- *   apiKey: process.env.DEEPGRAM_API_KEY!,
- *   enableTokenAuth: true
- * };
- *
- * app.use('/api/deepgram', createDeepgramProxy(options));
- *
- * const server = app.listen(3000);
- * server.on('upgrade', createWebSocketHandler(options));
- * ```
- *
- * @example Fastify
- * ```typescript
- * import Fastify from 'fastify';
- * import { fastifyDeepgramProxy } from '@deepgram/sdk';
- *
- * const fastify = Fastify();
- *
- * fastify.register(fastifyDeepgramProxy, {
- *   prefix: '/api/deepgram',
- *   apiKey: process.env.DEEPGRAM_API_KEY!,
- *   enableTokenAuth: true
- * });
- *
- * fastify.listen({ port: 3000 });
- * ```
- *
- * @packageDocumentation
- */
-export type { MiddlewareOptions, TokenRequest, TokenResponse } from "./core/types.mjs";
-export { createHttpHandler, createUpgradeHandler as createHttpUpgradeHandler, createDeepgramHttpServer, type HttpRequestHandler, type UpgradeHandler as HttpUpgradeHandler, } from "./adapters/http.mjs";
-export { createDeepgramProxy, createDeepgramMiddleware, createWebSocketHandler, type ExpressMiddleware, type UpgradeHandler, } from "./adapters/express.mjs";
-export { fastifyDeepgramProxy, deepgramProxyPlugin, type FastifyDeepgramProxyOptions, } from "./adapters/fastify.mjs";
-export { createProxyToken, verifyProxyToken, type ProxyTokenOptions, type ProxyTokenPayload, } from "./core/jwt.mjs";
-export { ProxyHandler } from "./core/ProxyHandler.mjs";
-export { TokenManager } from "./core/TokenManager.mjs";
-export { WebSocketProxy } from "./core/WebSocketProxy.mjs";

package/dist/esm/middleware/index.mjs

@@ -1,59 +0,0 @@
-/**
- * Deepgram SDK Middleware
- *
- * This module provides middleware for integrating Deepgram API proxying
- * into Node.js web frameworks like Express and Fastify.
- *
- * ## Features
- * - Server-side API key injection (hide keys from clients)
- * - Temporary token generation (client requests token, uses it temporarily)
- * - WebSocket proxying for Live/Agent APIs
- * - Framework integration (Raw Node.js, Express, Fastify)
- *
- * @example Express
- * ```typescript
- * import express from 'express';
- * import { createDeepgramProxy, createWebSocketHandler } from '@deepgram/sdk';
- *
- * const app = express();
- * const options = {
- *   apiKey: process.env.DEEPGRAM_API_KEY!,
- *   enableTokenAuth: true
- * };
- *
- * app.use('/api/deepgram', createDeepgramProxy(options));
- *
- * const server = app.listen(3000);
- * server.on('upgrade', createWebSocketHandler(options));
- * ```
- *
- * @example Fastify
- * ```typescript
- * import Fastify from 'fastify';
- * import { fastifyDeepgramProxy } from '@deepgram/sdk';
- *
- * const fastify = Fastify();
- *
- * fastify.register(fastifyDeepgramProxy, {
- *   prefix: '/api/deepgram',
- *   apiKey: process.env.DEEPGRAM_API_KEY!,
- *   enableTokenAuth: true
- * });
- *
- * fastify.listen({ port: 3000 });
- * ```
- *
- * @packageDocumentation
- */
-// Raw Node.js HTTP/HTTPS adapter (no dependencies)
-export { createHttpHandler, createUpgradeHandler as createHttpUpgradeHandler, createDeepgramHttpServer, } from "./adapters/http.mjs";
-// Express adapter
-export { createDeepgramProxy, createDeepgramMiddleware, createWebSocketHandler, } from "./adapters/express.mjs";
-// Fastify adapter
-export { fastifyDeepgramProxy, deepgramProxyPlugin, } from "./adapters/fastify.mjs";
-// JWT token management
-export { createProxyToken, verifyProxyToken, } from "./core/jwt.mjs";
-// Core classes (for advanced usage)
-export { ProxyHandler } from "./core/ProxyHandler.mjs";
-export { TokenManager } from "./core/TokenManager.mjs";
-export { WebSocketProxy } from "./core/WebSocketProxy.mjs";