@gobing-ai/ts-infra 0.3.4 → 0.3.6

package/src/application-node.ts

@@ -0,0 +1,311 @@
+/**
+ * Node/Bun convenience bootstrap for `@gobing-ai/ts-infra`.
+ *
+ * Composes the portable `runApplication` with runtime-specific wiring:
+ * - YAML config loading via `@gobing-ai/ts-runtime`
+ * - Application-specific config validation with caller-provided validator
+ * - File log sink via `node:fs`
+ * - Bun SQLite DB adapter creation from config
+ * - Optional Node OTel exporter initialization
+ * - Optional Node scheduler adapter
+ *
+ * This subpath may import runtime-specific adapters. The portable bootstrap
+ * subpath (`@gobing-ai/ts-infra/application`) must not.
+ *
+ * @module application-node
+ */
+
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+import { createDbAdapter, type DbAdapter } from '@gobing-ai/ts-db';
+import { interpolateTree, parseYamlObject } from '@gobing-ai/ts-runtime';
+
+import { runApplication } from './application/index';
+import { dbPlugin } from './application/plugins/builtins';
+import type { Plugin } from './application/plugins/types';
+import type {
+    ApplicationBootstrapOptions,
+    ApplicationConfigLoader,
+    ApplicationConfigValidator,
+    ApplicationRuntime,
+    ApplicationStopReason,
+    ConfigValidationResult,
+    DbAdapterLike,
+    EventMap,
+    InfraEvents,
+    LoggingOptions,
+    SchedulerOptions,
+    TelemetryOptions,
+} from './application/types';
+import { NodeSchedulerAdapter } from './scheduler-node';
+import { initNodeTelemetry, shutdownNodeTelemetry } from './telemetry/otel-node';
+
+// ── Errors ────────────────────────────────────────────────────────────────
+
+/** Error thrown when application config validation fails. Includes file path and section name. */
+export class ConfigValidationError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'ConfigValidationError';
+    }
+}
+
+// ── Config validation helper ──────────────────────────────────────────────
+
+/**
+ * Validate a raw config section using the caller-provided validator.
+ * Supports structural `safeParse`, `validate()`, `parse()`, and bare function forms.
+ */
+function validateAppConfig<TAppConfig>(
+    validator: ApplicationConfigValidator<TAppConfig>,
+    raw: unknown,
+    section: string,
+    filePath: string | undefined,
+): TAppConfig {
+    if (typeof validator === 'object' && 'safeParse' in validator) {
+        const result: ConfigValidationResult<TAppConfig> = validator.safeParse(raw);
+        if (!result.success) {
+            const details = result.errors?.map((e) => `${e.path}: ${e.message}`).join('; ') ?? 'unknown error';
+            throw new ConfigValidationError(
+                `Application config validation failed in section "${section}"` +
+                    (filePath ? ` (file: ${filePath})` : '') +
+                    `: ${details}`,
+            );
+        }
+        return result.data as TAppConfig;
+    }
+
+    if (typeof validator === 'function') {
+        return (validator as (raw: unknown) => TAppConfig)(raw);
+    }
+
+    if (typeof validator === 'object' && 'validate' in validator) {
+        return validator.validate(raw);
+    }
+
+    if (typeof validator === 'object' && 'parse' in validator) {
+        return validator.parse(raw);
+    }
+
+    throw new ConfigValidationError(`Unsupported validator shape for section "${section}"`);
+}
+
+// ── File sink helper ──────────────────────────────────────────────────────
+
+function createFileSink(filePath: string): (line: string) => void {
+    return (line: string) => {
+        try {
+            mkdirSync(dirname(filePath), { recursive: true });
+            appendFileSync(filePath, line);
+        } catch {
+            // Best-effort — don't crash on log write failure
+        }
+    };
+}
+
+// ── Config loading ────────────────────────────────────────────────────────
+
+interface LoadedConfig<TAppConfig> {
+    bootstrapConfig: Record<string, unknown>;
+    appConfig: TAppConfig | undefined;
+}
+
+function loadYamlConfig<TAppConfig>(
+    loader: ApplicationConfigLoader<TAppConfig>,
+    fileContent: string | undefined,
+): LoadedConfig<TAppConfig> {
+    const bootstrapSection = loader.bootstrapSection ?? 'bootstrap';
+
+    let raw: Record<string, unknown>;
+    if (fileContent !== undefined) {
+        raw = parseYamlObject(fileContent);
+    } else if (loader.overrides) {
+        raw = { ...loader.overrides };
+    } else {
+        raw = {};
+    }
+
+    // Interpolate environment variables (Node/Bun only)
+    raw = interpolateTree(raw) as Record<string, unknown>;
+
+    // Extract bootstrap section
+    const bootstrapSection_ = raw[bootstrapSection];
+    const bootstrapConfig: Record<string, unknown> =
+        typeof bootstrapSection_ === 'object' && bootstrapSection_ !== null
+            ? (bootstrapSection_ as Record<string, unknown>)
+            : {};
+
+    // Extract app config section
+    let appConfig: TAppConfig | undefined;
+    if (loader.appConfig) {
+        const appSection = loader.appSection;
+        const appRaw = appSection
+            ? raw[appSection]
+            : (() => {
+                  // Default: full remaining object minus bootstrap section
+                  const remaining: Record<string, unknown> = {};
+                  for (const [key, value] of Object.entries(raw)) {
+                      if (key !== bootstrapSection) {
+                          remaining[key] = value;
+                      }
+                  }
+                  return remaining;
+              })();
+
+        appConfig = validateAppConfig(loader.appConfig, appRaw, appSection ?? '*', loader.configFile);
+    }
+
+    return { bootstrapConfig, appConfig };
+}
+
+// ── Node/Bun options ──────────────────────────────────────────────────────
+
+/** Options for the Node/Bun convenience {@link runNodeApplication}. */
+export interface NodeApplicationOptions<TAppConfig = unknown, TEvents extends EventMap = InfraEvents> {
+    /** YAML config loading options. When omitted, uses defaults. */
+    readonly configLoader?: ApplicationConfigLoader<TAppConfig>;
+    /** Inline bootstrap config (overrides YAML-loaded config). */
+    readonly config?: ApplicationBootstrapOptions<TAppConfig, TEvents>['config'];
+    /** Pre-built services to inject. */
+    readonly services?: ApplicationBootstrapOptions<TAppConfig, TEvents>['services'];
+    /** User callback: application logic. */
+    readonly start: (app: ApplicationRuntime<TAppConfig, TEvents>) => Promise<void> | void;
+    /** User callback: cleanup before services shut down. */
+    readonly stop?: (
+        app: ApplicationRuntime<TAppConfig, TEvents>,
+        reason: ApplicationStopReason,
+    ) => Promise<void> | void;
+}
+
+// ── Public API ────────────────────────────────────────────────────────────
+
+/**
+ * Node/Bun convenience application bootstrap.
+ *
+ * Extends the portable `runApplication` with:
+ * - YAML config file loading with section splitting
+ * - Application-specific config validation
+ * - File log sink creation from `logging.filePath`
+ * - Bun SQLite DB adapter creation when `database.enabled` + `database.driver`
+ * - Optional Node OTel telemetry exporter
+ * - Optional Node scheduler adapter
+ *
+ * @example
+ * ```ts
+ * import { runNodeApplication } from '@gobing-ai/ts-infra/application-node';
+ *
+ * await runNodeApplication({
+ *     configLoader: {
+ *         configFile: 'config/app.yaml',
+ *         bootstrapSection: 'bootstrap',
+ *         appSection: 'billing',
+ *         appConfig: {
+ *             safeParse(raw) {
+ *                 return billingSchema.safeParse(raw);
+ *             },
+ *         },
+ *     },
+ *     async start(app) {
+ *         app.logger.info('started');
+ *     },
+ * });
+ * ```
+ */
+export async function runNodeApplication<TAppConfig = unknown, TEvents extends EventMap = InfraEvents>(
+    options: NodeApplicationOptions<TAppConfig, TEvents>,
+): Promise<ApplicationRuntime<TAppConfig, TEvents>> {
+    // ── Load config ─────────────────────────────────────────────────────
+    let loadedAppConfig: TAppConfig | undefined;
+    let yamlBootstrap: Record<string, unknown> = {};
+
+    if (options.configLoader?.configFile) {
+        const fileContent = readFileSync(options.configLoader.configFile, 'utf-8');
+        const loaded = loadYamlConfig(options.configLoader, fileContent);
+        yamlBootstrap = loaded.bootstrapConfig;
+        loadedAppConfig = loaded.appConfig;
+    } else if (options.configLoader) {
+        const loaded = loadYamlConfig(options.configLoader, undefined);
+        yamlBootstrap = loaded.bootstrapConfig;
+        loadedAppConfig = loaded.appConfig;
+    }
+
+    // ── Resolve bootstrap config from YAML + inline options ────────────
+    const yamlLog = yamlBootstrap.logging as Partial<LoggingOptions> | undefined;
+    const yamlTel = yamlBootstrap.telemetry as Partial<TelemetryOptions> | undefined;
+    const yamlSched = yamlBootstrap.scheduler as Partial<SchedulerOptions> | undefined;
+    const databaseOpts = (yamlBootstrap.database ?? {}) as Record<string, unknown>;
+
+    const loggingOpts: Partial<LoggingOptions> = { ...yamlLog, ...options.config?.logging };
+    const telemetryOpts: Partial<TelemetryOptions> = { ...yamlTel, ...options.config?.telemetry };
+    const schedulerOpts: Partial<SchedulerOptions> = { ...yamlSched, ...options.config?.scheduler };
+
+    const logFilePath = (yamlBootstrap.logging as Record<string, unknown> | undefined)?.filePath as string | undefined;
+    const loggingConfig: Partial<LoggingOptions> =
+        typeof logFilePath === 'string' ? { ...loggingOpts, fileSink: createFileSink(logFilePath) } : loggingOpts;
+
+    // ── Scheduler adapter ───────────────────────────────────────────────
+    const schedulerConfig: SchedulerOptions = {};
+    const rawSched = { ...schedulerOpts } as Record<string, unknown>;
+    if (rawSched.enabled === true) {
+        schedulerConfig.enabled = true;
+        schedulerConfig.autoStart = schedulerOpts.autoStart;
+        schedulerConfig.adapter = new NodeSchedulerAdapter();
+    }
+
+    // ── Node-owned plugins ──────────────────────────────────────────────
+    const plugins: Plugin[] = [];
+    let dbAdapter: DbAdapterLike | undefined = options.services?.db;
+    const rawTel = { ...telemetryOpts } as Record<string, unknown>;
+
+    // Node OTel telemetry as a failFast plugin
+    if (rawTel.enabled !== false && rawTel.endpoint) {
+        plugins.push({
+            name: 'builtin:node-telemetry',
+            version: '0.0.0',
+            failFast: true,
+            onLoad: async () => {},
+            onStart: async () => {
+                initNodeTelemetry({
+                    serviceName: (rawTel.serviceName as string | undefined) ?? 'ts-libs',
+                    endpoint: rawTel.endpoint as string,
+                    headers: rawTel.headers as Record<string, string> | undefined,
+                });
+            },
+            onStop: async () => {
+                await shutdownNodeTelemetry();
+            },
+        });
+    }
+
+    // DB adapter (owned — registered as a plugin with fail-soft close)
+    if (!dbAdapter && databaseOpts.enabled === true) {
+        const driver = databaseOpts.driver as string | undefined;
+        if (driver === 'bun-sqlite') {
+            const adapter = await createDbAdapter({
+                driver: 'bun-sqlite',
+                url: databaseOpts.url as string | undefined,
+            });
+            dbAdapter = adapter as DbAdapter;
+            plugins.push(dbPlugin(dbAdapter));
+        } else {
+            throw new ConfigValidationError(
+                `database.enabled is true but driver ${driver ? `"${driver}"` : 'is missing'} is not supported ` +
+                    `(expected "bun-sqlite"). Provide a supported driver or inject a DbAdapter via services.db.`,
+            );
+        }
+    }
+
+    // ── Delegate to portable runApplication ─────────────────────────────
+    // Node-specific cleanup is handled by plugins in the service ring —
+    // node-telemetry onStop, owned-db onStop. No manual try/catch or stop
+    // override needed.
+    return await runApplication<TAppConfig, TEvents>({
+        config: { ...options.config, logging: loggingConfig, telemetry: telemetryOpts, scheduler: schedulerConfig },
+        appConfig: loadedAppConfig,
+        services: { ...options.services, ...(dbAdapter ? { db: dbAdapter } : {}) },
+        start: options.start,
+        stop: options.stop,
+        plugins: plugins.length ? plugins : undefined,
+    });
+}

