feat!: refactor server/auth context

Author: andrewmd5

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

@@ -122,7 +122,7 @@ export class TempoRouter<TEnv> extends BaseRouter<Request, TEnv, Response> {
 		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,7 +355,7 @@ export class TempoRouter<TEnv> extends BaseRouter<Request, TEnv, Response> {
 				}
 				responseHeaders.set('content-type', contentType.raw);
 
-				const outgoingCredential = context.getOutgoingCredential();
+				const outgoingCredential = context.outgoingCredential;
 				if (outgoingCredential) {
 					responseHeaders.set('tempo-credential', stringifyCredential(outgoingCredential));
 				}
@@ -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/node-http/src/router.ts

@@ -107,7 +107,7 @@ export class TempoRouter<TEnv> extends BaseRouter<IncomingMessage, TEnv, ServerR
 		const authHeader = request.headers.authorization;
 		if (authHeader !== undefined && this.authInterceptor !== undefined) {
 			const authContext = await this.authInterceptor.intercept(context, authHeader);
-			context.setAuthContext(authContext);
+			context.authContext = authContext;
 		}
 	}
 
@@ -165,7 +165,7 @@ export class TempoRouter<TEnv> extends BaseRouter<IncomingMessage, TEnv, ServerR
 					}
 					return record;
 				},
-				context.clientDeadline(),
+				context.clientDeadline,
 			);
 		};
 		return await method.invoke(generator, context);
@@ -228,7 +228,7 @@ export class TempoRouter<TEnv> extends BaseRouter<IncomingMessage, TEnv, ServerR
 					}
 					return record;
 				},
-				context.clientDeadline(),
+				context.clientDeadline,
 			);
 		};
 		if (!TempoUtil.isAsyncGeneratorFunction(method.invoke)) {
@@ -343,7 +343,7 @@ export class TempoRouter<TEnv> extends BaseRouter<IncomingMessage, TEnv, ServerR
 				}
 				response.setHeader('content-type', contentType.raw);
 
-				const outgoingCredential = context.getOutgoingCredential();
+				const outgoingCredential = context.outgoingCredential;
 				if (outgoingCredential) {
 					response.setHeader('tempo-credential', stringifyCredential(outgoingCredential));
 				}
@@ -368,7 +368,7 @@ export class TempoRouter<TEnv> extends BaseRouter<IncomingMessage, TEnv, ServerR
 							}
 							return data;
 						},
-						context.clientDeadline(),
+						context.clientDeadline,
 					);
 				} else {
 					if (record === undefined) {

typescript/packages/server/src/auth.test.ts

@@ -0,0 +1,127 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { AuthContext } from './auth';
+import { TempoError } from '@tempojs/common';
+
+describe('AuthContext', () => {
+	let authContext: AuthContext;
+	let key: string;
+	let propertyName: string;
+	let propertyValue: unknown;
+
+	beforeEach(() => {
+		authContext = new AuthContext();
+		key = 'key1';
+		propertyName = 'prop1';
+		propertyValue = 'value1';
+		authContext.addProperty(key, propertyName, propertyValue);
+	});
+
+	it('should add a new property', () => {
+		const prop = authContext.findPropertyByName(key, propertyName);
+		expect(prop).toBeDefined();
+		expect(prop?.name).toEqual(propertyName);
+		expect(prop?.getValue()).toEqual(propertyValue);
+	});
+
+	it('should return peer identity if authenticated', () => {
+		authContext.peerIdentityKey = key;
+		const peerIdentity = authContext.peerIdentity;
+		expect(peerIdentity).toBeDefined();
+		expect(peerIdentity?.[0]?.name).toEqual(propertyName);
+		expect(peerIdentity?.[0]?.getValue()).toEqual(propertyValue);
+	});
+
+	it('should throw TempoError when setting undefined key as peerIdentityKey', () => {
+		expect(() => {
+			authContext.peerIdentityKey = undefined;
+		}).toThrow(TempoError);
+	});
+
+	it('should throw TempoError when setting a non-existent key as peerIdentityKey', () => {
+		expect(() => {
+			authContext.peerIdentityKey = 'nonExistentKey';
+		}).toThrow(TempoError);
+	});
+
+	it('should return undefined for non-authenticated peer', () => {
+		const nonAuthenticatedContext = new AuthContext();
+		const peerIdentity = nonAuthenticatedContext.peerIdentity;
+		expect(peerIdentity).toBeUndefined();
+	});
+
+	it('should return undefined for non-existing property', () => {
+		const prop = authContext.findPropertyByName(key, 'nonExistingProperty');
+		expect(prop).toBeUndefined();
+	});
+
+	it('should return undefined for properties of non-existing key', () => {
+		const properties = authContext.getProperties('nonExistingKey');
+		expect(properties).toBeUndefined();
+	});
+});
+
+describe('AuthContext - Edge Cases', () => {
+	let authContext: AuthContext;
+
+	beforeEach(() => {
+		authContext = new AuthContext();
+	});
+
+	it('should handle adding a property with null or undefined key', () => {
+		expect(() => {
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			//@ts-ignore
+			authContext.addProperty(null, 'propertyName', 'value');
+		}).toThrow(TempoError);
+		expect(() => {
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			//@ts-ignore
+			authContext.addProperty(undefined, 'propertyName', 'value');
+		}).toThrow(TempoError);
+	});
+
+	it('should handle adding a property with null or undefined name', () => {
+		expect(() => {
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			//@ts-ignore
+			authContext.addProperty('key', null, 'value');
+		}).toThrow(TempoError);
+		expect(() => {
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			//@ts-ignore
+			authContext.addProperty('key', undefined, 'value');
+		}).toThrow(TempoError);
+	});
+
+	it('should handle adding a property with undefined value', () => {
+		expect(() => authContext.addProperty('key', 'propertyName', undefined)).toThrow(TempoError);
+	});
+
+	it('should handle multiple properties with the same key and name', () => {
+		const value1 = 'value1';
+		const value2 = 'value2';
+		authContext.addProperty('key', 'propertyName', value1);
+		authContext.addProperty('key', 'propertyName', value2);
+		const properties = authContext.findPropertiesByName('key', 'propertyName');
+		expect(properties).toBeDefined();
+		expect(properties?.length).toEqual(2);
+		expect(properties?.[0]?.getValue()).toEqual(value1);
+		expect(properties?.[1]?.getValue()).toEqual(value2);
+	});
+
+	it('should throw error when trying to set peer identity with non-existing key', () => {
+		expect(() => {
+			authContext.peerIdentityKey = 'nonExistentKey';
+		}).toThrow(TempoError);
+	});
+
+	it('should handle setting peer identity with a key that exists but has no properties', () => {
+		const emptyKey = 'emptyKey';
+		authContext.addProperty(emptyKey, 'propertyName', 'value');
+		authContext.getProperties(emptyKey)?.pop();
+		expect(() => {
+			authContext.peerIdentityKey = emptyKey;
+		}).not.toThrow();
+		expect(authContext.peerIdentity).length(0);
+	});
+});