autotel-adapters 0.3.11 → 0.3.13

package/src/nitro.ts

@@ -1,121 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import {
-  getRequestLogger,
-  trace,
-  type RequestLogger,
-  type RequestLoggerOptions,
-} from 'autotel';
-import { createAdapterToolkit, createUseLogger } from './core';
-
-export interface NitroEventLike {
-  method?: string;
-  path?: string;
-  context?: Record<string, unknown>;
-}
-
-export interface NitroWithAutotelOptions {
-  spanName?: string | ((event: NitroEventLike) => string);
-  requestLoggerOptions?: RequestLoggerOptions;
-  enrich?: (event: NitroEventLike) => Record<string, unknown> | undefined;
-  /** Emit one wide event automatically when the handler settles. Default `true`. */
-  autoEmit?: boolean;
-}
-
-function enrichFromEvent(
-  event?: NitroEventLike,
-): Record<string, unknown> | undefined {
-  if (!event) return undefined;
-
-  return {
-    ...(event.method ? { 'http.request.method': event.method } : {}),
-    ...(event.path ? { 'http.route': event.path } : {}),
-    ...(typeof event.context?.requestId === 'string'
-      ? { 'http.request.id': event.context.requestId }
-      : {}),
-  };
-}
-
-const baseUseLogger = createUseLogger<NitroEventLike>({
-  adapterName: 'nitro',
-  enrich: enrichFromEvent,
-});
-const nitroLoggerStorage = new AsyncLocalStorage<RequestLogger>();
-
-export function useLogger(
-  event?: NitroEventLike,
-  serviceOrOptions?: string | RequestLoggerOptions,
-): RequestLogger {
-  const stored = nitroLoggerStorage.getStore();
-  const logger = stored ??
-    (
-    typeof serviceOrOptions === 'string'
-      ? baseUseLogger(event)
-      : baseUseLogger(event, serviceOrOptions)
-    );
-
-  if (typeof serviceOrOptions === 'string' && serviceOrOptions.length > 0) {
-    logger.set({ service: serviceOrOptions });
-  }
-
-  return logger;
-}
-
-export function withAutotelEventHandler<TEvent extends NitroEventLike, TReturn>(
-  handler: (event: TEvent) => TReturn | Promise<TReturn>,
-  options?: NitroWithAutotelOptions,
-): (event: TEvent) => Promise<TReturn> {
-  return async (event: TEvent): Promise<TReturn> => {
-    const spanName =
-      typeof options?.spanName === 'function'
-        ? options.spanName(event)
-        : (options?.spanName ?? `nitro.${event.method ?? 'request'}`);
-
-    const wrapped = trace({ name: spanName }, (ctx) => async (innerEvent: TEvent) => {
-      const log = getRequestLogger(ctx, options?.requestLoggerOptions);
-      const auto = enrichFromEvent(innerEvent);
-      if (auto && Object.keys(auto).length > 0) {
-        log.set(auto);
-      }
-      const custom = options?.enrich?.(innerEvent);
-      if (custom && Object.keys(custom).length > 0) {
-        log.set(custom);
-      }
-      try {
-        return await nitroLoggerStorage.run(log, async () =>
-          handler(innerEvent),
-        );
-      } finally {
-        if (options?.autoEmit !== false) {
-          log.emitNow();
-        }
-      }
-    });
-
-    return await wrapped(event);
-  };
-}
-
-export function createNitroAdapter(options?: NitroWithAutotelOptions) {
-  const toolkit = createAdapterToolkit<NitroEventLike>({
-    adapterName: 'nitro',
-    enrich: (event) => ({
-      ...enrichFromEvent(event),
-      ...(options?.enrich?.(event) ?? {}),
-    }),
-  });
-
-  return {
-    withAutotelEventHandler: <TEvent extends NitroEventLike, TReturn>(
-      handler: (event: TEvent) => TReturn | Promise<TReturn>,
-    ) => withAutotelEventHandler(handler, options),
-    useLogger,
-    parseError: toolkit.parseError,
-    createStructuredError: toolkit.createStructuredError,
-    createDrainPipeline: toolkit.createDrainPipeline,
-  };
-}
-
-export const nitroToolkit = createAdapterToolkit<NitroEventLike>({
-  adapterName: 'nitro',
-  enrich: enrichFromEvent,
-});

