@deepgram/sdk 3.3.4 → 3.4.0

package/src/packages/AbstractRestfulClient.ts

@@ -1,160 +0,0 @@
-import { DeepgramApiError, DeepgramError, DeepgramUnknownError } from "../lib/errors";
-import { Readable } from "stream";
-import { fetchWithAuth, resolveResponse } from "../lib/fetch";
-import type { Fetch, FetchParameters, RequestMethodType } from "../lib/types/Fetch";
-import { AbstractClient } from "./AbstractClient";
-import { DeepgramClientOptions } from "../lib/types";
-import { isBrowser } from "../lib/helpers";
-
-export abstract class AbstractRestfulClient extends AbstractClient {
-  protected fetch: Fetch;
-
-  constructor(protected key: string, protected options: DeepgramClientOptions) {
-    super(key, options);
-
-    if (isBrowser() && !this._willProxy()) {
-      throw new DeepgramError(
-        "Due to CORS we are unable to support REST-based API calls to our API from the browser. Please consider using a proxy, and including a `restProxy: { url: ''}` in your Deepgram client options."
-      );
-    }
-
-    this.fetch = fetchWithAuth(this.key, options._experimentalCustomFetch);
-  }
-
-  protected _getErrorMessage(err: any): string {
-    return err.msg || err.message || err.error_description || err.error || JSON.stringify(err);
-  }
-
-  protected async handleError(error: unknown, reject: (reason?: any) => void) {
-    const Res = await resolveResponse();
-
-    if (error instanceof Res) {
-      error
-        .json()
-        .then((err) => {
-          reject(new DeepgramApiError(this._getErrorMessage(err), error.status || 500));
-        })
-        .catch((err) => {
-          reject(new DeepgramUnknownError(this._getErrorMessage(err), err));
-        });
-    } else {
-      reject(new DeepgramUnknownError(this._getErrorMessage(error), error));
-    }
-  }
-
-  protected _getRequestParams(
-    method: RequestMethodType,
-    headers?: Record<string, string>,
-    parameters?: FetchParameters,
-    body?: string | Buffer | Readable
-  ) {
-    const params: { [k: string]: any } = {
-      ...this.options?.fetch,
-      method,
-      headers: { ...this.options?.fetch?.headers, ...headers } || {},
-    };
-
-    if (method === "GET") {
-      return params;
-    }
-
-    params.body = body;
-    params.duplex = "half";
-
-    return { ...params, ...parameters };
-  }
-
-  protected async _handleRequest(
-    fetcher: Fetch,
-    method: RequestMethodType,
-    url: string | URL,
-    headers?: Record<string, string>,
-    parameters?: FetchParameters,
-    body?: string | Buffer | Readable
-  ): Promise<any> {
-    return new Promise((resolve, reject) => {
-      fetcher(url, this._getRequestParams(method, headers, parameters, body))
-        .then((result) => {
-          if (!result.ok) throw result;
-
-          return result.json();
-        })
-        .then((data) => resolve(data))
-        .catch((error) => this.handleError(error, reject));
-    });
-  }
-
-  protected async _handleRawRequest(
-    fetcher: Fetch,
-    method: RequestMethodType,
-    url: string | URL,
-    headers?: Record<string, string>,
-    parameters?: FetchParameters,
-    body?: string | Buffer | Readable
-  ): Promise<any> {
-    return new Promise((resolve, reject) => {
-      fetcher(url, this._getRequestParams(method, headers, parameters, body))
-        .then((result) => {
-          if (!result.ok) throw result;
-
-          return result;
-        })
-        .then((data) => resolve(data))
-        .catch((error) => this.handleError(error, reject));
-    });
-  }
-
-  protected async get(
-    fetcher: Fetch,
-    url: string | URL,
-    headers?: Record<string, string>,
-    parameters?: FetchParameters
-  ): Promise<any> {
-    return this._handleRequest(fetcher, "GET", url, headers, parameters);
-  }
-
-  protected async post(
-    fetcher: Fetch,
-    url: string | URL,
-    body: string | Buffer | Readable,
-    headers?: Record<string, string>,
-    parameters?: FetchParameters
-  ): Promise<any> {
-    return this._handleRequest(fetcher, "POST", url, headers, parameters, body);
-  }
-
-  protected async put(
-    fetcher: Fetch,
-    url: string | URL,
-    body: string | Buffer | Readable,
-    headers?: Record<string, string>,
-    parameters?: FetchParameters
-  ): Promise<any> {
-    return this._handleRequest(fetcher, "PUT", url, headers, parameters, body);
-  }
-
-  protected async patch(
-    fetcher: Fetch,
-    url: string | URL,
-    body: string | Buffer | Readable,
-    headers?: Record<string, string>,
-    parameters?: FetchParameters
-  ): Promise<any> {
-    return this._handleRequest(fetcher, "PATCH", url, headers, parameters, body);
-  }
-
-  protected async delete(
-    fetcher: Fetch,
-    url: string | URL,
-    headers?: Record<string, string>,
-    parameters?: FetchParameters
-  ): Promise<any> {
-    return this._handleRequest(fetcher, "DELETE", url, headers, parameters);
-  }
-
-  private _willProxy() {
-    const proxyUrl = this.options.restProxy?.url;
-
-    return !!proxyUrl;
-  }
-}

