@geekmidas/services 1.0.4 → 1.1.0

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]);
+	});
+});

package/src/context.ts

@@ -85,16 +85,18 @@ function createRequestScopedLogger(bindings: object[] = []): Logger {
 			if (prop === 'then' || typeof prop === 'symbol') {
 				return undefined;
 			}
-			const value = (resolve() as Record<string, unknown>)[prop];
+			const value = (resolve() as unknown as Record<string, unknown>)[prop];
 			// Functions are re-resolved at *call* time so detached references
 			// (`const info = logger.info`) still target the current request's
 			// logger. Non-function members (e.g. `level`) forward as their live
 			// value on the current request's logger.
 			return typeof value === 'function'
-				? (...args: unknown[]) =>
-						(resolve() as Record<string, (...a: unknown[]) => unknown>)[prop](
-							...args,
-						)
+				? (...args: unknown[]) => {
+						const fn = (resolve() as unknown as Record<string, unknown>)[
+							prop
+						] as (...a: unknown[]) => unknown;
+						return fn(...args);
+					}
 				: value;
 		},
 		// Keep `'prop' in logger` / hasOwnProperty truthful against the underlying

package/src/middy.ts

@@ -0,0 +1,226 @@
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import type { MiddlewareObj } from '@middy/core';
+import type { Context } from 'aws-lambda';
+import { enterRequestContext, exitRequestContext } from './context';
+import { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';
+import type { Service } from './types';
+
+/**
+ * Middy middleware helpers that bring `@geekmidas/services` request context and
+ * service discovery to **standalone** Middy Lambda handlers — i.e. functions
+ * that aren't built with the `@geekmidas/constructs` Function/Cron constructs
+ * but still want `serviceContext.getLogger()` and resolved services.
+ *
+ * Why middleware (and not `runWithRequestContext`)? Middy runs `before → handler
+ * → after` as sequential awaits in a single async context, so establishing the
+ * context with `AsyncLocalStorage.enterWith` (via `enterRequestContext`) in a
+ * `before` hook propagates to the handler. `after`/`onError` reset it.
+ *
+ * Teardown is best-effort: like `enterRequestContext`, the reset is observable
+ * to code the handler reaches but not necessarily to the frame that invoked the
+ * Middy handler. This is fine for Lambda, where each invocation runs in its own
+ * fresh async context — `requestContext` always establishes a brand-new context
+ * per invocation, so requests never inherit a previous invocation's logger.
+ *
+ * @module
+ */
+
+/**
+ * Options for {@link requestContext}. Generic over the logger type so a custom
+ * logger that extends {@link Logger} is preserved rather than widened.
+ */
+export interface RequestContextOptions<TLogger extends Logger = Logger> {
+	/**
+	 * Logger to derive the per-request child logger from. Required — the caller
+	 * decides which logger to use (there is no implicit default).
+	 */
+	logger: TLogger;
+	/**
+	 * Derive the request id from the event/context.
+	 * Defaults to `context.awsRequestId` (always present in a Lambda invocation).
+	 */
+	getRequestId?: (event: unknown, context: Context) => string;
+	/**
+	 * Extra bindings to attach to the per-request child logger.
+	 */
+	bindings?: (event: unknown, context: Context) => Record<string, unknown>;
+}
+
+/**
+ * Options for {@link addServices} — how services are resolved. No logger is
+ * needed because resolving services doesn't establish a request context.
+ */
+export interface ServiceResolverOptions {
+	/**
+	 * Environment parser used to build the {@link ServiceDiscovery}. Required —
+	 * the caller supplies the parser (there is no implicit `process.env` default).
+	 */
+	envParser: EnvironmentParser<{}>;
+	/**
+	 * Explicit {@link ServiceDiscovery} to resolve services from. Takes
+	 * precedence over `envParser`.
+	 */
+	serviceDiscovery?: ServiceDiscovery;
+}
+
+/**
+ * Options for {@link withServices}: request context (logger) + service resolution.
+ */
+export type ServiceMiddlewareOptions<TLogger extends Logger = Logger> =
+	RequestContextOptions<TLogger> & ServiceResolverOptions;
+
+function deriveRequestId(
+	options: RequestContextOptions,
+	event: unknown,
+	context: Context,
+): string {
+	// Lambda always populates context.awsRequestId; getRequestId can override it.
+	return options.getRequestId?.(event, context) ?? context.awsRequestId;
+}
+
+function buildLogger(
+	baseLogger: Logger,
+	options: RequestContextOptions,
+	requestId: string,
+	event: unknown,
+	context: Context,
+): Logger {
+	return baseLogger.child({
+		requestId,
+		...(options.bindings?.(event, context) ?? {}),
+	});
+}
+
+/**
+ * Middy middleware that establishes a request context for the handler so any
+ * code it reaches — including `@geekmidas/services` service methods — can call
+ * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.
+ *
+ * Use this on standalone functions that need request-scoped logging. To also
+ * resolve services, pair it with {@link addServices}, or use
+ * {@link withServices} which bundles both.
+ *
+ * @example
+ * ```ts
+ * import middy from '@middy/core';
+ * import { serviceContext } from '@geekmidas/services';
+ * import { requestContext } from '@geekmidas/services/middy';
+ *
+ * export const handler = middy(async () => {
+ *   serviceContext.getLogger().info('tick');
+ * }).use(requestContext({ logger }));
+ * ```
+ */
+export function requestContext<TLogger extends Logger = Logger>(
+	options: RequestContextOptions<TLogger>,
+): MiddlewareObj<unknown, unknown, Error, Context> {
+	const baseLogger = options.logger;
+	return {
+		before: (request) => {
+			const { event, context } = request;
+			const requestId = deriveRequestId(options, event, context);
+			const logger = buildLogger(
+				baseLogger,
+				options,
+				requestId,
+				event,
+				context,
+			);
+			enterRequestContext({ logger, requestId, startTime: Date.now() });
+		},
+		after: () => {
+			exitRequestContext();
+		},
+		onError: () => {
+			exitRequestContext();
+		},
+	};
+}
+
+function resolveDiscovery(options: ServiceResolverOptions): ServiceDiscovery {
+	return (
+		options.serviceDiscovery ?? ServiceDiscovery.getInstance(options.envParser)
+	);
+}
+
+/**
+ * Event augmentation applied by {@link addServices} / {@link withServices}:
+ * resolved services keyed by `serviceName`. Intersect it with your own event
+ * type to type the handler, e.g. `(event: EventServices<T> & APIGatewayEvent)`.
+ */
+export type EventServices<T extends Service[]> = {
+	services: ServiceRecord<T>;
+};
+
+/**
+ * Middy middleware that resolves an array of {@link Service}s via
+ * {@link ServiceDiscovery} and attaches the resolved record to `event.services`
+ * (keyed by each service's `serviceName`), matching how the `Function`/`Cron`
+ * constructs expose services on the event.
+ *
+ * This middleware only resolves services; it does **not** establish a request
+ * context. If your services read `serviceContext` (e.g. `getLogger()`), pair it
+ * with {@link requestContext}, or use {@link withServices} which bundles both.
+ *
+ * Chainable — `.use(addServices([a])).use(addServices([b]))` accumulates onto
+ * `event.services`.
+ *
+ * @example
+ * ```ts
+ * import middy from '@middy/core';
+ * import { addServices, requestContext } from '@geekmidas/services/middy';
+ *
+ * export const handler = middy(async (event) => {
+ *   await event.services.database.users.deletePast();
+ *   event.services.cache.clear();
+ * })
+ *   .use(requestContext())
+ *   .use(addServices([databaseService, cacheService], { envParser }));
+ * ```
+ */
+export function addServices<const T extends Service[]>(
+	services: [...T],
+	options: ServiceResolverOptions,
+): MiddlewareObj<EventServices<T>, unknown, Error, Context> {
+	const discovery = resolveDiscovery(options);
+
+	return {
+		before: async (request) => {
+			const resolved = await discovery.register(services);
+			const event = request.event as { services?: Record<string, unknown> };
+			// Merge so chained addServices(...) calls accumulate on event.services.
+			event.services = { ...(event.services ?? {}), ...resolved };
+		},
+	};
+}
+
+/**
+ * Batteries-included Middy setup for service-backed handlers: returns a pair of
+ * middlewares — {@link requestContext} followed by {@link addServices} — so a
+ * single `.use(withServices([...]))` gives the handler both a request context
+ * and the resolved services on `event.services`.
+ *
+ * @example
+ * ```ts
+ * import middy from '@middy/core';
+ * import { withServices } from '@geekmidas/services/middy';
+ *
+ * export const handler = middy(async (event) => {
+ *   await event.services.database.users.deletePast();
+ *   event.services.cache.clear();
+ * }).use(withServices([databaseService, cacheService], { envParser }));
+ * ```
+ */
+export function withServices<
+	const T extends Service[],
+	TLogger extends Logger = Logger,
+>(
+	services: [...T],
+	options: ServiceMiddlewareOptions<TLogger>,
+): [
+	MiddlewareObj<unknown, unknown, Error, Context>,
+	MiddlewareObj<EventServices<T>, unknown, Error, Context>,
+] {
+	return [requestContext(options), addServices(services, options)];
+}

package/src/trpc.ts

@@ -0,0 +1,190 @@
+import { randomUUID } from 'node:crypto';
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import type {
+	TRPCMiddlewareBuilder,
+	TRPCMiddlewareFunction,
+} from '@trpc/server';
+import { runWithRequestContext } from './context';
+import { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';
+import type { Service } from './types';
+
+/**
+ * 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/services/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 ?? 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 (`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 ?? randomUUID();
+		const startTime = ctx.startTime ?? Date.now();
+		return runWithRequestContext(
+			{ logger: ctx.logger, requestId, startTime },
+			() => opts.next(),
+		);
+	});
+}

package/tsdown.config.ts

@@ -1,3 +1,13 @@
 import { defineConfig } from 'tsdown';
 
-export default defineConfig({});
+export default defineConfig({
+	entry: ['src/index.ts', 'src/context.ts', 'src/trpc.ts', 'src/middy.ts'],
+	clean: true,
+	outDir: 'dist',
+	format: ['cjs', 'esm'],
+	sourcemap: true,
+	dts: true,
+	outExtensions: (ctx) => ({
+		js: ctx.format === 'es' ? '.mjs' : '.cjs',
+	}),
+});

package/dist/ServiceDiscovery.cjs

@@ -1,4 +0,0 @@
-require('./context-CkCPt2Fe.cjs');
-const require_ServiceDiscovery = require('./ServiceDiscovery-Cxus7ber.cjs');
-
-exports.ServiceDiscovery = require_ServiceDiscovery.ServiceDiscovery;

package/dist/ServiceDiscovery.d.cts

@@ -1,3 +0,0 @@
-import "./types-BY9yrY6Y.cjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-DF4OKEZp.cjs";
-export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };

package/dist/ServiceDiscovery.d.mts

@@ -1,3 +0,0 @@
-import "./types-B99KrvXR.mjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-CadEgTKz.mjs";
-export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };

package/dist/ServiceDiscovery.mjs

@@ -1,4 +0,0 @@
-import "./context-BojeLlxs.mjs";
-import { ServiceDiscovery } from "./ServiceDiscovery-SujDuYHr.mjs";
-
-export { ServiceDiscovery };