@creativeorange/azure-text-to-speech 2.2.3 → 3.0.0

package/src/authentication.ts

@@ -0,0 +1,228 @@
+export type SpeechAuthorization = {
+    token: string;
+    region: string;
+};
+
+export type SpeechAuthorizationProvider =
+    () => Promise<SpeechAuthorization>;
+
+export type SpeechTokenRequestOptions = {
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+};
+
+export type SpeechAuthenticationOptions = {
+    tokenEndpoint?: string;
+    getAuthorizationToken?: SpeechAuthorizationProvider;
+    tokenRequestOptions?: SpeechTokenRequestOptions;
+    tokenLifetimeMs?: number;
+};
+
+export type SpeechSafeError = {
+    message: string;
+    code?: string;
+};
+
+const DEFAULT_TOKEN_LIFETIME_MS = 8 * 60 * 1000;
+
+export function createSpeechAuthorizationProvider(
+    options: SpeechAuthenticationOptions,
+): SpeechAuthorizationProvider {
+    const hasTokenEndpoint = typeof options.tokenEndpoint === 'string' &&
+        options.tokenEndpoint.trim() !== '';
+    const hasProvider = typeof options.getAuthorizationToken === 'function';
+
+    if (hasTokenEndpoint && hasProvider) {
+        throw new Error(
+            'Provide either tokenEndpoint or getAuthorizationToken, not both.',
+        );
+    }
+
+    if (!hasTokenEndpoint && !hasProvider) {
+        throw new Error(
+            'A tokenEndpoint or getAuthorizationToken provider is required.',
+        );
+    }
+
+    if (hasProvider) {
+        return options.getAuthorizationToken as SpeechAuthorizationProvider;
+    }
+
+    const tokenEndpoint = (options.tokenEndpoint as string).trim();
+    const requestOptions = options.tokenRequestOptions ?? {};
+
+    return async () => {
+        let response: Response;
+
+        try {
+            response = await fetch(tokenEndpoint, {
+                method: 'GET',
+                credentials: requestOptions.credentials ?? 'same-origin',
+                headers: {
+                    Accept: 'application/json',
+                    ...(requestOptions.headers ?? {}),
+                },
+            });
+        } catch {
+            throw createSafeError(
+                'Could not reach the speech token endpoint.',
+                'TOKEN_ENDPOINT_UNREACHABLE',
+            );
+        }
+
+        if (!response.ok) {
+            throw createSafeError(
+                `Speech token endpoint returned HTTP ${response.status}.`,
+                'TOKEN_ENDPOINT_HTTP_ERROR',
+            );
+        }
+
+        let payload: unknown;
+
+        try {
+            payload = await response.json();
+        } catch {
+            throw createSafeError(
+                'Speech token endpoint returned invalid JSON.',
+                'TOKEN_ENDPOINT_INVALID_JSON',
+            );
+        }
+
+        return validateSpeechAuthorization(payload);
+    };
+}
+
+export function validateSpeechAuthorization(
+    value: unknown,
+): SpeechAuthorization {
+    if (!value || typeof value !== 'object') {
+        throw createSafeError(
+            'Speech authorization response must be an object.',
+            'TOKEN_INVALID_RESPONSE',
+        );
+    }
+
+    const candidate = value as Partial<SpeechAuthorization>;
+    const token = typeof candidate.token === 'string' ? candidate.token.trim() : '';
+    const region = typeof candidate.region === 'string' ?
+        candidate.region.trim() :
+        '';
+
+    if (token === '') {
+        throw createSafeError(
+            'Speech authorization token is missing or empty.',
+            'TOKEN_EMPTY',
+        );
+    }
+
+    if (region === '') {
+        throw createSafeError(
+            'Speech authorization region is missing or empty.',
+            'TOKEN_REGION_MISSING',
+        );
+    }
+
+    return {token, region};
+}
+
+export function createSafeError(
+    message: string,
+    code?: string,
+): Error & SpeechSafeError {
+    const error = new Error(message) as Error & SpeechSafeError;
+    error.message = message;
+    if (code) {
+        error.code = code;
+    }
+
+    return error;
+}
+
+export function toSafeErrorDetail(error: unknown): SpeechSafeError {
+    if (error && typeof error === 'object') {
+        const candidate = error as {message?: unknown; code?: unknown};
+        const message = typeof candidate.message === 'string' &&
+            candidate.message.trim() !== '' ?
+            sanitizeErrorText(candidate.message) :
+            'An unexpected speech error occurred.';
+        const detail: SpeechSafeError = {message};
+
+        if (typeof candidate.code === 'string' && candidate.code.trim() !== '') {
+            detail.code = candidate.code;
+        }
+
+        return detail;
+    }
+
+    return {
+        message: 'An unexpected speech error occurred.',
+    };
+}
+
+function sanitizeErrorText(message: string): string {
+    return message
+        .replace(/Bearer\s+\S+/gi, 'Bearer [redacted]')
+        .replace(/token["']?\s*[:=]\s*["']?[^"',\s}]+/gi, 'token=[redacted]');
+}
+
+/**
+ * Fetches, validates, caches and refreshes temporary Azure Speech tokens.
+ * Never logs authorization tokens.
+ */
+export class SpeechAuthorizationManager {
+    private authorization?: SpeechAuthorization;
+    private authorizationExpiresAt = 0;
+    private authorizationRequest?: Promise<SpeechAuthorization>;
+    private readonly provider: SpeechAuthorizationProvider;
+    private readonly tokenLifetimeMs: number;
+
+    constructor(options: SpeechAuthenticationOptions) {
+        this.provider = createSpeechAuthorizationProvider(options);
+        this.tokenLifetimeMs = options.tokenLifetimeMs && options.tokenLifetimeMs > 0 ?
+            options.tokenLifetimeMs :
+            DEFAULT_TOKEN_LIFETIME_MS;
+    }
+
+    async getAuthorization(): Promise<SpeechAuthorization> {
+        if (this.authorization && Date.now() < this.authorizationExpiresAt) {
+            return this.authorization;
+        }
+
+        if (this.authorizationRequest) {
+            return this.authorizationRequest;
+        }
+
+        this.authorizationRequest = this.fetchAuthorization()
+            .then((authorization) => {
+                this.authorization = authorization;
+                this.authorizationExpiresAt = Date.now() + this.tokenLifetimeMs;
+
+                return authorization;
+            })
+            .finally(() => {
+                this.authorizationRequest = undefined;
+            });
+
+        return this.authorizationRequest;
+    }
+
+    clearAuthorization(): void {
+        this.authorization = undefined;
+        this.authorizationExpiresAt = 0;
+        this.authorizationRequest = undefined;
+    }
+
+    private async fetchAuthorization(): Promise<SpeechAuthorization> {
+        try {
+            const authorization = await this.provider();
+
+            return validateSpeechAuthorization(authorization);
+        } catch (error) {
+            this.clearAuthorization();
+            throw createSafeError(
+                toSafeErrorDetail(error).message,
+                (error as SpeechSafeError)?.code,
+            );
+        }
+    }
+}

package/src/main.ts

@@ -1,2 +1,9 @@
+export type {
+    SpeechAuthorization,
+    SpeechAuthorizationProvider,
+    SpeechTokenRequestOptions,
+    SpeechAuthenticationOptions,
+    SpeechSafeError,
+} from './authentication';
 export * from './SpeechToText';
 export * from './TextToSpeech';

package/.eslintrc.js

@@ -1,30 +0,0 @@
-module.exports = {
-    'env': {
-        'browser': true,
-        'es6': true
-    },
-    'extends': [
-        'eslint:recommended',
-        'plugin:@typescript-eslint/eslint-recommended',
-        'google'
-    ],
-    'rules': {
-        "no-console": "off",
-        'max-len': ['error', {'code': 125}],
-        'indent': ['error', 4],
-        'require-jsdoc': ['error', {
-            'require': {
-                'FunctionDeclaration': false,
-                'MethodDefinition': false,
-                'ClassDeclaration': false,
-                'ArrowFunctionExpression': false,
-                'FunctionExpression': false
-            }
-        }],
-    },
-    'parserOptions': {
-        'sourceType': 'module',
-    },
-    'parser': '@typescript-eslint/parser',
-    "ignorePatterns": ["**/*.html", "**/*.scss"],
-}