package/src/packages/AbstractWsClient.ts

@@ -1,42 +0,0 @@
-import { EventEmitter } from "events";
-import { DEFAULT_OPTIONS, DEFAULT_URL } from "../lib/constants";
-import { applySettingDefaults, stripTrailingSlash } from "../lib/helpers";
-import { DeepgramClientOptions } from "../lib/types";
-
-export abstract class AbstractWsClient extends EventEmitter {
-  protected baseUrl: URL;
-
-  constructor(
-    protected key: string,
-    protected options: DeepgramClientOptions | undefined = DEFAULT_OPTIONS
-  ) {
-    super();
-
-    this.key = key;
-
-    if (!key) {
-      this.key = process.env.DEEPGRAM_API_KEY as string;
-    }
-
-    if (!this.key) {
-      throw new Error("A deepgram API key is required");
-    }
-
-    this.options = applySettingDefaults(options, DEFAULT_OPTIONS);
-
-    if (!this.options.global?.url) {
-      throw new Error(
-        `An API URL is required. It should be set to ${DEFAULT_URL} by default. No idea what happened!`
-      );
-    }
-
-    let url = this.options.global.url;
-
-    if (!/^https?:\/\//i.test(url)) {
-      url = "https://" + url;
-    }
-
-    this.baseUrl = new URL(stripTrailingSlash(url));
-    this.baseUrl.protocol = this.baseUrl.protocol.toLowerCase().replace(/(http)(s)?/gi, "ws$2");
-  }
-}

package/src/packages/LiveClient.ts

