@geekmidas/constructs 3.0.14 → 4.0.0

package/src/adaptors/__tests__/trpc.spec.ts

@@ -1,220 +0,0 @@
-import { EnvironmentParser } from '@geekmidas/envkit';
-import type { Logger } from '@geekmidas/logger';
-import {
-	type Service,
-	ServiceDiscovery,
-	serviceContext,
-} from '@geekmidas/services';
-import { initTRPC } from '@trpc/server';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-	createRequestContextMiddleware,
-	createServicesMiddleware,
-} from '../trpc';
-
-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]);
-	});
-});

package/src/adaptors/trpc.ts

@@ -1,192 +0,0 @@
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import type { Logger } from '@geekmidas/logger';
-import {
-	runWithRequestContext,
-	type Service,
-	ServiceDiscovery,
-	type ServiceRecord,
-} from '@geekmidas/services';
-import type {
-	TRPCMiddlewareBuilder,
-	TRPCMiddlewareFunction,
-} from '@trpc/server';
-
-/**
- * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the
- * initialized `t` object so callers retain ownership of their tRPC instance
- * (no double-initialization, no opinion on context/meta shape).
- */
-type CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(
-	fn: TRPCMiddlewareFunction<
-		TContext,
-		TMeta,
-		object,
-		$ContextOverrides,
-		unknown
-	>,
-) => TRPCMiddlewareBuilder<TContext, TMeta, $ContextOverrides, unknown>;
-
-/**
- * Result of `createServicesMiddleware`: a function that accepts a service
- * tuple and returns a tRPC middleware that merges resolved services onto the
- * context.
- */
-export type ServicesMiddleware<
-	TContext extends object,
-	TMeta extends object,
-> = <const T extends Service[]>(
-	services: [...T],
-) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
-
-/**
- * Context shape required by `createServicesMiddleware` overload 2.
- * Procedures that pull services via context-stored discovery must expose it
- * under `serviceDiscovery`.
- */
-export interface ContextWithServiceDiscovery {
-	serviceDiscovery: ServiceDiscovery;
-}
-
-/**
- * Minimum context required for request-context propagation. `logger` must be
- * present so services can call `serviceContext.getLogger()`. `requestId` and
- * `startTime` are auto-generated if missing.
- */
-export interface ContextWithLogger {
-	logger: Logger;
-	requestId?: string;
-	startTime?: number;
-}
-
-/**
- * Create a tRPC middleware that:
- *
- * 1. Resolves the requested services via `ServiceDiscovery`.
- * 2. Wraps the downstream call in `runWithRequestContext` so any code reached
- *    by the procedure (including service method implementations) can read the
- *    current logger/request id via `serviceContext`.
- * 3. Merges the resolved services onto the tRPC context so handlers can access
- *    them by service name (`ctx.database`, `ctx.cache`, ...).
- *
- * Two overloads:
- * - Pass an `envParser` to create a per-request `ServiceDiscovery` instance.
- * - Omit `envParser` to read `ctx.serviceDiscovery` from the tRPC context.
- *
- * @example
- * ```ts
- * import { initTRPC } from '@trpc/server';
- * import { createServicesMiddleware } from '@geekmidas/constructs/trpc';
- *
- * const t = initTRPC.context<Context>().create();
- * const withServices = createServicesMiddleware(t.middleware, envParser);
- *
- * export const authedProcedure = t.procedure.use(
- *   withServices([databaseService, cacheService]),
- * );
- * ```
- */
-export function createServicesMiddleware<
-	TContext extends ContextWithLogger & object,
-	TMeta extends object,
->(
-	mw: CreateMiddleware<TContext, TMeta>,
-	envParser: EnvironmentParser<{}>,
-): ServicesMiddleware<TContext, TMeta>;
-export function createServicesMiddleware<
-	TContext extends ContextWithLogger & ContextWithServiceDiscovery & object,
-	TMeta extends object,
->(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
-export function createServicesMiddleware<
-	TContext extends ContextWithLogger & object,
-	TMeta extends object,
->(
-	mw: CreateMiddleware<TContext, TMeta>,
-	envParser?: EnvironmentParser<{}>,
-): ServicesMiddleware<TContext, TMeta> {
-	return (<const T extends Service[]>(services: [...T]) => {
-		const builder = mw(async (opts) => {
-			const ctx = opts.ctx as TContext & Partial<ContextWithServiceDiscovery>;
-
-			const discovery =
-				ctx.serviceDiscovery ??
-				ServiceDiscovery.getInstance(
-					envParser ??
-						(() => {
-							// Hit only if overload 2 was selected but ctx.serviceDiscovery is
-							// missing at runtime — surface the mistake immediately rather
-							// than letting an undefined env parser fail deep inside register.
-							throw new Error(
-								'createServicesMiddleware: no `envParser` provided and ' +
-									'`ctx.serviceDiscovery` is missing. Pass an EnvironmentParser ' +
-									'to createServicesMiddleware(), or attach a ServiceDiscovery ' +
-									'instance to the tRPC context.',
-							);
-						})(),
-				);
-
-			const requestId = ctx.requestId ?? crypto.randomUUID();
-			const startTime = ctx.startTime ?? Date.now();
-
-			return runWithRequestContext(
-				{ logger: ctx.logger, requestId, startTime },
-				async () => {
-					const resolved = await discovery.register(services);
-					return opts.next({
-						ctx: { ...opts.ctx, ...resolved } as typeof opts.ctx &
-							ServiceRecord<T>,
-					});
-				},
-			);
-		});
-
-		// Tag the inner middleware function with the requested services so external
-		// tooling (e.g. detect-procedures route generators) can introspect a
-		// procedure's service dependencies without re-executing middleware.
-		const middlewares = (
-			builder as unknown as { _middlewares?: Array<{ _services?: Service[] }> }
-		)._middlewares;
-		if (middlewares?.length) {
-			const last = middlewares[middlewares.length - 1];
-			if (last) last._services = services as unknown as Service[];
-		}
-
-		return builder as TRPCMiddlewareBuilder<
-			TContext,
-			TMeta,
-			ServiceRecord<T>,
-			unknown
-		>;
-	}) as ServicesMiddleware<TContext, TMeta>;
-}
-
-/**
- * Create a tRPC middleware that establishes a request context for downstream
- * code without resolving any services. Useful when services aren't needed on
- * a procedure but the handler (or libraries it calls) still wants to read
- * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.
- *
- * `requestId` and `startTime` are pulled from the tRPC context when present,
- * otherwise generated (`crypto.randomUUID()` and `Date.now()`).
- *
- * @example
- * ```ts
- * const withRequestContext = createRequestContextMiddleware(t.middleware);
- * export const baseProcedure = t.procedure.use(withRequestContext);
- * ```
- */
-export function createRequestContextMiddleware<
-	TContext extends ContextWithLogger & object,
-	TMeta extends object,
->(
-	mw: CreateMiddleware<TContext, TMeta>,
-): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown> {
-	return mw(async (opts) => {
-		const ctx = opts.ctx as TContext;
-		const requestId = ctx.requestId ?? crypto.randomUUID();
-		const startTime = ctx.startTime ?? Date.now();
-		return runWithRequestContext(
-			{ logger: ctx.logger, requestId, startTime },
-			() => opts.next(),
-		);
-	});
-}