package/src/index.ts

@@ -52,7 +52,6 @@ export {
     ActionRegistry,
     type CreateDefaultRegistryOptions,
     createDefaultRegistry,
-    getSchedulerAdapter,
     HealthPingAction,
     type HealthPingWriter,
     initScheduler,
@@ -63,7 +62,6 @@ export {
     type ScheduledAction,
     type SchedulerAction,
     type SchedulerAdapter,
-    setSchedulerAdapter,
     toScheduledAction,
     wrapScheduledHandler,
 } from './scheduler/index';

package/src/scheduler/cloudflare.ts

@@ -2,7 +2,11 @@
  * Cloudflare Workers scheduler adapter using Cron Triggers.
  * Uses minimal local type declarations — no @cloudflare/workers-types dependency.
  */
-import { getSchedulerJobExecutedTotal, getSchedulerJobFailedTotal } from '../telemetry/metrics';
+import {
+    getSchedulerJobDuration,
+    getSchedulerJobExecutedTotal,
+    getSchedulerJobFailedTotal,
+} from '../telemetry/metrics';
 import type { ScheduledAction, SchedulerAdapter } from './types';
 
 interface CfScheduledEvent {
@@ -46,12 +50,19 @@ export class CloudflareSchedulerAdapter implements SchedulerAdapter {
     handleScheduledEvent(event: CfScheduledEvent, ctx: CfEventContext): void {
         const action = this.entries.get(event.cron);
         if (action) {
+            const startMs = performance.now();
             getSchedulerJobExecutedTotal().add(1, { cron: event.cron });
             ctx.waitUntil(
-                action().catch((error: unknown) => {
-                    getSchedulerJobFailedTotal().add(1, { cron: event.cron });
-                    throw error;
-                }),
+                action()
+                    .catch((error: unknown) => {
+                        getSchedulerJobFailedTotal().add(1, { cron: event.cron });
+                        throw error;
+                    })
+                    .finally(() => {
+                        // Duration parity with NodeSchedulerAdapter — record the job
+                        // duration metric keyed by cron for both runtimes.
+                        getSchedulerJobDuration().record(performance.now() - startMs, { cron: event.cron });
+                    }),
             );
         }
     }

package/src/scheduler/factory.ts

@@ -1,26 +1,13 @@
 /**
- * Scheduler factory — selects adapter based on runtime.
+ * Scheduler factory — initializes an adapter and registers cron entries.
+ *
+ * The adapter is passed in explicitly (dependency injection); there is no
+ * process-global adapter state. Callers that don't supply one get a
+ * {@link NoopSchedulerAdapter}.
  */
 import { NoopSchedulerAdapter } from './noop';
 import type { ScheduledAction, SchedulerAdapter } from './types';
 
-let runtimeAdapter: SchedulerAdapter | undefined;
-
-/** Set the runtime scheduler adapter. Call before {@link initScheduler}. */
-export function setSchedulerAdapter(adapter: SchedulerAdapter): void {
-    runtimeAdapter = adapter;
-}
-
-/** Reset the scheduler adapter singleton. For testing. */
-export function resetSchedulerAdapter(): void {
-    runtimeAdapter = undefined;
-}
-
-/** Get the currently configured scheduler adapter, or `undefined` if not set. */
-export function getSchedulerAdapter(): SchedulerAdapter | undefined {
-    return runtimeAdapter;
-}
-
 /**
  * Initialize the scheduler adapter and register cron entries.
  *
@@ -28,19 +15,21 @@ export function getSchedulerAdapter(): SchedulerAdapter | undefined {
  * running, newly registered entries will NOT be started until the next
  * `start()` call.
  *
- * Returns the configured adapter (defaults to noop if none set).
+ * @param adapter - Adapter to use. Defaults to a {@link NoopSchedulerAdapter}.
+ * @param cronEntries - `[cron, action]` pairs to register on the adapter.
+ * @returns The configured adapter.
  */
-export function initScheduler(cronEntries?: Array<[string, ScheduledAction]>): SchedulerAdapter {
-    // Default: create a noop adapter. Apps inject their own via setSchedulerAdapter.
-    if (!runtimeAdapter) {
-        runtimeAdapter = new NoopSchedulerAdapter();
-    }
+export function initScheduler(
+    adapter?: SchedulerAdapter,
+    cronEntries?: Array<[string, ScheduledAction]>,
+): SchedulerAdapter {
+    const resolved = adapter ?? new NoopSchedulerAdapter();
 
     if (cronEntries) {
         for (const [cron, action] of cronEntries) {
-            runtimeAdapter.register(cron, action);
+            resolved.register(cron, action);
         }
     }
 
-    return runtimeAdapter;
+    return resolved;
 }

package/src/scheduler/index.ts

@@ -10,7 +10,7 @@ export {
     type SchedulerAction,
     toScheduledAction,
 } from './action';
-export { getSchedulerAdapter, initScheduler, resetSchedulerAdapter, setSchedulerAdapter } from './factory';
+export { initScheduler } from './factory';
 export { NoopSchedulerAdapter } from './noop';
 export type { ScheduledAction, SchedulerAdapter } from './types';
 export { wrapScheduledHandler } from './wrap-handler';

package/src/scheduler/wrap-handler.ts

@@ -7,10 +7,14 @@ import type { ScheduledAction } from './types';
  * Wrap a scheduled action with OTel tracing, duration measurement, and
  * `scheduler.job.executed` event emission.
  *
- * Composes *on top of* the adapter's inline metrics (executed/failed/duration
- * counters live in the Node/Cloudflare adapters) — this wrapper adds the named
- * tracing span and the lifecycle event, neither of which the adapters provide.
- * Opt-in: wrap an action before registering it when you want that visibility.
+ * Observability is split by design across two axes, not duplicated:
+ * - The adapters (`NodeSchedulerAdapter`, `CloudflareSchedulerAdapter`) record
+ *   executed/failed/duration **metrics keyed by `cron`** for aggregate dashboards.
+ * - This opt-in wrapper adds a named **tracing span + lifecycle event keyed by
+ *   the human `name`**, for per-job diagnosis. Its timer measures the inner action
+ *   scope; the adapter's measures the full tick — nested, not double-counted.
+ *
+ * Wrap an action before registering it when you want the named span/event.
  *
  * @param name - Job name, surfaced as `scheduler.job_name` on the span/event.
  * @param action - The action to wrap (new no-arg `ScheduledAction` signature).

package/src/telemetry/index.ts

@@ -1,4 +1,3 @@
-export { getTelemetryConfig, type TelemetryConfig, type TelemetryConfigPartial } from './config';
 export { extractSqlOperation, sanitizeSql } from './db-sanitize';
 export {
     type Counter,
@@ -18,6 +17,14 @@ export {
     initMetrics,
     shutdownMetrics,
 } from './metrics';
-export { getTracer, initTelemetry, isTelemetryEnabled, shutdownTelemetry } from './sdk';
+export {
+    getTelemetryConfig,
+    getTracer,
+    initTelemetry,
+    isTelemetryEnabled,
+    shutdownTelemetry,
+    type TelemetryConfig,
+    type TelemetryConfigPartial,
+} from './sdk';
 export type { Span, SpanOptions, Tracer } from './tracing';
 export { addSpanAttributes, addSpanEvent, getActiveSpan, traceAsync, traceSync, withSpan } from './tracing';

package/src/telemetry/metrics.ts

@@ -109,9 +109,30 @@ export function getSchedulerJobFailedTotal(): Counter {
 
 // ── Lifecycle ───────────────────────────────────────────────────────
 
-/** Mark the metrics subsystem as initialized. Idempotent. */
+/**
+ * Pre-warm every instrument against the currently-registered meter and mark the
+ * subsystem initialized. Idempotent.
+ *
+ * Instruments are otherwise created lazily on first getter call (so metrics keep
+ * working even if this is never called — see the module contract). Calling this
+ * during bootstrap eagerly materializes them, so `isMetricsInitialized()` reflects
+ * real wiring rather than being a flag that gates nothing.
+ */
 export function initMetrics(): void {
     if (metricsInitialized) return;
+    // Eagerly materialize all instruments against the live meter.
+    getHttpClientRequestTotal();
+    getHttpClientRequestDuration();
+    getHttpClientRequestErrors();
+    getEventbusEmitsTotal();
+    getEventbusErrorsTotal();
+    getQueueJobEnqueuedTotal();
+    getQueueJobCompletedTotal();
+    getQueueJobFailedTotal();
+    getQueueJobProcessingDuration();
+    getSchedulerJobExecutedTotal();
+    getSchedulerJobDuration();
+    getSchedulerJobFailedTotal();
     metricsInitialized = true;
 }
 

package/src/telemetry/sdk.ts

@@ -8,8 +8,57 @@
  * keeps the main barrel free of any SDK runtime dependency.
  */
 import { type Tracer, trace } from '@opentelemetry/api';
-import type { TelemetryConfig } from './config';
-import { getTelemetryConfig } from './config';
+
+// ── Configuration ───────────────────────────────────────────────────────────
+
+/**
+ * Full telemetry configuration: master enable switch, service name,
+ * environment, and debug-level DB statement capture.
+ */
+export interface TelemetryConfig {
+    /** Master switch — when false, all tracing degrades to no-ops. */
+    enabled: boolean;
+    /** Logical service name emitted on every span. */
+    serviceName: string;
+    /** Deployment environment (development, staging, production). */
+    environment: string;
+    /**
+     * Debug-only DB statement capture.
+     *
+     * When true, DB spans may include sanitized SQL text in a `db.statement`
+     * attribute. SQL text is redacted — parameter values, literals, and
+     * identifiers are stripped before capture.
+     *
+     * Default: `false`. Controlled by `OTEL_DB_STATEMENT_DEBUG` env var.
+     */
+    dbStatementDebug: boolean;
+}
+
+/** Partial telemetry config from the centralized config system. */
+export interface TelemetryConfigPartial {
+    enabled?: boolean | undefined;
+    serviceName?: string | undefined;
+    environment?: string | undefined;
+    dbStatementDebug?: boolean | undefined;
+    /** Deployment environment fallback (from app.env). */
+    appEnv?: string | undefined;
+}
+
+const CONFIG_DEFAULTS = {
+    enabled: true as const,
+    serviceName: 'ts-libs' as const,
+    environment: 'development' as const,
+};
+
+/** Resolve the full telemetry config by merging a partial override with defaults. */
+export function getTelemetryConfig(configPartial: TelemetryConfigPartial = {}): TelemetryConfig {
+    return {
+        enabled: configPartial.enabled ?? CONFIG_DEFAULTS.enabled,
+        serviceName: configPartial.serviceName ?? CONFIG_DEFAULTS.serviceName,
+        environment: configPartial.environment ?? configPartial.appEnv ?? CONFIG_DEFAULTS.environment,
+        dbStatementDebug: configPartial.dbStatementDebug ?? false,
+    };
+}
 
 const TRACER_NAME = '@gobing-ai/ts-infra';
 const TRACER_VERSION = '0.1.0';

package/dist/telemetry/config.d.ts

@@ -1,41 +0,0 @@
-/**
- * Telemetry configuration interface.
- */
-/**
- * Full telemetry configuration: master enable switch, service name,
- * environment, and debug-level DB statement capture.
- */
-export interface TelemetryConfig {
-    /** Master switch — when false, all tracing degrades to no-ops. */
-    enabled: boolean;
-    /** Logical service name emitted on every span. */
-    serviceName: string;
-    /** Deployment environment (development, staging, production). */
-    environment: string;
-    /**
-     * Debug-only DB statement capture.
-     *
-     * When true, DB spans may include sanitized SQL text in a `db.statement`
-     * attribute. SQL text is redacted — parameter values, literals, and
-     * identifiers are stripped before capture.
-     *
-     * Default: `false`. Controlled by `OTEL_DB_STATEMENT_DEBUG` env var.
-     */
-    dbStatementDebug: boolean;
-}
-/**
- * Partial telemetry config from the centralized config system.
- */
-export interface TelemetryConfigPartial {
-    enabled?: boolean | undefined;
-    serviceName?: string | undefined;
-    environment?: string | undefined;
-    dbStatementDebug?: boolean | undefined;
-    /** Deployment environment fallback (from app.env). */
-    appEnv?: string | undefined;
-}
-/**
- * Resolve the full telemetry config by merging a partial override with defaults.
- */
-export declare function getTelemetryConfig(configPartial?: TelemetryConfigPartial): TelemetryConfig;
-//# sourceMappingURL=config.d.ts.map

package/dist/telemetry/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/telemetry/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC5B,kEAAkE;IAClE,OAAO,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;;;OAQG;IACH,gBAAgB,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACnC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAQD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,GAAE,sBAA2B,GAAG,eAAe,CAU9F"}

package/dist/telemetry/config.js

@@ -1,21 +0,0 @@
-/**
- * Telemetry configuration interface.
- */
-const DEFAULTS = {
-    enabled: true,
-    serviceName: 'ts-libs',
-    environment: 'development',
-};
-/**
- * Resolve the full telemetry config by merging a partial override with defaults.
- */
-export function getTelemetryConfig(configPartial = {}) {
-    const enabled = configPartial.enabled ?? DEFAULTS.enabled;
-    const serviceName = configPartial.serviceName ?? DEFAULTS.serviceName;
-    return {
-        enabled,
-        serviceName,
-        environment: configPartial.environment ?? configPartial.appEnv ?? DEFAULTS.environment,
-        dbStatementDebug: configPartial.dbStatementDebug ?? false,
-    };
-}