package/src/resolve-adapter-config.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import {
-  resolveAdapterConfig,
-  shouldProbeRuntime,
-  type ConfigField,
-} from './core';
-
-interface AdapterConfig {
-  token?: string;
-  endpoint?: string;
-  timeout?: number;
-}
-
-const FIELDS: ConfigField<AdapterConfig>[] = [
-  { key: 'token', env: ['MY_ADAPTER_TOKEN'] },
-  { key: 'endpoint', env: ['MY_ADAPTER_ENDPOINT'] },
-  { key: 'timeout' }, // optional tuning field, no env fallback
-];
-
-describe('shouldProbeRuntime', () => {
-  beforeEach(() => {
-    delete process.env.MY_ADAPTER_TOKEN;
-    delete process.env.MY_ADAPTER_ENDPOINT;
-  });
-
-  it('returns false when overrides cover every env-backed field', () => {
-    expect(
-      shouldProbeRuntime(FIELDS, { token: 't', endpoint: 'u' }),
-    ).toBe(false);
-  });
-
-  it('returns false when env covers every env-backed field', () => {
-    process.env.MY_ADAPTER_TOKEN = 't';
-    process.env.MY_ADAPTER_ENDPOINT = 'u';
-    expect(shouldProbeRuntime(FIELDS)).toBe(true);
-  });
-
-  it('returns true when an env-backed field is still missing', () => {
-    process.env.MY_ADAPTER_TOKEN = 't';
-    expect(shouldProbeRuntime(FIELDS)).toBe(true);
-  });
-
-  it('ignores fields with no env list (optional tuning fields)', () => {
-    process.env.MY_ADAPTER_TOKEN = 't';
-    process.env.MY_ADAPTER_ENDPOINT = 'u';
-    // `timeout` is still a runtime-resolvable field, so probing may still apply.
-    expect(shouldProbeRuntime(FIELDS)).toBe(true);
-  });
-});
-
-describe('resolveAdapterConfig', () => {
-  beforeEach(() => {
-    delete process.env.MY_ADAPTER_TOKEN;
-    delete process.env.MY_ADAPTER_ENDPOINT;
-  });
-  afterEach(() => vi.restoreAllMocks());
-
-  it('calls the probe when overrides do not fully resolve config', async () => {
-    process.env.MY_ADAPTER_TOKEN = 't';
-    process.env.MY_ADAPTER_ENDPOINT = 'u';
-
-    const probe = vi.fn().mockResolvedValue(undefined);
-    const cfg = await resolveAdapterConfig('my-adapter', FIELDS, undefined, probe);
-
-    expect(probe).toHaveBeenCalledOnce();
-    expect(cfg.token).toBe('t');
-    expect(cfg.endpoint).toBe('u');
-  });
-
-  it('calls the probe and merges runtimeConfig.autotel.<namespace>.<key>', async () => {
-    const probe = vi.fn().mockResolvedValue({
-      autotel: { 'my-adapter': { token: 'from-runtime', endpoint: 'rt-url' } },
-    });
-    const cfg = await resolveAdapterConfig('my-adapter', FIELDS, undefined, probe);
-
-    expect(probe).toHaveBeenCalledOnce();
-    expect(cfg.token).toBe('from-runtime');
-    expect(cfg.endpoint).toBe('rt-url');
-  });
-
-  it('overrides win over runtime and env', async () => {
-    process.env.MY_ADAPTER_TOKEN = 'env-token';
-    const probe = vi.fn().mockResolvedValue({
-      autotel: { 'my-adapter': { token: 'rt-token', endpoint: 'rt-url' } },
-    });
-
-    const cfg = await resolveAdapterConfig(
-      'my-adapter',
-      FIELDS,
-      { token: 'override' },
-      probe,
-    );
-
-    expect(cfg.token).toBe('override');
-    expect(cfg.endpoint).toBe('rt-url');
-  });
-
-  it('runtime config wins over env when both are present', async () => {
-    process.env.MY_ADAPTER_TOKEN = 'env-token';
-    process.env.MY_ADAPTER_ENDPOINT = 'env-url';
-
-    const probe = vi.fn().mockResolvedValue({
-      autotel: { 'my-adapter': { token: 'rt-token', endpoint: 'rt-url' } },
-    });
-    const cfg = await resolveAdapterConfig('my-adapter', FIELDS, undefined, probe);
-
-    expect(cfg.token).toBe('rt-token');
-    expect(cfg.endpoint).toBe('rt-url');
-  });
-});

package/src/tanstack.ts

@@ -1,23 +0,0 @@
-import { createUseLogger, createAdapterToolkit } from './core';
-
-export const useLogger = createUseLogger<{
-  pathname?: string;
-  method?: string;
-}>({
-  adapterName: 'tanstack',
-  enrich: (ctx) => ({
-    ...(ctx.method ? { 'http.request.method': ctx.method } : {}),
-    ...(ctx.pathname ? { 'http.route': ctx.pathname } : {}),
-  }),
-});
-
-export const tanstackToolkit = createAdapterToolkit<{
-  pathname?: string;
-  method?: string;
-}>({
-  adapterName: 'tanstack',
-  enrich: (ctx) => ({
-    ...(ctx.method ? { 'http.request.method': ctx.method } : {}),
-    ...(ctx.pathname ? { 'http.route': ctx.pathname } : {}),
-  }),
-});