fix(auth): address PR feedback

lukeocodes · lukeocodes · commit a5f0bda9cc99 · 2025-06-20T15:05:18.000+01:00
diff --git a/examples/node-auth/index.js b/examples/node-auth/index.js
diff --git a/examples/node-live-token/index.js b/examples/node-live-token/index.js
@@ -0,0 +1,99 @@
+const { createClient, LiveTranscriptionEvents } = require("../../dist/main/index");
+const fetch = require("cross-fetch");
+
+const live = async () => {
+  console.log("transcribing url with auth factory");
+
+  const authFactory = async () => {
+    const deepgramTokenClient = createClient(process.env.DEEPGRAM_API_KEY);
+
+    const { result: tokenResult, error: tokenError } = await deepgramTokenClient.auth.grantToken();
+
+    if (tokenError) console.error(tokenError);
+    if (!tokenError) return tokenResult.access_token;
+  };
+
+  const deepgramClient = createClient({ accessToken: authFactory });
+
+  const url = "http://stream.live.vc.bbcmedia.co.uk/bbc_world_service";
+
+  // We will collect the is_final=true messages here so we can use them when the person finishes speaking
+  let is_finals = [];
+
+  const connection = deepgramClient.listen.live({
+    model: "nova-3",
+    language: "en-US",
+    // Apply smart formatting to the output
+    smart_format: true,
+    // To get UtteranceEnd, the following must be set:
+    interim_results: true,
+    utterance_end_ms: 1000,
+    vad_events: true,
+    // Time in milliseconds of silence to wait for before finalizing speech
+    endpointing: 300,
+    // Keyterm Prompting allows you improve Keyword Recall Rate (KRR) for important keyterms or phrases up to 90%.
+    keyterm: ["BBC"],
+  });
+
+  connection.on(LiveTranscriptionEvents.Open, () => {
+    connection.on(LiveTranscriptionEvents.Close, () => {
+      console.log("Connection closed.");
+    });
+
+    connection.on(LiveTranscriptionEvents.Metadata, (data) => {
+      console.log(`Deepgram Metadata: ${data}`);
+    });
+
+    connection.on(LiveTranscriptionEvents.Transcript, (data) => {
+      const sentence = data.channel.alternatives[0].transcript;
+
+      // Ignore empty transcripts
+      if (sentence.length == 0) {
+        return;
+      }
+      if (data.is_final) {
+        // We need to collect these and concatenate them together when we get a speech_final=true
+        // See docs: https://developers.deepgram.com/docs/understand-endpointing-interim-results
+        is_finals.push(sentence);
+
+        // Speech final means we have detected sufficent silence to consider this end of speech
+        // Speech final is the lowest latency result as it triggers as soon an the endpointing value has triggered
+        if (data.speech_final) {
+          const utterance = is_finals.join(" ");
+          console.log(`Speech Final: ${utterance}`);
+          is_finals = [];
+        } else {
+          // These are useful if you need real time captioning and update what the Interim Results produced
+          console.log(`Is Final: ${sentence}`);
+        }
+      } else {
+        // These are useful if you need real time captioning of what is being spoken
+        console.log(`Interim Results: ${sentence}`);
+      }
+    });
+
+    connection.on(LiveTranscriptionEvents.UtteranceEnd, (_data) => {
+      const utterance = is_finals.join(" ");
+      console.log(`Deepgram UtteranceEnd: ${utterance}`);
+      is_finals = [];
+    });
+
+    connection.on(LiveTranscriptionEvents.SpeechStarted, (_data) => {
+      // console.log("Deepgram SpeechStarted");
+    });
+
+    connection.on(LiveTranscriptionEvents.Error, (err) => {
+      console.error(err);
+    });
+
+    fetch(url)
+      .then((r) => r.body)
+      .then((res) => {
+        res.on("readable", () => {
+          connection.send(res.read());
+        });
+      });
+  });
+};
+
+live();
diff --git a/examples/node-prerecorded/index.js b/examples/node-prerecorded/index.js
@@ -2,7 +2,62 @@ const { createClient } = require("../../dist/main/index");
 const fs = require("fs");
 const path = require("path");
 
