@geekmidas/services 1.0.3 → 1.1.0

package/src/__tests__/context.spec.ts

@@ -1,7 +1,40 @@
+import type { Logger } from '@geekmidas/logger';
 import { ConsoleLogger } from '@geekmidas/logger/console';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { runWithRequestContext, serviceContext } from '../context';
 
+/** Minimal spy logger whose `child()` returns itself for easy assertions. */
+function makeSpyLogger(): Logger {
+	const logger: Logger = {
+		trace: vi.fn(),
+		debug: vi.fn(),
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		fatal: vi.fn(),
+		child: vi.fn(() => logger),
+	};
+	return logger;
+}
+
+/**
+ * A logger that carries MORE than the base `Logger` interface: an extra method
+ * (`flush`) and a data property (`level`). Models a richer real-world logger
+ * (e.g. pino) so we can assert the request-scoped proxy forwards the full
+ * surface, not just the known log methods.
+ */
+type ExtendedLogger = Logger & {
+	flush: ReturnType<typeof vi.fn>;
+	level: string;
+};
+
+function makeExtendedSpyLogger(level = 'info'): ExtendedLogger {
+	const logger = makeSpyLogger() as ExtendedLogger;
+	logger.flush = vi.fn();
+	logger.level = level;
+	return logger;
+}
+
 describe('Request Context', () => {
 	const logger = new ConsoleLogger({ app: 'test' });
 
@@ -28,13 +61,156 @@ describe('Request Context', () => {
 				);
 			});
 
-			it('should return logger inside request context', async () => {
+			it('should delegate to the current request logger', async () => {
+				const requestLogger = makeSpyLogger();
 				await runWithRequestContext(
-					{ logger, requestId: 'test-id', startTime: Date.now() },
+					{
+						logger: requestLogger,
+						requestId: 'test-id',
+						startTime: Date.now(),
+					},
 					async () => {
-						expect(serviceContext.getLogger()).toBe(logger);
+						serviceContext.getLogger().info('hello');
 					},
 				);
+				expect(requestLogger.info).toHaveBeenCalledWith('hello');
+			});
+
+			it('captured-once logger follows each request (singleton service fix)', async () => {
+				// Mimic a singleton service that grabs the logger ONCE (during its
+				// one-time register) and reuses that reference for every request.
+				let captured: Logger | undefined;
+				const handle = (requestLogger: Logger) =>
+					runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							captured ??= serviceContext.getLogger();
+							captured.info('handled');
+						},
+					);
+
+				const first = makeSpyLogger();
+				const second = makeSpyLogger();
+				await handle(first);
+				await handle(second);
+
+				// Before the fix, the captured logger stayed bound to `first`, so
+				// `second` never saw the call.
+				expect(first.info).toHaveBeenCalledTimes(1);
+				expect(second.info).toHaveBeenCalledTimes(1);
+			});
+
+			it('child loggers also follow the current request', async () => {
+				let capturedChild: Logger | undefined;
+				const handle = (requestLogger: Logger) =>
+					runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							capturedChild ??= serviceContext
+								.getLogger()
+								.child({ scope: 'svc' });
+							capturedChild.info('scoped');
+						},
+					);
+
+				const first = makeSpyLogger();
+				const second = makeSpyLogger();
+				await handle(first);
+				await handle(second);
+
+				expect(first.child).toHaveBeenCalledWith({ scope: 'svc' });
+				expect(second.child).toHaveBeenCalledWith({ scope: 'svc' });
+				expect(first.info).toHaveBeenCalledWith('scoped');
+				expect(second.info).toHaveBeenCalledWith('scoped');
+			});
+
+			describe('forwards the full logger surface (logger with more)', () => {
+				it('forwards an extra method beyond the Logger interface', async () => {
+					const requestLogger = makeExtendedSpyLogger();
+					await runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							(serviceContext.getLogger() as ExtendedLogger).flush();
+						},
+					);
+					expect(requestLogger.flush).toHaveBeenCalledTimes(1);
+				});
+
+				it('re-resolves an extra method per request when captured once', async () => {
+					let captured: ExtendedLogger | undefined;
+					const handle = (requestLogger: Logger) =>
+						runWithRequestContext(
+							{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+							async () => {
+								captured ??= serviceContext.getLogger() as ExtendedLogger;
+								captured.flush();
+							},
+						);
+
+					const first = makeExtendedSpyLogger();
+					const second = makeExtendedSpyLogger();
+					await handle(first);
+					await handle(second);
+
+					expect(first.flush).toHaveBeenCalledTimes(1);
+					expect(second.flush).toHaveBeenCalledTimes(1);
+				});
+
+				it('forwards a data property as the current request logger value', async () => {
+					const captureLevel = (requestLogger: Logger) =>
+						runWithRequestContext(
+							{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+							async () => (serviceContext.getLogger() as ExtendedLogger).level,
+						);
+
+					const debugLogger = makeExtendedSpyLogger('debug');
+					const warnLogger = makeExtendedSpyLogger('warn');
+
+					expect(await captureLevel(debugLogger)).toBe('debug');
+					expect(await captureLevel(warnLogger)).toBe('warn');
+				});
+
+				it('detached method reference still targets the current request', async () => {
+					const requestLogger = makeExtendedSpyLogger();
+					await runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							const { info } = serviceContext.getLogger();
+							info('detached');
+						},
+					);
+					expect(requestLogger.info).toHaveBeenCalledWith('detached');
+				});
+
+				it('reflects underlying membership via the `in` operator', async () => {
+					const requestLogger = makeExtendedSpyLogger();
+					await runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							const proxy = serviceContext.getLogger();
+							expect('flush' in proxy).toBe(true);
+							expect('child' in proxy).toBe(true);
+							expect('nope' in proxy).toBe(false);
+						},
+					);
+				});
+
+				it('is not thenable (safe to return from async / await)', async () => {
+					await runWithRequestContext(
+						{
+							logger: makeExtendedSpyLogger(),
+							requestId: 'r',
+							startTime: Date.now(),
+						},
+						async () => {
+							const proxy = serviceContext.getLogger();
+							expect((proxy as { then?: unknown }).then).toBeUndefined();
+							// Awaiting a non-thenable yields the value itself rather than
+							// hanging or invoking a spurious `then`.
+							expect(await proxy).toBe(proxy);
+						},
+					);
+				});
 			});
 		});
 

