Merge pull request #25 from betwixt-labs/auth-context-fixes

Refactor 'AuthContext' and 'ServerContext'

Author: andrewmd5

typescript/build.sh

@@ -88,8 +88,8 @@ echo "export const TempoVersion = '$VERSION';" > $COMMON_VERSION_FILE
 
 echo "All package versions and '@tempojs' dependencies have been updated to $VERSION."
 
-# Test
-yarn vitest run
+# Install
+yarn install
 
 # Build and pack the 'common' package.
 build ./packages/common
@@ -109,5 +109,5 @@ build ./packages/cf-router
 # Build and pack the 'node-http-router' package.
 build ./packages/node-http
 
-# Install package dependencies
-yarn install
+# Test
+yarn vitest run

typescript/package.json

@@ -29,6 +29,6 @@
     "@tempojs/client": "^0.0.5",
     "@tempojs/common": "^0.0.5",
     "@tempojs/server": "^0.0.5",
-    "bebop": "^2.8.2"
+    "bebop": "^2.8.3"
   }
 }

typescript/packages/cf-router/src/router.ts

@@ -4,7 +4,7 @@ import {
 	TempoError,
 	TempoStatusCode,
 	TempoUtil,
-	stringifyCredentials,
+	stringifyCredential,
 	Deadline,
 	MethodType,
 	tempoStream,
@@ -114,15 +114,15 @@ export class TempoRouter<TEnv> extends BaseRouter<Request, TEnv, Response> {
 		}
 		headers.set(
 			'access-control-expose-headers',
-			'content-encoding, content-length, content-type, tempo-status, tempo-message, custom-metadata, tempo-credentials',
+			'content-encoding, content-length, content-type, tempo-status, tempo-message, custom-metadata, tempo-credential',
 		);
 	}
 
 	private async setAuthContext(request: Request, context: ServerContext): Promise<void> {
 		const authHeader = request.headers.get('authorization');
 		if (authHeader !== null && this.authInterceptor !== undefined) {
 			const authContext = await this.authInterceptor.intercept(context, authHeader);
-			context.setAuthContext(authContext);
+			context.authContext = authContext;
 		}
 	}
 
@@ -174,7 +174,7 @@ export class TempoRouter<TEnv> extends BaseRouter<Request, TEnv, Response> {
 					}
 					return record;
 				},
-				context.clientDeadline(),
+				context.clientDeadline,
 			);
 		};
 		return await method.invoke(generator, context);
@@ -231,7 +231,7 @@ export class TempoRouter<TEnv> extends BaseRouter<Request, TEnv, Response> {
 					}
 					return record;
 				},
