@kuckit/infrastructure 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -1,506 +1,29 @@
-import * as drizzle_orm_node_postgres0 from "drizzle-orm/node-postgres";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { Pool } from "pg";
-import { AwilixContainer } from "awilix";
-import { AppError, CacheStore, CacheStore as CacheStore$1, Clock, EventBus, EventHandler, EventName, EventPublisher, Logger, RateLimiterStore, RateLimiterStore as RateLimiterStore$1, TypedDomainEvent, User, UserRepository } from "@kuckit/domain";
-import { google } from "@ai-sdk/google";
-import { auth } from "@kuckit/auth";
-import { UserRepository as UserRepository$1 } from "@kuckit/domain/ports/user-repository";
-import { Logger as Logger$1 } from "@kuckit/domain/ports/logger";
-
-//#region src/db/drizzle/db.d.ts
-/**
- * Create database connection pool
- */
-declare const createDbPool: (connectionString: string) => Pool;
-/**
- * Create Drizzle instance from pool
- */
-declare const createDb: (pool: Pool) => drizzle_orm_node_postgres0.NodePgDatabase<Record<string, never>> & {
-  $client: Pool;
-};
-//#endregion
-//#region src/db/drizzle/repositories/user.drizzle.d.ts
-/**
- * Drizzle implementation of UserRepository
- */
-declare const makeDrizzleUserRepository: (db: NodePgDatabase) => UserRepository$1;
-//#endregion
-//#region src/db/transaction.d.ts
-/**
- * Run a function within a database transaction
- * Creates a child scope with transaction-bound repositories
- *
- * Usage:
- * ```typescript
- * const result = await runInTransaction(container, async (txScope) => {
- *   const { userRepository } = txScope.cradle
- *   await userRepository.save(user)
- *   return user
- * })
- * ```
- */
-declare const runInTransaction: <T>(container: AwilixContainer, fn: (txScope: AwilixContainer) => Promise<T>) => Promise<T>;
-type TransactionFn<T> = (txScope: AwilixContainer) => Promise<T>;
-//#endregion
-//#region ../domain/src/ports/logger.d.ts
-/**
- * Logger port - structured logging for Loki/Prometheus
- * Loki-compatible: labels and structured fields in meta
- */
-interface Logger$2 {
-  debug: (message: string, meta?: LogContext) => void;
-  info: (message: string, meta?: LogContext) => void;
-  warn: (message: string, meta?: LogContext) => void;
-  error: (message: string, meta?: LogContext | Error) => void;
-}
-/**
- * Structured log context (Loki labels)
- */
-interface LogContext {
-  requestId?: string;
-  userId?: string;
-  feature?: string;
-  [key: string]: any;
-}
-//#endregion
-//#region src/logging/structured-logger.d.ts
-type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
-/**
- * Structured logger implementation
- * - JSON logs compatible with Loki
- * - File + stdout support
- * - Prometheus metrics collection
- */
-declare class StructuredLogger implements Logger$2 {
-  private options;
-  private fileStream;
-  private metrics;
-  constructor(options?: {
-    logDir?: string;
-    enableFile?: boolean;
-    minLevel?: LogLevel;
-  });
-  private initFileStream;
-  debug(message: string, meta?: LogContext): void;
-  info(message: string, meta?: LogContext): void;
-  warn(message: string, meta?: LogContext): void;
-  error(message: string, meta?: LogContext | Error): void;
-  private log;
-  private shouldSkip;
-  private formatLog;
-  /**
-   * Get metrics in Prometheus text format
-   */
-  getMetrics(): string;
-  /**
-   * Cleanup resources
-   */
-  dispose(): Promise<void>;
-}
-/**
- * Create logger instance
- */
-declare const makeStructuredLogger: (options?: {
-  logDir?: string;
-  enableFile?: boolean;
-  minLevel?: LogLevel;
-}) => StructuredLogger;
-//#endregion
-//#region src/logging/request-logger.d.ts
-/**
- * Options for creating a request-scoped logger
- */
-interface RequestLoggerOptions {
-  requestId: string;
-  userId?: string;
-  baseLogger: Logger$1;
-}
-/**
- * Create a request-scoped logger that automatically includes
- * requestId and userId in all log entries.
- *
- * This wraps the base singleton logger and enriches all log
- * calls with request context for Loki-compatible structured logging.
- */
-declare const makeRequestLogger: (options: RequestLoggerOptions) => Logger$1;
-//#endregion
-//#region src/errors/error-handler.d.ts
-/**
- * Serialized error for API responses
- */
-interface SerializedError {
-  code: string;
-  message: string;
-  statusCode: number;
-  meta?: Record<string, any>;
-}
-/**
- * Error handler for structured error logging and serialization
- */
-declare class ErrorHandler {
-  private logger;
-  constructor(logger: Logger$2);
-  /**
-   * Handle error and serialize for API response
-   */
-  handle(error: unknown, context?: Record<string, any>): SerializedError;
-  /**
-   * Normalize any error to AppError
-   */
-  private normalize;
-  /**
-   * Log error with appropriate level
-   */
-  private log;
-  /**
-   * Serialize error for API response
-   */
-  private serialize;
-  /**
-   * Create error handler factory
-   */
-  static create(logger: Logger$2): ErrorHandler;
-}
-/**
- * Factory for error handler
- */
-declare const makeErrorHandler: (logger: Logger$2) => ErrorHandler;
-//#endregion
-//#region src/events/in-memory-event-bus.d.ts
-/**
- * In-memory event bus
- * Stores handlers in Sets, executes synchronously or asynchronously
- */
-declare class InMemoryEventBus implements EventBus {
-  private logger;
-  private handlers;
-  private allHandlers;
-  constructor(logger: Logger);
-  publish<TName extends EventName>(event: TypedDomainEvent<TName>): Promise<void>;
-  publishAsync<TName extends EventName>(event: TypedDomainEvent<TName>): void;
-  subscribe<TName extends EventName>(eventName: TName, handler: EventHandler<TName>): () => void;
-  subscribeAll(handler: EventHandler): () => void;
-}
-//#endregion
-//#region src/events/event-publisher-adapter.d.ts
-/**
- * Adapter that implements EventPublisher port using EventBus
- * Converts the simplified EventPublisher interface to full EventBus types
- */
-declare const makeEventPublisherAdapter: (eventBus: EventBus, logger: Logger) => EventPublisher;
-//#endregion
-//#region src/events/in-memory-event-publisher.d.ts
-/**
- * In-memory event publisher implementation
- * Suitable for development and testing
- */
-declare const makeInMemoryEventPublisher: () => EventPublisher;
-//#endregion
-//#region src/cache/in-memory-cache-store.d.ts
-/**
- * In-memory cache store implementation
- * Suitable for single-process applications or development
- * For distributed systems, use Redis adapter
- */
-declare class InMemoryCacheStore implements CacheStore$1 {
-  private cleanupIntervalMs;
-  private cache;
-  private cleanupTimer;
-  constructor(cleanupIntervalMs?: number);
-  get<T>(key: string): Promise<T | undefined>;
-  set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
-  del(key: string): Promise<void>;
-  clear(): Promise<void>;
-  has(key: string): Promise<boolean>;
-  /**
-   * Start background cleanup of expired entries
-   */
-  private startCleanup;
-  /**
-   * Stop cleanup timer
-   */
-  destroy(): void;
-}
-//#endregion
-//#region src/rate-limiter/in-memory-rate-limiter.d.ts
-/**
- * In-memory rate limiter using token bucket algorithm
- * Suitable for single-process applications or development
- * For distributed systems, use Redis adapter
- */
-declare class InMemoryRateLimiterStore implements RateLimiterStore$1 {
-  private cleanupIntervalMs;
-  private buckets;
-  private cleanupTimer;
-  constructor(cleanupIntervalMs?: number);
-  checkLimit(key: string, capacity: number, refillPerSecond: number): Promise<{
-    allowed: boolean;
-    tokensRemaining: number;
-    resetAt: Date;
-  }>;
-  reset(key: string): Promise<void>;
-  clear(): Promise<void>;
-  /**
-   * Start background cleanup of old buckets
-   * Removes buckets that haven't been used in a long time
-   */
-  private startCleanup;
-  /**
-   * Stop cleanup timer
-   */
-  destroy(): void;
-}
-//#endregion
-//#region src/decorators/use-case-decorator.d.ts
-/**
- * Use case decorator type
- * Wraps a use case function with cross-cutting concerns
- */
-type UseCase<T extends (...args: any[]) => Promise<any>> = T;
-/**
- * Decorator context passed to all decorators
- */
-interface DecoratorContext {
-  logger: Logger$2;
-  requestId?: string;
-  userId?: string;
-  feature?: string;
-}
-/**
- * Performance metrics collected by decorator
- */
-interface PerformanceMetrics {
-  startTime: number;
-  endTime: number;
-  durationMs: number;
-}
-/**
- * Base decorator that adds performance monitoring
- */
-declare const withPerformanceMonitoring: <T extends (...args: any[]) => Promise<any>>(useCase: T, context: DecoratorContext, featureName: string) => T;
-/**
- * Base decorator that adds error handling and conversion
- */
-declare const withErrorHandling: <T extends (...args: any[]) => Promise<any>>(useCase: T, context: DecoratorContext, featureName: string) => T;
-/**
- * Request tracing decorator - adds context to logs
- */
-declare const withRequestTracing: <T extends (...args: any[]) => Promise<any>>(useCase: T, context: DecoratorContext, featureName: string) => T;
-/**
- * Compose multiple decorators together
- * Order: Tracing → Performance → Error Handling
- * (outermost → innermost)
- */
-declare const decorateUseCase: <T extends (...args: any[]) => Promise<any>>(useCase: T, context: DecoratorContext, featureName: string) => T;
-/**
- * Factory for creating decorated use cases
- * Used in dependency injection to wrap use cases automatically
- */
-declare const makeDecoratedUseCase: <T extends (...args: any[]) => Promise<any>>(useCase: T, context: DecoratorContext, featureName: string) => T;
-//#endregion
-//#region src/decorators/apply-decorators.d.ts
-/**
- * Helper to apply decorators to use cases in module registration
- * Reduces boilerplate in feature modules
- *
- * Usage:
- * ```
- * getUserProfile: asFunction(({ userRepository, ...deps }) =>
- *   applyDecorators(
- *     makeGetUserProfile({ userRepository }),
- *     deps,
- *     'getUserProfile'
- *   )
- * ).scoped(),
- * ```
- */
-declare const applyDecorators: <T extends (...args: any[]) => Promise<any>>(useCase: T, deps: {
-  logger: any;
-  requestId?: string;
-}, featureName: string) => T;
-//#endregion
-//#region src/decorators/with-caching.d.ts
-/**
- * Options for caching decorator
- */
-interface WithCachingOptions {
-  /** Cache key function - maps input to cache key */
-  keyFn: (input: any) => string;
-  /** Time to live in milliseconds */
-  ttlMs: number;
-  /** Stale-while-revalidate: return stale value while refreshing in background */
-  staleWhileRevalidateMs?: number;
-}
-/**
- * Wraps a use case with caching
- * - Only works with idempotent read operations
- * - Key function determines cache key from input
- * - TTL controls cache expiration
- * - SWR allows returning stale value while revalidating
- *
- * @example
- * ```ts
- * const cachedGetUser = withCaching(
- *   getUserProfile,
- *   cacheStore,
- *   {
- *     keyFn: (input) => `user:${input.userId}`,
- *     ttlMs: 60000, // 1 minute
- *     staleWhileRevalidateMs: 120000, // 2 minutes
- *   }
- * )
- * ```
- */
-declare const withCaching: <I extends Record<string, any>, O>(fn: (input: I) => Promise<O>, cacheStore: CacheStore$1, options: WithCachingOptions) => ((input: I) => Promise<O>);
-//#endregion
-//#region src/decorators/with-retry.d.ts
-/**
- * Options for retry decorator
- */
-interface WithRetryOptions {
-  /** Maximum number of retry attempts (default: 3) */
-  maxAttempts?: number;
-  /** Initial backoff in milliseconds (default: 100) */
-  initialBackoffMs?: number;
-  /** Maximum backoff in milliseconds (default: 30000) */
-  maxBackoffMs?: number;
-  /** Backoff multiplier for exponential backoff (default: 2) */
-  backoffMultiplier?: number;
-  /** Predicate to determine if error is retryable */
-  retryOn?: (error: Error) => boolean;
-}
-/**
- * Wraps a use case with retry logic
- * - Uses exponential backoff
- * - Only retries on specific errors via retryOn predicate
- * - Backoff is capped at maxBackoffMs
- *
- * @example
- * ```ts
- * const retriedGetUser = withRetry(
- *   getUserProfile,
- *   {
- *     maxAttempts: 3,
- *     initialBackoffMs: 100,
- *     maxBackoffMs: 30000,
- *     backoffMultiplier: 2,
- *     retryOn: (error) => error.message.includes('TIMEOUT'),
- *   }
- * )
- * ```
- */
-declare const withRetry: <I extends any[], O>(fn: (...args: I) => Promise<O>, options?: WithRetryOptions) => ((...args: I) => Promise<O>);
-//#endregion
-//#region src/decorators/with-rate-limit.d.ts
-/**
- * Options for rate limiting decorator
- */
-interface WithRateLimitOptions {
-  /** Rate limit key function - maps input to limit key */
-  keyFn: (input: any) => string;
-  /** Bucket capacity (max requests) */
-  capacity: number;
-  /** Tokens refilled per second */
-  refillPerSecond: number;
-}
-/**
- * Rate limit error
- */
-declare class RateLimitError extends AppError {
-  readonly resetAt: Date;
-  constructor(resetAt: Date);
-}
-/**
- * Wraps a use case with rate limiting
- * - Uses token bucket algorithm
- * - Per-input rate limit tracking via keyFn
- * - Throws RateLimitError when limit exceeded
- *
- * @example
- * ```ts
- * const limitedCreatePost = withRateLimit(
- *   createPost,
- *   rateLimiterStore,
- *   {
- *     keyFn: (input) => `user:${input.userId}`,
- *     capacity: 10,
- *     refillPerSecond: 1, // 1 request per second
- *   }
- * )
- * ```
- */
-declare const withRateLimit: <I extends Record<string, any>, O>(fn: (input: I) => Promise<O>, rateLimiterStore: RateLimiterStore$1, options: WithRateLimitOptions) => ((input: I) => Promise<O>);
-//#endregion
-//#region src/modules/types.d.ts
-/**
- * Application configuration
- */
-interface Config {
-  databaseUrl: string;
-  port: number;
-  corsOrigin: string;
-  googleAiApiKey: string;
-  logLevel: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
-  enableFileLogging: boolean;
-  logDir: string;
-}
-/**
- * Typed Cradle interface for full type safety
- * Includes all registrations from all modules
- */
-interface Cradle {
-  config: Config;
-  dbPool: Pool;
-  db: ReturnType<typeof createDb>;
-  clock: Clock;
-  logger: Logger & StructuredLogger;
-  errorHandler: ErrorHandler;
-  auth: typeof auth;
-  aiProvider: ReturnType<typeof google>;
-  eventBus: EventBus;
-  cacheStore: CacheStore$1;
-  rateLimiterStore: RateLimiterStore$1;
-  userRepository: UserRepository;
-  getUserProfile: (input: {
-    userId: string;
-  }) => Promise<User>;
-  updateUserProfile: (input: {
-    userId: string;
-    updates: Partial<{
-      name: string;
-      email: string;
-    }>;
-  }) => Promise<User>;
-  createUser: (input: {
-    name: string;
-    email: string;
-    emailVerified: boolean;
-  }) => Promise<User>;
-  eventPublisher: EventPublisher;
-  session?: any;
-  requestId: string;
-  requestLogger: Logger;
-}
-//#endregion
-//#region src/modules/core.module.d.ts
-/**
- * Core module: singleton registrations for infrastructure
- * - Database pool and connection
- * - Clock
- * - Logger (structured, Loki/Prometheus compatible)
- * - AI provider
- * - Auth
- */
-declare const registerCoreModule: (container: AwilixContainer<Cradle>) => void;
-//#endregion
-//#region src/modules/user.module.d.ts
-/**
- * User repository module: registers user-related repositories
- *
- * Note: Use case registrations are in apps/server/src/modules/user.module.ts
- * to maintain Clean Architecture layering (Infrastructure should not import Application)
- */
-declare const registerUserModule: (container: AwilixContainer<Cradle>) => void;
-//#endregion
-export { type CacheStore, type Config, type Cradle, type DecoratorContext, ErrorHandler, InMemoryCacheStore, InMemoryEventBus, InMemoryRateLimiterStore, type PerformanceMetrics, RateLimitError, type RateLimiterStore, RequestLoggerOptions, SerializedError, StructuredLogger, type TransactionFn, type UseCase, type WithCachingOptions, type WithRateLimitOptions, type WithRetryOptions, applyDecorators, createDb, createDbPool, decorateUseCase, makeDecoratedUseCase, makeDrizzleUserRepository, makeErrorHandler, makeEventPublisherAdapter, makeInMemoryEventPublisher, makeRequestLogger, makeStructuredLogger, registerCoreModule, registerUserModule, runInTransaction, withCaching, withErrorHandling, withPerformanceMonitoring, withRateLimit, withRequestTracing, withRetry };
+import { t as InMemoryCacheStore } from "./in-memory-cache-store-BaRxM--K.js";
+import { t as CacheStore } from "./index-C6nYd7xV.js";
+import { n as createDbPool, t as createDb } from "./db-tAPHBDyL.js";
+import { t as makeDrizzleUserRepository } from "./user.drizzle-9kkstnkV.js";
+import "./index-B5F3AfVc.js";
+import { n as runInTransaction, t as TransactionFn } from "./transaction-akuz5Fch.js";
+import { t as applyDecorators } from "./apply-decorators-CW23qWy7.js";
+import "./logger-Bl10drB8.js";
+import { a as makeDecoratedUseCase, c as withRequestTracing, i as decorateUseCase, n as PerformanceMetrics, o as withErrorHandling, r as UseCase, s as withPerformanceMonitoring, t as DecoratorContext } from "./use-case-decorator-DzPSPSv5.js";
+import { n as withCaching, t as WithCachingOptions } from "./with-caching-BniS1aZd.js";
+import { n as withRetry, t as WithRetryOptions } from "./with-retry-B9-hUj7I.js";
+import { n as WithRateLimitOptions, r as withRateLimit, t as RateLimitError } from "./with-rate-limit-DK4ZF-Qg.js";
+import "./index-DXJbbtWQ.js";
+import { n as SerializedError, r as makeErrorHandler, t as ErrorHandler } from "./error-handler-BDid7SIZ.js";
+import "./index-LKrIp3Oo.js";
+import { t as makeEventPublisherAdapter } from "./event-publisher-adapter-CpxK0OJ3.js";
+import { t as InMemoryEventBus } from "./in-memory-event-bus-CqIBLRze.js";
+import { t as makeInMemoryEventPublisher } from "./in-memory-event-publisher-CxOQ-hnq.js";
+import "./index-C0yeuOwC.js";
+import { n as makeStructuredLogger, t as StructuredLogger } from "./structured-logger-Dz06Uz-u.js";
+import { n as makeRequestLogger, t as RequestLoggerOptions } from "./request-logger-CK3SOnoz.js";
+import "./index-DVGDAddE.js";
+import { t as InMemoryRateLimiterStore } from "./in-memory-rate-limiter-DJsxdZZR.js";
+import { t as RateLimiterStore } from "./index-BH67NKRs.js";
+import { n as Cradle, t as Config } from "./types-65aFqB5L.js";
+import { t as registerCoreModule } from "./core.module-B1TdC0yX.js";
+import { t as registerUserModule } from "./user.module-D3lVJ98T.js";
+import "./index-B7z6dpFd.js";
+export { CacheStore, type Config, type Cradle, DecoratorContext, ErrorHandler, InMemoryCacheStore, InMemoryEventBus, InMemoryRateLimiterStore, PerformanceMetrics, RateLimitError, RateLimiterStore, RequestLoggerOptions, SerializedError, StructuredLogger, type TransactionFn, UseCase, WithCachingOptions, WithRateLimitOptions, WithRetryOptions, applyDecorators, createDb, createDbPool, decorateUseCase, makeDecoratedUseCase, makeDrizzleUserRepository, makeErrorHandler, makeEventPublisherAdapter, makeInMemoryEventPublisher, makeRequestLogger, makeStructuredLogger, registerCoreModule, registerUserModule, runInTransaction, withCaching, withErrorHandling, withPerformanceMonitoring, withRateLimit, withRequestTracing, withRetry };