@velajs/vela 1.19.0 → 1.19.1

package/dist/discovery.service-BYm95SSD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.service-BYm95SSD.js","names":[],"sources":["../src/errors/http-exception.ts","../src/exceptions/exception-handler.ts","../src/exceptions/reporter.ts","../src/discovery/discovery.service.ts"],"sourcesContent":["export type ExceptionResponse = string | Record<string, unknown>;\n\nexport class HttpException extends Error {\n  public readonly statusCode: number;\n  private readonly _response: ExceptionResponse;\n\n  constructor(response: ExceptionResponse, statusCode: number) {\n    const message = typeof response === 'string' ? response : JSON.stringify(response);\n    super(message);\n    this.name = 'HttpException';\n    this.statusCode = statusCode;\n    this._response = response;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n\n  getStatus(): number {\n    return this.statusCode;\n  }\n\n  getResponse(): Record<string, unknown> {\n    if (typeof this._response === 'string') {\n      return { statusCode: this.statusCode, message: this._response };\n    }\n    return this._response;\n  }\n\n  // The constructor's original argument, untransformed — a string message or a\n  // caller-supplied object. The canonical HTTP edge branches on this: string\n  // responses become `{ error: { code, message } }`, object responses ship\n  // verbatim (crud envelope compat). Distinct from `getResponse()`, which wraps\n  // strings in the legacy `{ statusCode, message }` shape.\n  getRawResponse(): ExceptionResponse {\n    return this._response;\n  }\n}\n\n// 4xx\n\nexport class BadRequestException extends HttpException {\n  constructor(message: ExceptionResponse = 'Bad Request') {\n    super(message, 400);\n    this.name = 'BadRequestException';\n  }\n}\n\nexport class UnauthorizedException extends HttpException {\n  constructor(message: ExceptionResponse = 'Unauthorized') {\n    super(message, 401);\n    this.name = 'UnauthorizedException';\n  }\n}\n\nexport class ForbiddenException extends HttpException {\n  constructor(message: ExceptionResponse = 'Forbidden') {\n    super(message, 403);\n    this.name = 'ForbiddenException';\n  }\n}\n\nexport class NotFoundException extends HttpException {\n  constructor(message: ExceptionResponse = 'Not Found') {\n    super(message, 404);\n    this.name = 'NotFoundException';\n  }\n}\n\nexport class MethodNotAllowedException extends HttpException {\n  constructor(message: ExceptionResponse = 'Method Not Allowed') {\n    super(message, 405);\n    this.name = 'MethodNotAllowedException';\n  }\n}\n\nexport class NotAcceptableException extends HttpException {\n  constructor(message: ExceptionResponse = 'Not Acceptable') {\n    super(message, 406);\n    this.name = 'NotAcceptableException';\n  }\n}\n\nexport class RequestTimeoutException extends HttpException {\n  constructor(message: ExceptionResponse = 'Request Timeout') {\n    super(message, 408);\n    this.name = 'RequestTimeoutException';\n  }\n}\n\nexport class ConflictException extends HttpException {\n  constructor(message: ExceptionResponse = 'Conflict') {\n    super(message, 409);\n    this.name = 'ConflictException';\n  }\n}\n\nexport class GoneException extends HttpException {\n  constructor(message: ExceptionResponse = 'Gone') {\n    super(message, 410);\n    this.name = 'GoneException';\n  }\n}\n\nexport class PayloadTooLargeException extends HttpException {\n  constructor(message: ExceptionResponse = 'Payload Too Large') {\n    super(message, 413);\n    this.name = 'PayloadTooLargeException';\n  }\n}\n\nexport class UnsupportedMediaTypeException extends HttpException {\n  constructor(message: ExceptionResponse = 'Unsupported Media Type') {\n    super(message, 415);\n    this.name = 'UnsupportedMediaTypeException';\n  }\n}\n\nexport class UnprocessableEntityException extends HttpException {\n  constructor(message: ExceptionResponse = 'Unprocessable Entity') {\n    super(message, 422);\n    this.name = 'UnprocessableEntityException';\n  }\n}\n\nexport class TooManyRequestsException extends HttpException {\n  constructor(message: ExceptionResponse = 'Too Many Requests') {\n    super(message, 429);\n    this.name = 'TooManyRequestsException';\n  }\n}\n\n// 5xx\n\nexport class InternalServerErrorException extends HttpException {\n  constructor(message: ExceptionResponse = 'Internal Server Error') {\n    super(message, 500);\n    this.name = 'InternalServerErrorException';\n  }\n}\n\nexport class NotImplementedException extends HttpException {\n  constructor(message: ExceptionResponse = 'Not Implemented') {\n    super(message, 501);\n    this.name = 'NotImplementedException';\n  }\n}\n\nexport class BadGatewayException extends HttpException {\n  constructor(message: ExceptionResponse = 'Bad Gateway') {\n    super(message, 502);\n    this.name = 'BadGatewayException';\n  }\n}\n\nexport class ServiceUnavailableException extends HttpException {\n  constructor(message: ExceptionResponse = 'Service Unavailable') {\n    super(message, 503);\n    this.name = 'ServiceUnavailableException';\n  }\n}\n\nexport class GatewayTimeoutException extends HttpException {\n  constructor(message: ExceptionResponse = 'Gateway Timeout') {\n    super(message, 504);\n    this.name = 'GatewayTimeoutException';\n  }\n}\n","import { isVelaError, type ErrorBodyResult } from '@velajs/errors';\n\n/**\n * A predicate for classifying an error, used by {@link ExceptionHandler.dontReport}.\n *\n * Three shapes are accepted:\n * - `string` — a Vela error code; matches when the error is a branded\n *   `VelaError` whose `code` equals the string.\n * - a predicate `(error: unknown) => boolean` — **must be an arrow function**.\n *   A class and a predicate are both `typeof 'function'`; {@link matchesAny}\n *   discriminates on `prototype`, which arrow functions do not have.\n * - an error class constructor — matches via `instanceof`.\n *\n * Bound functions (e.g. `SomeClass.bind(null)`) also lack `.prototype`, so they\n * are treated as predicates and invoked — never as class matchers. Since a bound\n * constructor cannot be called without `new`, using one here throws; pass the\n * unbound class instead.\n */\nexport type ErrorMatcher =\n  | string\n  | ((error: unknown) => boolean)\n  | (new (...args: never[]) => Error);\n\n/**\n * Ambient context handed to every reporting/rendering hook. `edge` names the\n * transport that caught the error; open-ended extra keys (via the index\n * signature) let a handler's `context()` enrich the payload.\n */\nexport interface ErrorReportContext {\n  edge: 'http' | 'ws' | 'live' | 'queue' | 'schedule' | 'hono';\n  /** e.g. `'CatsController.findAll'` or a query name. */\n  source?: string;\n  /** e.g. `'exception filter threw'`. */\n  note?: string;\n  [key: string]: unknown;\n}\n\n/**\n * The application-wide exception handler contract. Provide an implementation\n * under {@link APP_EXCEPTION_HANDLER} to customize how errors are reported and\n * rendered. Every member is optional — an empty object is a valid handler.\n */\nexport interface ExceptionHandler {\n  /** Fire-and-forget reporting (logging, Sentry, …). May be async. */\n  report?(error: unknown, ctx: ErrorReportContext): void | Promise<void>;\n  /** Errors matching any of these are never reported. */\n  dontReport?: ErrorMatcher[];\n  /** Extra fields merged into the report context. Must be side-effect free. */\n  context?(error: unknown, ctx: ErrorReportContext): Record<string, unknown>;\n  /** Override the client-bound response for an error. */\n  render?(error: unknown, ctx: unknown): Response | ErrorBodyResult | undefined;\n}\n\n/**\n * True when `error` matches any of `matchers`. A string matches a branded\n * {@link VelaError} by `code`; an arrow-function predicate is called; anything\n * else with a `prototype` is treated as an error class and matched via\n * `instanceof`. Predicates therefore MUST be arrow functions — a regular\n * `function` expression has a `prototype` and would be mistaken for a class.\n * Bound functions (e.g. `SomeClass.bind(null)`) lack `.prototype` too, so they\n * are invoked as predicates — don't pass a bound class as a class matcher.\n */\nexport const matchesAny = (matchers: ErrorMatcher[] | undefined, error: unknown): boolean => {\n  if (!matchers?.length) return false;\n  return matchers.some((m) => {\n    if (typeof m === 'string') return isVelaError(error) && error.code === m;\n    if (typeof m === 'function' && !m.prototype) return (m as (e: unknown) => boolean)(error);\n    return error instanceof (m as new () => Error);\n  });\n};\n","import { CORE_CATALOG, isVelaError, type Catalog, type ErrorBodyResult } from '@velajs/errors';\nimport { HTTPException } from 'hono/http-exception';\nimport type { Container } from '../container/container';\nimport { HttpException } from '../errors/http-exception';\nimport { APP_EXCEPTION_HANDLER, ERROR_CATALOG } from '../pipeline/tokens';\nimport { matchesAny, type ErrorReportContext, type ExceptionHandler } from './exception-handler';\n\n/**\n * The resolved reporting facade every transport edge (HTTP, WS, live, queue,\n * schedule) uses. `report` is fire-and-forget and fully contained — a broken\n * or throwing handler can never mask the original error. `render` gives a\n * handler the chance to override the client-bound response.\n */\nexport interface ErrorReporter {\n  catalog: Catalog<string>;\n  report(error: unknown, ctx: ErrorReportContext): void;\n  render(error: unknown, executionCtx: unknown): Response | ErrorBodyResult | undefined;\n}\n\n/**\n * Build an {@link ErrorReporter} from a container. Reads the optional\n * {@link APP_EXCEPTION_HANDLER} and {@link ERROR_CATALOG} providers; with\n * neither registered the reporter logs (unless diagnostics is `'silent'`) and\n * exposes the core catalog.\n */\nexport const resolveErrorReporter = (container: Container): ErrorReporter => {\n  const handler: ExceptionHandler | undefined = container.has(APP_EXCEPTION_HANDLER)\n    ? container.resolve(APP_EXCEPTION_HANDLER)\n    : undefined;\n  const catalog: Catalog<string> = container.has(ERROR_CATALOG)\n    ? container.resolve(ERROR_CATALOG)\n    : CORE_CATALOG;\n\n  return {\n    catalog,\n    report(error, ctx) {\n      let suppressed = false;\n      try {\n        suppressed = matchesAny(handler?.dontReport, error);\n      } catch {\n        // A broken matcher must never mask the original error — treat as no match.\n      }\n      if (suppressed) return;\n      const merged = handler?.context ? { ...ctx, ...safeContext(handler, error, ctx) } : ctx;\n      if (handler?.report) {\n        try {\n          void Promise.resolve(handler.report(error, merged)).catch(() => {});\n        } catch {\n          // A broken reporter must never mask the original error.\n        }\n        return;\n      }\n      if (container.getDiagnostics() !== 'silent') {\n        const status = clientFaultStatus(error);\n        if (status !== undefined && status >= 400 && status < 500) return; // client fault — not server-error log noise\n        console.error(\n          `[vela] ${merged.edge} error${merged.source ? ` in ${merged.source}` : ''}${merged.note ? ` (${merged.note})` : ''}:`,\n          error,\n        );\n      }\n    },\n    render(error, executionCtx) {\n      try {\n        return handler?.render?.(error, executionCtx);\n      } catch {\n        return undefined; // broken render hook falls through to default render\n      }\n    },\n  };\n};\n\n/**\n * The HTTP status of a client-fault (4xx) error, read across the three shapes a\n * caught error can take: a branded {@link VelaError} (`.status`), vela's own\n * {@link HttpException} (`getStatus()`), or hono's {@link HTTPException}\n * (`.status`). `undefined` for anything else — including raw/unbranded errors,\n * which must always be logged. Only the DEFAULT console reporter uses this to\n * mute client faults; a custom `handler.report` still receives everything.\n */\nconst clientFaultStatus = (error: unknown): number | undefined => {\n  if (isVelaError(error)) return error.status;\n  if (error instanceof HttpException) return error.getStatus();\n  if (error instanceof HTTPException) return error.status; // hono\n  return undefined;\n};\n\nconst safeContext = (\n  handler: ExceptionHandler,\n  error: unknown,\n  ctx: ErrorReportContext,\n): Record<string, unknown> => {\n  try {\n    return handler.context?.(error, ctx) ?? {};\n  } catch {\n    return {};\n  }\n};\n","import { Scope } from '../constants';\nimport { Container } from '../container/container';\nimport { Inject, Injectable } from '../container/decorators';\nimport type { Token, Type } from '../container/types';\nimport { MetadataRegistry } from '../registry/metadata.registry';\nimport type { Constructor } from '../registry/types';\nimport type { DiscoverableDecorator } from './discoverable.decorator';\n\n/** A container-registered class provider surfaced by discovery. */\nexport interface DiscoveredClass<T = unknown> {\n  token: Token;\n  metatype: Type<T>;\n  /** Module buckets holding this token (registration order; first = primary). */\n  moduleIds: string[];\n  scope: Scope;\n  /**\n   * Resolved instance. `undefined` only when the provider is request-scoped\n   * and `includeRequestScoped` was not set — request-scoped providers cannot\n   * be materialized at bootstrap without fabricating a phantom request.\n   */\n  instance: T | undefined;\n}\n\nexport interface DiscoveredMethodMeta<M = unknown> {\n  class: DiscoveredClass;\n  methodName: string | symbol;\n  meta: M;\n}\n\nexport interface DiscoveryFilter {\n  /** Restrict to providers declared by these module buckets. */\n  moduleId?: string | string[];\n  /**\n   * Resolve request-scoped providers too (constructs an instance outside any\n   * request — only for callers that know what they're doing). Default false:\n   * request-scoped hits are skipped with a diagnostics warning.\n   */\n  includeRequestScoped?: boolean;\n  /**\n   * Return providers of not-yet-materialized lazy modules as metadata-only\n   * entries (`instance: undefined`, mirroring the request-scoped convention)\n   * instead of resolving them — which would force the whole module group.\n   * Used by `EntrypointRegistry.build`; default false so every existing\n   * scanner keeps its transparent cascade-materialization semantics.\n   */\n  deferLazy?: boolean;\n}\n\n/** Class-level appended-list convention: method decorators that push `{ methodName, ... }` items. */\ninterface MethodMetaItem {\n  methodName: string | symbol;\n}\n\nfunction isMethodMetaItem(x: unknown): x is MethodMetaItem {\n  return (\n    typeof x === 'object' &&\n    x !== null &&\n    (typeof (x as MethodMetaItem).methodName === 'string' ||\n      typeof (x as MethodMetaItem).methodName === 'symbol')\n  );\n}\n\nfunction resolveKey(key: string | DiscoverableDecorator<unknown>): string {\n  return typeof key === 'string' ? key : key.KEY;\n}\n\n/**\n * Decorator-driven provider discovery — the public replacement for the\n * bootstrap scan every subsystem used to hand-roll (`container.getTokens()` +\n * `MetadataRegistry.getCustomClassMeta` + `resolve` + diagnostics handling).\n *\n * Registered globally by `bootstrap()`, so any provider can inject it:\n *\n * ```ts\n * @Injectable()\n * class MyRegistry implements OnApplicationBootstrap {\n *   constructor(private readonly discovery: DiscoveryService) {}\n *   onApplicationBootstrap() {\n *     for (const { instance, meta } of this.discovery.providersWithMeta<MyMeta>(MY_KEY)) {\n *       this.register(instance, meta);\n *     }\n *   }\n * }\n * ```\n *\n * Discovery is kernel-level, not encapsulation-scoped: module visibility\n * protects modules from *each other*, never from the framework's own\n * dispatchers. Use `DiscoveryFilter.moduleId` for the rare narrowing case.\n *\n * The resolve-failure policy honors the container's diagnostics mode exactly\n * like the legacy loops: `throw` rethrows, `log` warns and skips, `silent`\n * skips — so a broken provider never silently changes discovery semantics.\n */\n@Injectable()\nexport class DiscoveryService {\n  constructor(@Inject(Container) private readonly container: Container) {}\n\n  /** Every class-token provider registered in the container. */\n  getProviders(filter?: DiscoveryFilter): DiscoveredClass[] {\n    const out: DiscoveredClass[] = [];\n    for (const token of this.container.getTokens()) {\n      if (typeof token !== 'function') continue;\n      const entry = this.buildEntry(token as Type, filter, 'provider discovery');\n      if (entry) out.push(entry);\n    }\n    return out;\n  }\n\n  /**\n   * Providers whose class carries class-level metadata under `key` — both\n   * class decorators (single value) and method decorators that append\n   * class-level lists (`@Cron`, `@OnEvent`, `@SubscribeMessage`).\n   */\n  providersWithMeta<M>(\n    key: string | DiscoverableDecorator<M>,\n    filter?: DiscoveryFilter,\n  ): Array<DiscoveredClass & { meta: M }> {\n    const metaKey = resolveKey(key as string | DiscoverableDecorator<unknown>);\n    const out: Array<DiscoveredClass & { meta: M }> = [];\n    for (const target of this.candidatesWithClassMeta(metaKey)) {\n      const entry = this.buildEntry(target as Type, filter, `discovery of '${metaKey}'`);\n      if (!entry) continue;\n      const meta = MetadataRegistry.getCustomClassMeta(target, metaKey) as M;\n      out.push({ ...entry, meta });\n    }\n    return out;\n  }\n\n  /**\n   * Handler methods carrying metadata under `key`. Merges the two storage\n   * conventions:\n   *  - class-level appended lists whose items carry `methodName`\n   *    (`@Cron`/`@OnEvent`-style method decorators), and\n   *  - true handler-level metadata (`@SetMetadata`/`createDiscoverableDecorator`\n   *    applied to a method).\n   */\n  methodsWithMeta<M>(\n    key: string | DiscoverableDecorator<M>,\n    filter?: DiscoveryFilter,\n  ): DiscoveredMethodMeta<M>[] {\n    const metaKey = resolveKey(key as string | DiscoverableDecorator<unknown>);\n    const out: DiscoveredMethodMeta<M>[] = [];\n\n    for (const target of this.candidatesWithClassMeta(metaKey)) {\n      const classMeta = MetadataRegistry.getCustomClassMeta(target, metaKey);\n      if (!Array.isArray(classMeta) || !classMeta.some(isMethodMetaItem)) continue;\n      const entry = this.buildEntry(target as Type, filter, `discovery of '${metaKey}'`);\n      if (!entry) continue;\n      for (const item of classMeta) {\n        if (!isMethodMetaItem(item)) continue;\n        out.push({ class: entry, methodName: item.methodName, meta: item as M });\n      }\n    }\n\n    for (const target of MetadataRegistry.getClassesWithHandlerMeta(metaKey)) {\n      if (!this.container.has(target as Token)) continue;\n      const entry = this.buildEntry(target as Type, filter, `discovery of '${metaKey}'`);\n      if (!entry) continue;\n      for (const { handler, value } of MetadataRegistry.getHandlersWithMeta(target, metaKey)) {\n        out.push({ class: entry, methodName: handler, meta: value as M });\n      }\n    }\n\n    return out;\n  }\n\n  /**\n   * Index-first candidate walk with a legacy full-scan fallback: when the\n   * reverse index knows nothing about a key, an older copy of the registry\n   * module may have taken the writes (mixed dist/src or package versions in\n   * one process) — fall back to scanning container tokens the way the\n   * pre-DiscoveryService loops did.\n   */\n  private candidatesWithClassMeta(metaKey: string): object[] {\n    const indexed = MetadataRegistry.getClassesWithClassMeta(metaKey);\n    if (indexed.size > 0) {\n      return [...indexed].filter((t) => this.container.has(t as Token));\n    }\n    const out: object[] = [];\n    for (const token of this.container.getTokens()) {\n      if (typeof token !== 'function') continue;\n      if (MetadataRegistry.getCustomClassMeta(token, metaKey) !== undefined) {\n        out.push(token);\n      }\n    }\n    return out;\n  }\n\n  private buildEntry(\n    metatype: Type,\n    filter: DiscoveryFilter | undefined,\n    label: string,\n  ): DiscoveredClass | undefined {\n    const moduleIds = this.container.getOwnerModuleIds(metatype);\n    if (moduleIds.length === 0) return undefined;\n\n    if (filter?.moduleId !== undefined) {\n      const wanted = Array.isArray(filter.moduleId) ? filter.moduleId : [filter.moduleId];\n      if (!moduleIds.some((id) => wanted.includes(id))) return undefined;\n    }\n\n    const scope = this.container.getProviderScope(metatype) ?? Scope.SINGLETON;\n\n    if (filter?.deferLazy && this.container.isLazyPending(metatype)) {\n      // Deliberate deferral — no diagnostics warning: the entry is complete\n      // metadata-wise and consumers re-resolve by token at dispatch time.\n      return { token: metatype, metatype, moduleIds, scope, instance: undefined };\n    }\n\n    if (scope === Scope.REQUEST && !filter?.includeRequestScoped) {\n      if (this.container.getDiagnostics() === 'log') {\n        console.warn(\n          `[vela] ${label}: ${metatype.name} is request-scoped and cannot be ` +\n            `materialized at bootstrap — skipped. Pass { includeRequestScoped: true } to override.`,\n        );\n      }\n      return { token: metatype, metatype, moduleIds, scope, instance: undefined };\n    }\n\n    let instance: unknown;\n    try {\n      instance = this.container.resolve(metatype);\n    } catch (err) {\n      const mode = this.container.getDiagnostics();\n      if (mode === 'throw') throw err;\n      if (mode === 'log') {\n        console.warn(`[vela] ${label}: cannot resolve ${metatype.name}:`, err);\n      }\n      return undefined;\n    }\n\n    return { token: metatype, metatype, moduleIds, scope, instance };\n  }\n}\n\n// Re-export so consumers can narrow on Constructor without importing registry types.\nexport type { Constructor };\n"],"mappings":"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"}