-				context.clientDeadline(),
+				context.clientDeadline,
 			);
 		};
 		if (!TempoUtil.isAsyncGeneratorFunction(method.invoke)) {
@@ -355,9 +355,9 @@ export class TempoRouter<TEnv> extends BaseRouter<Request, TEnv, Response> {
 				}
 				responseHeaders.set('content-type', contentType.raw);
 
-				const outgoingCredentials = context.getOutgoingCredentials();
-				if (outgoingCredentials) {
-					responseHeaders.set('tempo-credentials', stringifyCredentials(outgoingCredentials));
+				const outgoingCredential = context.outgoingCredential;
+				if (outgoingCredential) {
+					responseHeaders.set('tempo-credential', stringifyCredential(outgoingCredential));
 				}
 				responseHeaders.set('tempo-status', '0');
 				responseHeaders.set('tempo-message', 'OK');
@@ -384,7 +384,7 @@ export class TempoRouter<TEnv> extends BaseRouter<Request, TEnv, Response> {
 							}
 							return data;
 						},
-						context.clientDeadline(),
+						context.clientDeadline,
 					);
 				} else {
 					if (record === undefined) {

typescript/packages/client/src/auth.ts

@@ -1,102 +1,102 @@
-import { Credentials, parseCredentials, stringifyCredentials } from '@tempojs/common';
+import { Credential, parseCredential, stringifyCredential } from '@tempojs/common';
 
 /**
  * A type representing an HTTP header with a name and value.
  */
 type Header = { name: string; value: string };
 
 /**
- * An interface defining the methods required for a credentials storage strategy.
+ * An interface defining the methods required for a credential storage strategy.
  */
-export interface CredentialsStorage {
+export interface CredentialStorage {
 	/**
-	 * Retrieves stored credentials for a given key.
-	 * @param key - The key associated with the stored credentials.
-	 * @returns A Promise that resolves with the credentials, or undefined if not found.
+	 * Retrieves stored credential for a given key.
+	 * @param key - The key associated with the stored credential.
+	 * @returns A Promise that resolves with the credential, or undefined if not found.
 	 */
-	getCredentials(key: string): Promise<Credentials | undefined>;
+	getCredential(key: string): Promise<Credential | undefined>;
 
 	/**
-	 * Stores credentials for a given key.
-	 * @param key - The key associated with the credentials to store.
-	 * @param credentials - The credentials to store.
-	 * @returns A Promise that resolves when the credentials have been stored.
+	 * Stores credential for a given key.
+	 * @param key - The key associated with the credential to store.
+	 * @param credential - The credential to store.
+	 * @returns A Promise that resolves when the credential have been stored.
 	 */
-	storeCredentials(key: string, credentials: Credentials): Promise<void>;
+	storeCredential(key: string, credential: Credential): Promise<void>;
 
 	/**
-	 * Removes the credentials stored for a given key.
-	 * @param key - The key associated with the credentials to store.
+	 * Removes the credential stored for a given key.
+	 * @param key - The key associated with the credential to store.
 	 */
-	removeCredentials(key: string): Promise<void>;
+	removeCredential(key: string): Promise<void>;
 }
 
 /**
- * An implementation of CredentialsStorage using the browser's localStorage.
+ * An implementation of CredentialStorage using the browser's localStorage.
  */
-export class LocalStorageStrategy implements CredentialsStorage {
-	async getCredentials(key: string): Promise<Credentials | undefined> {
+export class LocalStorageStrategy implements CredentialStorage {
+	async getCredential(key: string): Promise<Credential | undefined> {
 		const storedValue = localStorage.getItem(key);
 		if (!storedValue) return undefined;
-		return parseCredentials(storedValue);
+		return parseCredential(storedValue);
 	}
 
-	async storeCredentials(key: string, credentials: Credentials): Promise<void> {
-		localStorage.setItem(key, stringifyCredentials(credentials));
+	async storeCredential(key: string, credential: Credential): Promise<void> {
+		localStorage.setItem(key, stringifyCredential(credential));
 	}
 
-	async removeCredentials(key: string): Promise<void> {
+	async removeCredential(key: string): Promise<void> {
 		localStorage.removeItem(key);
 	}
 }
 
 /**
- * An implementation of CredentialsStorage using the browser's sessionStorage.
+ * An implementation of CredentialStorage using the browser's sessionStorage.
  */
-export class SessionStorageStrategy implements CredentialsStorage {
-	async getCredentials(key: string): Promise<Credentials | undefined> {
+export class SessionStorageStrategy implements CredentialStorage {
+	async getCredential(key: string): Promise<Credential | undefined> {
 		const storedValue = sessionStorage.getItem(key);
 		if (!storedValue) return undefined;
-		return parseCredentials(storedValue);
+		return parseCredential(storedValue);
 	}
 
-	async storeCredentials(key: string, credentials: Credentials): Promise<void> {
-		sessionStorage.setItem(key, stringifyCredentials(credentials));
+	async storeCredential(key: string, credential: Credential): Promise<void> {
+		sessionStorage.setItem(key, stringifyCredential(credential));
 	}
 
-	async removeCredentials(key: string): Promise<void> {
+	async removeCredential(key: string): Promise<void> {
 		sessionStorage.removeItem(key);
 	}
 }
 
 /**
- * A no-operation implementation of CredentialsStorage that does not store or retrieve credentials.
+ * A no-operation implementation of CredentialStorage that does not store or retrieve credential.
  */
-export class NoStorageStrategy implements CredentialsStorage {
-	async getCredentials(_key: string): Promise<Credentials | undefined> {
+export class NoStorageStrategy implements CredentialStorage {
+	async getCredential(_key: string): Promise<Credential | undefined> {
 		return undefined;
 	}
 
-	async storeCredentials(_key: string, _credentials: Credentials): Promise<void> {
+	async storeCredential(_key: string, _credential: Credential): Promise<void> {
 		// No storage implementation
 	}
 
-	async removeCredentials(_key: string): Promise<void> {
+	async removeCredential(_key: string): Promise<void> {
 		// No storage implementation
 	}
 }
 
 /**
- * An abstract class representing the base for all CallCredentials implementations.
+ * An abstract class representing the base for all CallCredential implementations.
  */
-export abstract class CallCredentials {
-	protected constructor(protected storage: CredentialsStorage, protected key: string) {}
+export abstract class CallCredential {
+	protected constructor(protected storage: CredentialStorage, protected key: string) {}
 
 	/**
-	 * Retrieves stored credentials.
-	 * @returns A Promise that resolves with the credentials, or undefined if not found.
+	 * Retrieves stored credential.
+	 * @returns A Promise that resolves with the credential, or undefined if not found.
 	 */
-	public abstract getCredentials(): Promise<Credentials | undefined>;
+	public abstract getCredential(): Promise<Credential | undefined>;
 
 	/**
 	 * Retrieves the HTTP header to be used for authentication.
@@ -105,31 +105,30 @@ export abstract class CallCredentials {
 	public abstract getHeader(): Promise<Header | undefined>;
 
 	/**
-	 * Stores credentials.
-	 * @param credentials - The credentials to store.
-	 * @returns A Promise that resolves when the credentials have been stored.
+	 * Stores credential.
+	 * @param credential - The credential to store.
+	 * @returns A Promise that resolves when the credential have been stored.
 	 */
-	public abstract storeCredentials(credentials: Credentials): Promise<void>;
+	public abstract storeCredential(credential: Credential): Promise<void>;
 
 	/**
-	 * Remove credentials.
-	 * @param credentials - The credentials to remove.
-	 * @returns A Promise that resolves when the credentials have been removed.
+	 * Remove credential.
+	 * @returns A Promise that resolves when the credential have been removed.
 	 */
-	public async removeCredentials(): Promise<void> {
-		await this.storage.removeCredentials(this.key);
+	public async removeCredential(): Promise<void> {
+		await this.storage.removeCredential(this.key);
 	}
 }
 
 /**
- * An implementation of CallCredentials for insecure (unauthenticated) channels.
+ * An implementation of CallCredential for insecure (unauthenticated) channels.
  */
-export class InsecureChannelCredentials extends CallCredentials {
+export class InsecureChannelCredential extends CallCredential {
 	/**
-	 * Retrieves stored credentials. Always returns undefined for insecure channels.
+	 * Retrieves stored credential. Always returns undefined for insecure channels.
 	 * @returns A Promise that resolves with undefined.
 	 */
-	public override getCredentials(): Promise<Credentials | undefined> {
+	public override getCredential(): Promise<Credential | undefined> {
 		return Promise.resolve(undefined);
 	}
 
@@ -142,69 +141,69 @@ export class InsecureChannelCredentials extends CallCredentials {
 	}
 
 	/**
-	 * Stores credentials. Does nothing for insecure channels.
-	 * @param credentials - The credentials to store.
+	 * Stores credential. Does nothing for insecure channels.
+	 * @param credential - The credential to store.
 	 * @returns A Promise that resolves immediately.
 	 */
-	public override storeCredentials(_credentials: Credentials): Promise<void> {
+	public override storeCredential(_credential: Credential): Promise<void> {
 		return Promise.resolve();
 	}
 
 	/**
-	 * Creates a new instance of InsecureChannelCredentials.
-	 * @returns A new instance of InsecureChannelCredentials.
+	 * Creates a new instance of InsecureChannelCredential.
+	 * @returns A new instance of InsecureChannelCredential.
 	 */
-	public static create(): InsecureChannelCredentials {
-		return new InsecureChannelCredentials(new NoStorageStrategy(), '');
+	public static create(): InsecureChannelCredential {
+		return new InsecureChannelCredential(new NoStorageStrategy(), '');
 	}
 }
 
 /**
- * An implementation of CallCredentials for Bearer token authentication.
+ * An implementation of CallCredential for Bearer token authentication.
  */
-export class BearerCredentials extends CallCredentials {
-	constructor(storage: CredentialsStorage, key: string) {
+export class BearerCredential extends CallCredential {
+	constructor(storage: CredentialStorage, key: string) {
 		super(storage, key);
 	}
 
 	/**
-	 * Retrieves stored credentials from the storage strategy.
-	 * @returns A Promise that resolves with the credentials, or undefined if not found.
+	 * Retrieves stored credential from the storage strategy.
+	 * @returns A Promise that resolves with the credential, or undefined if not found.
 	 */
-	public async getCredentials(): Promise<Credentials | undefined> {
-		return await this.storage.getCredentials(this.key);
+	public async getCredential(): Promise<Credential | undefined> {
+		return await this.storage.getCredential(this.key);
 	}
 
 	/**
 	 * Retrieves the HTTP header for Bearer token authentication.
 	 * @returns A Promise that resolves with the header, or undefined if the token is not available.
 	 */
 	public override async getHeader(): Promise<Header | undefined> {
-		const credentials = await this.getCredentials();
-		if (!credentials) return undefined;
+		const credential = await this.getCredential();
+		if (!credential) return undefined;
 
-		const token = credentials['access_token'] || credentials['token'] || credentials['accessToken'];
+		const token = credential['access_token'] || credential['token'] || credential['accessToken'];
 		if (!token) return undefined;
 
 		return { name: 'Authorization', value: `Bearer ${token}` };
 	}
 
 	/**
-	 * Stores credentials using the storage strategy.
-	 * @param credentials - The credentials to store.
-	 * @returns A Promise that resolves when the credentials have been stored.
+	 * Stores credential using the storage strategy.
+	 * @param credential - The credential to store.
+	 * @returns A Promise that resolves when the credential have been stored.
 	 */
-	public async storeCredentials(credentials: Credentials): Promise<void> {
-		await this.storage.storeCredentials(this.key, credentials);
+	public async storeCredential(credential: Credential): Promise<void> {
+		await this.storage.storeCredential(this.key, credential);
 	}
 
 	/**
-	 * Creates a new instance of BearerCredentials with the specified storage strategy and key.
-	 * @param storage - The storage strategy to use for storing and retrieving credentials.
-	 * @param key - The key associated with the credentials.
-	 * @returns A new instance of BearerCredentials.
+	 * Creates a new instance of BearerCredential with the specified storage strategy and key.
+	 * @param storage - The storage strategy to use for storing and retrieving credential.
+	 * @param key - The key associated with the credential.
+	 * @returns A new instance of BearerCredential.
 	 */
-	public static create(storage: CredentialsStorage, key: string): BearerCredentials {
-		return new BearerCredentials(storage, key);
+	public static create(storage: CredentialStorage, key: string): BearerCredential {
+		return new BearerCredential(storage, key);
 	}
 }