@@ -1,140 +0,0 @@
-import { AbstractWsClient } from "./AbstractWsClient";
-import { appendSearchParams } from "../lib/helpers";
-import { DeepgramError } from "../lib/errors";
-import { DEFAULT_OPTIONS } from "../lib/constants";
-import { LiveConnectionState, LiveTranscriptionEvents } from "../lib/enums";
-import { w3cwebsocket } from "websocket";
-
-import type {
-  LiveSchema,
-  LiveConfigOptions,
-  LiveMetadataEvent,
-  LiveTranscriptionEvent,
-  DeepgramClientOptions,
-  UtteranceEndEvent,
-  SpeechStartedEvent,
-} from "../lib/types";
-
-export class LiveClient extends AbstractWsClient {
-  private _socket: w3cwebsocket;
-
-  constructor(
-    protected key: string,
-    protected options: DeepgramClientOptions | undefined = DEFAULT_OPTIONS,
-    private transcriptionOptions: LiveSchema = {},
-    endpoint = "v1/listen"
-  ) {
-    super(key, options);
-
-    const url = new URL(endpoint, this.baseUrl);
-    url.protocol = url.protocol.toLowerCase().replace(/(http)(s)?/gi, "ws$2");
-    appendSearchParams(url.searchParams, this.transcriptionOptions);
-
-    this._socket = new w3cwebsocket(url.toString(), ["token", this.key]);
-
-    this._socket.onopen = () => {
-      this.emit(LiveTranscriptionEvents.Open, this);
-    };
-
-    this._socket.onclose = (event: any) => {
-      this.emit(LiveTranscriptionEvents.Close, event);
-    };
-
-    this._socket.onerror = (event) => {
-      this.emit(LiveTranscriptionEvents.Error, event);
-    };
-
-    this._socket.onmessage = (event) => {
-      try {
-        const data: any = JSON.parse(event.data.toString());
-
-        if (data.type === LiveTranscriptionEvents.Metadata) {
-          this.emit(LiveTranscriptionEvents.Metadata, data as LiveMetadataEvent);
-        }
-
-        if (data.type === LiveTranscriptionEvents.Transcript) {
-          this.emit(LiveTranscriptionEvents.Transcript, data as LiveTranscriptionEvent);
-        }
-
-        if (data.type === LiveTranscriptionEvents.UtteranceEnd) {
-          this.emit(LiveTranscriptionEvents.UtteranceEnd, data as UtteranceEndEvent);
-        }
-
-        if (data.type === LiveTranscriptionEvents.SpeechStarted) {
-          this.emit(LiveTranscriptionEvents.SpeechStarted, data as SpeechStartedEvent);
-        }
-      } catch (error) {
-        this.emit(LiveTranscriptionEvents.Error, {
-          event,
-          message: "Unable to parse `data` as JSON.",
-          error,
-        });
-      }
-    };
-  }
-
-  public configure(config: LiveConfigOptions): void {
-    this._socket.send(
-      JSON.stringify({
-        type: "Configure",
-        processors: config,
-      })
-    );
-  }
-
-  public keepAlive(): void {
-    this._socket.send(
-      JSON.stringify({
-        type: "KeepAlive",
-      })
-    );
-  }
-
-  public getReadyState(): LiveConnectionState {
-    return this._socket.readyState;
-  }
-
-  /**
-   * Sends data to the Deepgram API via websocket connection
-   * @param data Audio data to send to Deepgram
-   *
-   * Conforms to RFC #146 for Node.js - does not send an empty byte.
-   * In the browser, a Blob will contain length with no audio.
-   * @see https://github.com/deepgram/deepgram-python-sdk/issues/146
-   */
-  public send(data: string | ArrayBufferLike | Blob): void {
-    if (this._socket.readyState === LiveConnectionState.OPEN) {
-      if (typeof data === "string") {
-        this._socket.send(data); // send text data
-      } else if ((data as any) instanceof Blob) {
-        this._socket.send(data as unknown as ArrayBufferLike); // send blob data
-      } else {
-        const buffer = data as ArrayBufferLike;
-
-        if (buffer.byteLength > 0) {
-          this._socket.send(buffer); // send buffer when not zero-byte (or browser)
-        } else {
-          this.emit(
-            LiveTranscriptionEvents.Warning,
-            "Zero-byte detected, skipping. Send `CloseStream` if trying to close the connection."
-          );
-        }
-      }
-    } else {
-      throw new DeepgramError("Could not send. Connection not open.");
-    }
-  }
-
-  /**
-   * Denote that you are finished sending audio and close
-   * the websocket connection when transcription is finished
-   */
-  public finish(): void {
-    // tell the server to close the socket
-    this._socket.send(
-      JSON.stringify({
-        type: "CloseStream",
-      })
-    );
-  }
-}