package/src/__tests__/middy.spec.ts

@@ -0,0 +1,218 @@
+import { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import middy from '@middy/core';
+import type { Context } from 'aws-lambda';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { serviceContext } from '../context';
+import { addServices, requestContext, withServices } from '../middy';
+import { ServiceDiscovery } from '../ServiceDiscovery';
+import type { Service } from '../types';
+
+const createMockContext = (): Context =>
+	({
+		functionName: 'standalone',
+		functionVersion: '1',
+		invokedFunctionArn:
+			'arn:aws:lambda:us-east-1:123456789012:function:standalone',
+		memoryLimitInMB: '128',
+		awsRequestId: 'aws-req-1',
+		logGroupName: '/aws/lambda/standalone',
+		logStreamName: 'stream',
+		getRemainingTimeInMillis: () => 30000,
+		done: vi.fn(),
+		fail: vi.fn(),
+		succeed: vi.fn(),
+		callbackWaitsForEmptyEventLoop: true,
+	}) as unknown as Context;
+
+/**
+ * Invoke a Middy-wrapped handler with a mock Lambda context. The service
+ * middlewares augment the context type to require `services`, but at runtime
+ * they populate it before the handler runs — so the mock starts without it and
+ * we invoke through a loosely-typed shim.
+ */
+const invoke = (
+	handler: (event: any, context: any) => any,
+	event: unknown = {},
+): Promise<unknown> => Promise.resolve(handler(event, createMockContext()));
+
+function makeSpyLogger(): Logger {
+	const logger: Logger = {
+		trace: vi.fn(),
+		debug: vi.fn(),
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		fatal: vi.fn(),
+		child: vi.fn(() => logger),
+	};
+	return logger;
+}
+
+interface Greeter {
+	greet(): string;
+	registeredRequestId: string;
+}
+
+class GreeterService implements Service<'greeter', Greeter> {
+	serviceName = 'greeter' as const;
+	async register(): Promise<Greeter> {
+		// Service code can read the request context during registration.
+		const registeredRequestId = serviceContext.getRequestId();
+		return {
+			registeredRequestId,
+			greet() {
+				serviceContext.getLogger().info('greeting');
+				return 'hello';
+			},
+		};
+	}
+}
+
+interface Counter {
+	next(): number;
+}
+
+class CounterService implements Service<'counter', Counter> {
+	serviceName = 'counter' as const;
+	async register(): Promise<Counter> {
+		let n = 0;
+		return { next: () => ++n };
+	}
+}
+
+describe('middy adaptor', () => {
+	beforeEach(() => {
+		// ServiceDiscovery is a process-wide singleton that caches resolved
+		// instances; reset so each test starts clean.
+		ServiceDiscovery.reset();
+	});
+
+	describe('requestContext', () => {
+		it('makes serviceContext available inside a plain handler', async () => {
+			const logger = makeSpyLogger();
+			let seenRequestId: string | undefined;
+			let hadContext = false;
+
+			const handler = middy(async () => {
+				hadContext = serviceContext.hasContext();
+				seenRequestId = serviceContext.getRequestId();
+				serviceContext.getLogger().info('tick');
+			}).use(requestContext({ logger }));
+
+			await invoke(handler);
+
+			expect(hadContext).toBe(true);
+			expect(seenRequestId).toBe('aws-req-1');
+			expect(logger.info).toHaveBeenCalledWith('tick');
+		});
+
+		it('gives each invocation its own fresh context', async () => {
+			const seen: string[] = [];
+			let counter = 0;
+			const handler = middy(async () => {
+				seen.push(serviceContext.getRequestId());
+			}).use(
+				requestContext({
+					logger: makeSpyLogger(),
+					getRequestId: () => `req-${++counter}`,
+				}),
+			);
+
+			await invoke(handler);
+			await invoke(handler);
+
+			// The second invocation must not inherit the first's request id.
+			expect(seen).toEqual(['req-1', 'req-2']);
+		});
+
+		it('propagates handler errors', async () => {
+			const handler = middy(async () => {
+				throw new Error('boom');
+			}).use(requestContext({ logger: makeSpyLogger() }));
+
+			await expect(invoke(handler)).rejects.toThrow('boom');
+		});
+
+		it('derives the request id via getRequestId override', async () => {
+			let seen: string | undefined;
+			const handler = middy(async () => {
+				seen = serviceContext.getRequestId();
+			}).use(
+				requestContext({
+					logger: makeSpyLogger(),
+					getRequestId: () => 'custom-id',
+				}),
+			);
+
+			await invoke(handler);
+			expect(seen).toBe('custom-id');
+		});
+	});
+
+	describe('addServices', () => {
+		it('resolves services onto event.services (paired with requestContext)', async () => {
+			const envParser = new EnvironmentParser({});
+			const logger = makeSpyLogger();
+			let greeting: string | undefined;
+			let counted: number | undefined;
+			let registeredRequestId: string | undefined;
+
+			const handler = middy(async (event: { services: any }) => {
+				registeredRequestId = event.services.greeter.registeredRequestId;
+				greeting = event.services.greeter.greet();
+				counted = event.services.counter.next();
+			})
+				.use(requestContext({ logger, getRequestId: () => 'shared-id' }))
+				.use(
+					addServices([new GreeterService(), new CounterService()], {
+						envParser,
+					}),
+				);
+
+			await invoke(handler);
+
+			expect(greeting).toBe('hello');
+			expect(counted).toBe(1);
+			// register() and the service method ran inside the requestContext.
+			expect(registeredRequestId).toBe('shared-id');
+			expect(logger.info).toHaveBeenCalledWith('greeting');
+		});
+
+		it('resolves context-free services without a requestContext', async () => {
+			const envParser = new EnvironmentParser({});
+			let counted: number | undefined;
+
+			const handler = middy(async (event: { services: any }) => {
+				counted = event.services.counter.next();
+			}).use(addServices([new CounterService()], { envParser }));
+
+			await invoke(handler);
+
+			expect(counted).toBe(1);
+		});
+	});
+
+	describe('withServices', () => {
+		it('establishes context and resolves services out of the box', async () => {
+			const envParser = new EnvironmentParser({});
+			let greeting: string | undefined;
+			let registeredRequestId: string | undefined;
+
+			const handler = middy(async (event: { services: any }) => {
+				registeredRequestId = event.services.greeter.registeredRequestId;
+				greeting = event.services.greeter.greet();
+			}).use(
+				withServices([new GreeterService()], {
+					logger: makeSpyLogger(),
+					envParser,
+				}),
+			);
+
+			await invoke(handler);
+
+			expect(greeting).toBe('hello');
+			expect(registeredRequestId).toBe('aws-req-1');
+		});
+	});
+});

package/src/__tests__/trpc.spec.ts

@@ -0,0 +1,218 @@
+import { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import { initTRPC } from '@trpc/server';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { serviceContext } from '../context';
+import { ServiceDiscovery } from '../ServiceDiscovery';
+import {
+	createRequestContextMiddleware,
+	createServicesMiddleware,
+} from '../trpc';
+import type { Service } from '../types';
+
+beforeEach(() => {
+	// ServiceDiscovery is a process-wide singleton that caches resolved
+	// instances. Reset so each test gets a fresh registry.
+	ServiceDiscovery.reset();
+});
+
+function makeLogger(): Logger {
+	const logger: Logger = {
+		debug: vi.fn(),
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		fatal: vi.fn(),
+		trace: vi.fn(),
+		child: vi.fn(() => logger),
+	};
+	return logger;
+}
+
+describe('createServicesMiddleware (with envParser)', () => {
+	it('resolves services and merges them onto ctx', async () => {
+		const databaseService = {
+			serviceName: 'database' as const,
+			register: () => ({ query: (sql: string) => `result: ${sql}` }),
+		} satisfies Service<'database', { query: (sql: string) => string }>;
+
+		const t = initTRPC.context<{ logger: Logger }>().create();
+		const withServices = createServicesMiddleware(
+			t.middleware,
+			new EnvironmentParser({}),
+		);
+
+		const caller = t.router({
+			run: t.procedure
+				.use(withServices([databaseService]))
+				.query(({ ctx }) => ctx.database.query('select 1')),
+		});
+
+		const result = await caller.createCaller({ logger: makeLogger() }).run();
+
+		expect(result).toBe('result: select 1');
+	});
+
+	it('makes serviceContext.getLogger() readable from inside a service method', async () => {
+		let observedLogger: Logger | null = null;
+		const dbService = {
+			serviceName: 'database' as const,
+			register: () => ({
+				touch() {
+					observedLogger = serviceContext.getLogger();
+					observedLogger.info('touched');
+					return 'ok';
+				},
+			}),
+		} satisfies Service<'database', { touch: () => string }>;
+
+		const t = initTRPC.context<{ logger: Logger }>().create();
+		const withServices = createServicesMiddleware(
+			t.middleware,
+			new EnvironmentParser({}),
+		);
+
+		const requestLogger = makeLogger();
+
+		const caller = t.router({
+			run: t.procedure
+				.use(withServices([dbService]))
+				.query(({ ctx }) => ctx.database.touch()),
+		});
+
+		await caller.createCaller({ logger: requestLogger }).run();
+
+		// getLogger() returns a request-scoped proxy (not the raw logger), so we
+		// assert it delegates to the request logger rather than checking identity.
+		expect(observedLogger).not.toBeNull();
+		expect(requestLogger.info).toHaveBeenCalledWith('touched');
+	});
+
+	it('throws cleanly when service code runs outside the procedure', () => {
+		// Sanity check that serviceContext stays scoped to the procedure call —
+		// reads outside any procedure must throw.
+		expect(() => serviceContext.getLogger()).toThrow();
+	});
+});
+
+describe('createServicesMiddleware (context-supplied discovery)', () => {
+	it('uses ctx.serviceDiscovery when no envParser is provided', async () => {
+		const cacheService = {
+			serviceName: 'cache' as const,
+			register: () => ({ get: (key: string) => `cached:${key}` }),
+		} satisfies Service<'cache', { get: (key: string) => string }>;
+
+		type Ctx = { logger: Logger; serviceDiscovery: ServiceDiscovery };
+		const t = initTRPC.context<Ctx>().create();
+		const withServices = createServicesMiddleware<Ctx, object>(t.middleware);
+
+		const caller = t.router({
+			run: t.procedure
+				.use(withServices([cacheService]))
+				.query(({ ctx }) => ctx.cache.get('k')),
+		});
+
+		const discovery = ServiceDiscovery.getInstance(new EnvironmentParser({}));
+
+		const result = await caller
+			.createCaller({ logger: makeLogger(), serviceDiscovery: discovery })
+			.run();
+
+		expect(result).toBe('cached:k');
+	});
+});
+
+describe('createRequestContextMiddleware', () => {
+	it('exposes ctx.logger via serviceContext.getLogger() for the handler', async () => {
+		const t = initTRPC.context<{ logger: Logger }>().create();
+		const withRequestContext = createRequestContextMiddleware(t.middleware);
+
+		let observed: Logger | null = null;
+		const caller = t.router({
+			run: t.procedure.use(withRequestContext).query(() => {
+				observed = serviceContext.getLogger();
+				observed.info('handled');
+				return 'done';
+			}),
+		});
+
+		const requestLogger = makeLogger();
+		const result = await caller.createCaller({ logger: requestLogger }).run();
+
+		expect(result).toBe('done');
+		// The request-scoped proxy delegates to ctx.logger.
+		expect(observed).not.toBeNull();
+		expect(requestLogger.info).toHaveBeenCalledWith('handled');
+	});
+
+	it('auto-generates requestId and startTime when ctx does not provide them', async () => {
+		const t = initTRPC.context<{ logger: Logger }>().create();
+		const withRequestContext = createRequestContextMiddleware(t.middleware);
+
+		let requestId: string | null = null;
+		let startTime: number | null = null;
+
+		const caller = t.router({
+			run: t.procedure.use(withRequestContext).query(() => {
+				requestId = serviceContext.getRequestId();
+				startTime = serviceContext.getRequestStartTime();
+				return 'ok';
+			}),
+		});
+
+		await caller.createCaller({ logger: makeLogger() }).run();
+
+		expect(requestId).toBeTypeOf('string');
+		expect(requestId!.length).toBeGreaterThan(0);
+		expect(typeof startTime).toBe('number');
+	});
+
+	it('honors caller-supplied requestId and startTime when present on ctx', async () => {
+		type Ctx = { logger: Logger; requestId?: string; startTime?: number };
+		const t = initTRPC.context<Ctx>().create();
+		const withRequestContext = createRequestContextMiddleware(t.middleware);
+
+		let observedId: string | null = null;
+		let observedStart: number | null = null;
+
+		const caller = t.router({
+			run: t.procedure.use(withRequestContext).query(() => {
+				observedId = serviceContext.getRequestId();
+				observedStart = serviceContext.getRequestStartTime();
+				return 'ok';
+			}),
+		});
+
+		await caller
+			.createCaller({
+				logger: makeLogger(),
+				requestId: 'req_abc',
+				startTime: 12345,
+			})
+			.run();
+
+		expect(observedId).toBe('req_abc');
+		expect(observedStart).toBe(12345);
+	});
+});
+
+describe('tagging for tooling', () => {
+	it('attaches the resolved services tuple to the inner middleware', () => {
+		const svc = {
+			serviceName: 'sample' as const,
+			register: () => ({}),
+		} satisfies Service<'sample', {}>;
+
+		const t = initTRPC.context<{ logger: Logger }>().create();
+		const withServices = createServicesMiddleware(
+			t.middleware,
+			new EnvironmentParser({}),
+		);
+
+		const builder = withServices([svc]);
+		const middlewares = (
+			builder as unknown as { _middlewares: Array<{ _services?: Service[] }> }
+		)._middlewares;
+		expect(middlewares?.at(-1)?._services).toEqual([svc]);
+	});
+});