+const transcribeUrlAuthWithFactory = async () => {
+  console.log("transcribing url with auth factory");
+
+  const authFactory = async () => {
+    const deepgramTokenClient = createClient(process.env.DEEPGRAM_API_KEY);
+
+    const { result: tokenResult, error: tokenError } = await deepgramTokenClient.auth.grantToken();
+
+    if (tokenError) console.error(tokenError);
+    if (!tokenError) return tokenResult.access_token;
+  };
+
+  const deepgramClient = createClient({ accessToken: authFactory });
+
+  console.log("Transcribing URL", "https://dpgr.am/spacewalk.wav");
+  const { result, error } = await deepgramClient.listen.prerecorded.transcribeUrl(
+    {
+      url: "https://dpgr.am/spacewalk.wav",
+    },
+    {
+      model: "nova-3",
+    }
+  );
+
+  if (error) console.error(error);
+  if (!error) console.dir(result, { depth: 1 });
+};
+
+const transcribeUrlWithAccessToken = async () => {
+  console.log("transcribing url with access token");
+
+  const deepgramTokenClient = createClient(process.env.DEEPGRAM_API_KEY);
+
+  const { result: tokenResult, error: tokenError } = await deepgramTokenClient.auth.grantToken();
+
+  if (tokenError) console.error(tokenError);
+
+  const deepgramClient = createClient({ accessToken: tokenResult.access_token });
+
+  console.log("Transcribing URL", "https://dpgr.am/spacewalk.wav");
+  const { result, error } = await deepgramClient.listen.prerecorded.transcribeUrl(
+    {
+      url: "https://dpgr.am/spacewalk.wav",
+    },
+    {
+      model: "nova-3",
+    }
+  );
+
+  if (error) console.error(error);
+  if (!error) console.dir(result, { depth: 1 });
+};
+
 const transcribeUrl = async () => {
+  console.log("transcribing url with api key");
+
   const deepgram = createClient(process.env.DEEPGRAM_API_KEY);
 
   console.log("Transcribing URL", "https://dpgr.am/spacewalk.wav");
@@ -12,7 +67,6 @@ const transcribeUrl = async () => {
     },
     {
       model: "nova-3",
-      keyterm: ["spacewalk"],
     }
   );
 
@@ -21,6 +75,8 @@ const transcribeUrl = async () => {
 };
 
 const transcribeFile = async () => {
+  console.log("transcribing file with api key");
+
   const deepgram = createClient(process.env.DEEPGRAM_API_KEY);
 
   const filePath = path.join(__dirname, "../spacewalk.wav");
@@ -30,12 +86,15 @@ const transcribeFile = async () => {
   console.log("Transcribing file", file);
   const { result, error } = await deepgram.listen.prerecorded.transcribeFile(file, {
     model: "nova-3",
-    keyterm: ["spacewalk"],
   });
 
   if (error) console.error(error);
   if (!error) console.dir(result, { depth: 1 });
 };
 
-transcribeUrl();
-transcribeFile();
+(async () => {
+  await transcribeUrl();
+  await transcribeFile();
+  await transcribeUrlAuthWithFactory();
+  await transcribeUrlWithAccessToken();
+})();
diff --git a/src/lib/types/DeepgramClientOptions.ts b/src/lib/types/DeepgramClientOptions.ts
@@ -24,7 +24,8 @@ interface ITransport<C, O> {
 }
 
 export type DefaultNamespaceOptions = {
-  key?: string;
+  key?: string | IKeyFactory;
+  accessToken?: string | IKeyFactory;
   fetch: {
     options: { url: TransportUrl };
   };
@@ -34,7 +35,8 @@ export type DefaultNamespaceOptions = {
 } & NamespaceOptions;
 
 export interface NamespaceOptions {
-  key?: string;
+  key?: string | IKeyFactory;
+  accessToken?: string | IKeyFactory;
   fetch?: ITransport<IFetch, TransportFetchOptions>;
   websocket?: ITransport<IWebSocket, TransportWebSocketOptions>;
 }
@@ -58,7 +60,7 @@ export type DefaultClientOptions = {
  */
 export interface DeepgramClientOptions {
   key?: string | IKeyFactory;
-  accessToken?: string;
+  accessToken?: string | IKeyFactory;
   global?: NamespaceOptions & { url?: string; headers?: { [index: string]: any } };
   listen?: NamespaceOptions;
   manage?: NamespaceOptions;
diff --git a/src/packages/AbstractClient.ts b/src/packages/AbstractClient.ts
@@ -44,21 +44,28 @@ export abstract class AbstractClient extends EventEmitter {
   constructor(options: DeepgramClientOptions) {
     super();
 
-    if (options.accessToken) {
+    // run the factory for the access token if it's a function
+    if (typeof options.accessToken === "function") {
+      this.factory = options.accessToken;
+      this.accessToken = this.factory();
+    } else {
       this.accessToken = options.accessToken;
     }
 
+    // run the factory for the key if it's a function
     if (typeof options.key === "function") {
       this.factory = options.key;
       this.key = this.factory();
     } else {
       this.key = options.key;
     }
 
-    if (!this.key) {
+    // if we still have neither, try to use the DEEPGRAM_API_KEY environment variable
+    if (!this.key && !this.accessToken) {
       this.key = process.env.DEEPGRAM_API_KEY as string;
     }
 
+    // if we STILL have neither, throw an error
     if (!this.key && !this.accessToken) {
       throw new DeepgramError("A deepgram API key or temporary auth token is required.");
     }
diff --git a/src/packages/AbstractLiveClient.ts b/src/packages/AbstractLiveClient.ts
