@composed-di/core 0.5.2-alpha → 0.6.0-alpha

package/dist/serviceModuleListener.d.ts

@@ -1,133 +0,0 @@
-import type { ServiceKey } from './serviceKey';
-/**
- * A handle representing a single in-flight operation (initialization,
- * disposal, or method call), returned by a ServiceEventListener when the
- * operation starts.
- *
- * `end` is invoked exactly once when the operation finishes, so
- * implementations can close over per-call state (a start time, a span
- * handle, a correlation id) without any bookkeeping to pair concurrent
- * start/finish events.
- */
-export interface EventSpan {
-    /**
-     * Optional wrapper around the operation itself. When present, the module
-     * invokes the operation as `run(() => operation())`, so the listener can
-     * establish ambient state that the operation body and its async
-     * continuations inherit — this is what lets spans of nested service
-     * calls form a parent-child hierarchy.
-     *
-     * Implementations must invoke `fn` exactly once, synchronously, and
-     * return its result unchanged (for async operations, the promise itself).
-     * `end` is still delivered separately when the operation finishes.
-     *
-     * @param fn - A thunk that performs the operation.
-     * @return The value returned by `fn`.
-     */
-    run?<T>(fn: () => T): T;
-    /**
-     * Invoked exactly once when the operation finishes, whether it succeeded
-     * or failed. For methods that return a promise, this fires when the
-     * promise settles, not when the method returns. On failure, the error is
-     * rethrown to the caller after this is invoked.
-     *
-     * Whether to retain or log the outcome is the implementation's choice;
-     * values are passed by reference, so implementations must not mutate them.
-     *
-     * @param outcome - How the operation finished, and its value or error.
-     * @return void
-     */
-    end?(outcome: EventOutcome): void;
-}
-/**
- * How an operation finished, delivered to EventSpan.end: `success` carries
- * the value produced by the operation (the return or resolved value for
- * method calls, the service instance for initialize, undefined for
- * dispose); `failure` carries the error that was thrown or rejected.
- */
-export type EventOutcome = {
-    type: 'success';
-    value: unknown;
-} | {
-    type: 'failure';
-    error: unknown;
-};
-/**
- * Context of a service initialization, delivered to onInitialize.
- * Future fields are added here rather than as extra parameters.
- */
-export interface InitializeContext {
-    /**
-     * The unique identifier of the service that is being initialized.
-     */
-    key: ServiceKey<unknown>;
-}
-/**
- * Context of a service disposal, delivered to onDispose.
- * Future fields are added here rather than as extra parameters.
- */
-export interface DisposeContext {
-    /**
-     * The unique identifier of the service that is being disposed.
-     */
-    key: ServiceKey<unknown>;
-}
-/**
- * Context of a method invocation, delivered to onMethodCall.
- * Future fields are added here rather than as extra parameters.
- */
-export interface MethodCallContext {
-    /**
-     * The unique identifier of the service the method belongs to.
-     */
-    key: ServiceKey<unknown>;
-    /**
-     * The name of the class implementing the service (the instance's
-     * constructor name), which may differ from `key.name`. Undefined for
-     * services that are not instances of a named class, such as plain
-     * object literals.
-     */
-    className?: string;
-    /**
-     * The name of the method that is being called.
-     */
-    functionName: string;
-    /**
-     * The arguments the method was invoked with, passed by reference;
-     * implementations must not mutate them.
-     */
-    args: readonly unknown[];
-}
-/**
- * Interface for listening to service events. Implement this interface to
- * observe lifecycle events and method calls of services in a module.
- *
- * Each method is invoked when the corresponding operation starts and may
- * return an EventSpan that is notified when that operation finishes.
- * Returning nothing opts out of completion tracking for that call.
- */
-export interface ServiceModuleListener {
-    /**
-     * Invoked at the start of the initialization process for a specific service.
-     *
-     * @param context - Context of the initialization, including the service key.
-     * @return An EventSpan notified when initialization finishes, or void.
-     */
-    onInitialize?(context: InitializeContext): EventSpan | void;
-    /**
-     * Invoked when the disposal process for a service starts.
-     *
-     * @param context - Context of the disposal, including the service key.
-     * @return An EventSpan notified when disposal finishes, or void.
-     */
-    onDispose?(context: DisposeContext): EventSpan | void;
-    /**
-     * Invoked when a method call starts on a service instance.
-     *
-     * @param context - Context of the invocation, including the service key,
-     * the method name, and its arguments.
-     * @return An EventSpan notified when the call finishes, or void.
-     */
-    onMethodCall?(context: MethodCallContext): EventSpan | void;
-}
-//# sourceMappingURL=serviceModuleListener.d.ts.map

package/dist/serviceModuleListener.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serviceModuleListener.d.ts","sourceRoot":"","sources":["../src/serviceModuleListener.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GACtB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IAEzB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,YAAY,CAAC,CAAC,OAAO,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAAC;IAE5D;;;;;OAKG;IACH,SAAS,CAAC,CAAC,OAAO,EAAE,cAAc,GAAG,SAAS,GAAG,IAAI,CAAC;IAEtD;;;;;;OAMG;IACH,YAAY,CAAC,CAAC,OAAO,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,CAAC;CAC7D"}

package/dist/serviceModuleListener.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=serviceModuleListener.js.map

package/dist/serviceModuleListener.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serviceModuleListener.js","sourceRoot":"","sources":["../src/serviceModuleListener.ts"],"names":[],"mappings":""}

package/src/redactingEventListener.ts

@@ -1,132 +0,0 @@
-import type {
-  DisposeContext,
-  EventOutcome,
-  EventSpan,
-  InitializeContext,
-  MethodCallContext,
-  ServiceModuleListener,
-} from './serviceModuleListener';
-import type { ServiceKey } from './serviceKey';
-
-/**
- * The placeholder that replaces redacted values in event contexts and
- * outcomes.
- */
-export const REDACTED_VALUE = '[redacted]';
-
-/**
- * Marks a service — or specific properties of it — as sensitive, so the
- * values flowing through its events are replaced with {@link REDACTED_VALUE}.
- */
-export interface RedactionRule<T> {
-  /**
-   * The service key whose values must be redacted. Matched by key
-   * identity, like everywhere else in the container.
-   */
-  key: ServiceKey<T>;
-
-  /**
-   * Property names to redact. Optional: when omitted, ALL properties of
-   * the service are redacted, along with its initialize result (the
-   * service instance itself may carry credentials or config).
-   */
-  properties?: Extract<keyof T, string>[];
-}
-
-export function redactionRule<T>(key: ServiceKey<T>, properties?: Extract<keyof T, string>[]): RedactionRule<T> {
-  return { key, properties };
-}
-
-/**
- * A ServiceEventListener decorator that redacts sensitive values before
- * they reach the wrapped listener. Works with any implementation via
- * delegation: arguments in MethodCallContext and success values in
- * EventOutcome are replaced with {@link REDACTED_VALUE}, so the delegate
- * never sees the sensitive data — whatever it captures or exports is
- * already scrubbed.
- *
- * Failure outcomes are passed through unchanged so error reporting keeps
- * working; keep secrets out of error messages at the throwing site.
- *
- * @example
- * ```ts
- * const listener = new RedactingEventListener(
- *   new OTELEventListener({ captureArguments: true, captureResults: true }),
- *   [
- *     { key: SecretClientKey }, // whole service is sensitive
- *     { key: VaultKey, properties: ['getSecret'] }, // only these calls
- *   ],
- * );
- * ```
- */
-export class RedactingEventListener implements ServiceModuleListener {
-  constructor(
-    private readonly delegate: ServiceModuleListener,
-    private readonly rules: readonly RedactionRule<any>[],
-  ) {}
-
-  onInitialize(context: InitializeContext): EventSpan | void {
-    // The initialize result is the service instance itself, so it is
-    // redacted only when the whole service is sensitive — a rule without
-    // `properties`.
-    return redactSpan(
-      this.delegate.onInitialize?.(context),
-      this.isRedacted(context.key),
-    );
-  }
-
-  onDispose(context: DisposeContext): EventSpan | void {
-    // Dispose carries no arguments and no result value; nothing to redact.
-    return this.delegate.onDispose?.(context);
-  }
-
-  onMethodCall(context: MethodCallContext): EventSpan | void {
-    const redacted = this.isRedacted(context.key, context.functionName);
-    const span = this.delegate.onMethodCall?.(
-      redacted
-        ? // Replace each argument rather than the whole array, so the
-          // delegate still sees the call's arity.
-          { ...context, args: context.args.map(() => REDACTED_VALUE) }
-        : context,
-    );
-    return redactSpan(span, redacted);
-  }
-
-  // 1. Si expiro el dbr `EXPIRED` el cron debe mandar a `FACE_MISMATCH`?
-  // 2. Si hubo un matchLevel intermediario el cron debe mandar a `FACE_MISMATCH`? (Probablemente no)
-  private isRedacted(key: ServiceKey<any>, propertyName?: string): boolean {
-    return this.rules.some(
-      (rule) =>
-        rule.key === key &&
-        // A rule without `properties` redacts everything on the key,
-        // including initialize — where no property name is passed —
-        // while a rule with `properties` matches only those calls.
-        (rule.properties === undefined ||
-          (propertyName !== undefined &&
-            rule.properties?.includes(propertyName))),
-    );
-  }
-}
-
-/**
- * Wraps the delegate's EventSpan so success values are redacted before
- * `end` sees them. `run` (and any future fields) pass through untouched.
- */
-function redactSpan(
-  span: EventSpan | void,
-  redacted: boolean,
-): EventSpan | void {
-  if (!redacted || !span?.end) {
-    return span;
-  }
-  const end = span.end.bind(span);
-  return {
-    ...span,
-    end: (outcome: EventOutcome) =>
-      end(
-        outcome.type === 'success'
-          ? { type: 'success', value: REDACTED_VALUE }
-          : outcome,
-      ),
-  };
-}

package/src/serviceModuleListener.ts

@@ -1,139 +0,0 @@
-import type { ServiceKey } from './serviceKey';
-
-/**
- * A handle representing a single in-flight operation (initialization,
- * disposal, or method call), returned by a ServiceEventListener when the
- * operation starts.
- *
- * `end` is invoked exactly once when the operation finishes, so
- * implementations can close over per-call state (a start time, a span
- * handle, a correlation id) without any bookkeeping to pair concurrent
- * start/finish events.
- */
-export interface EventSpan {
-  /**
-   * Optional wrapper around the operation itself. When present, the module
-   * invokes the operation as `run(() => operation())`, so the listener can
-   * establish ambient state that the operation body and its async
-   * continuations inherit — this is what lets spans of nested service
-   * calls form a parent-child hierarchy.
-   *
-   * Implementations must invoke `fn` exactly once, synchronously, and
-   * return its result unchanged (for async operations, the promise itself).
-   * `end` is still delivered separately when the operation finishes.
-   *
-   * @param fn - A thunk that performs the operation.
-   * @return The value returned by `fn`.
-   */
-  run?<T>(fn: () => T): T;
-
-  /**
-   * Invoked exactly once when the operation finishes, whether it succeeded
-   * or failed. For methods that return a promise, this fires when the
-   * promise settles, not when the method returns. On failure, the error is
-   * rethrown to the caller after this is invoked.
-   *
-   * Whether to retain or log the outcome is the implementation's choice;
-   * values are passed by reference, so implementations must not mutate them.
-   *
-   * @param outcome - How the operation finished, and its value or error.
-   * @return void
-   */
-  end?(outcome: EventOutcome): void;
-}
-
-/**
- * How an operation finished, delivered to EventSpan.end: `success` carries
- * the value produced by the operation (the return or resolved value for
- * method calls, the service instance for initialize, undefined for
- * dispose); `failure` carries the error that was thrown or rejected.
- */
-export type EventOutcome =
-  { type: 'success'; value: unknown } | { type: 'failure'; error: unknown };
-
-/**
- * Context of a service initialization, delivered to onInitialize.
- * Future fields are added here rather than as extra parameters.
- */
-export interface InitializeContext {
-  /**
-   * The unique identifier of the service that is being initialized.
-   */
-  key: ServiceKey<unknown>;
-}
-
-/**
- * Context of a service disposal, delivered to onDispose.
- * Future fields are added here rather than as extra parameters.
- */
-export interface DisposeContext {
-  /**
-   * The unique identifier of the service that is being disposed.
-   */
-  key: ServiceKey<unknown>;
-}
-
-/**
- * Context of a method invocation, delivered to onMethodCall.
- * Future fields are added here rather than as extra parameters.
- */
-export interface MethodCallContext {
-  /**
-   * The unique identifier of the service the method belongs to.
-   */
-  key: ServiceKey<unknown>;
-
-  /**
-   * The name of the class implementing the service (the instance's
-   * constructor name), which may differ from `key.name`. Undefined for
-   * services that are not instances of a named class, such as plain
-   * object literals.
-   */
-  className?: string;
-
-  /**
-   * The name of the method that is being called.
-   */
-  functionName: string;
-
-  /**
-   * The arguments the method was invoked with, passed by reference;
-   * implementations must not mutate them.
-   */
-  args: readonly unknown[];
-}
-
-/**
- * Interface for listening to service events. Implement this interface to
- * observe lifecycle events and method calls of services in a module.
- *
- * Each method is invoked when the corresponding operation starts and may
- * return an EventSpan that is notified when that operation finishes.
- * Returning nothing opts out of completion tracking for that call.
- */
-export interface ServiceModuleListener {
-  /**
-   * Invoked at the start of the initialization process for a specific service.
-   *
-   * @param context - Context of the initialization, including the service key.
-   * @return An EventSpan notified when initialization finishes, or void.
-   */
-  onInitialize?(context: InitializeContext): EventSpan | void;
-
-  /**
-   * Invoked when the disposal process for a service starts.
-   *
-   * @param context - Context of the disposal, including the service key.
-   * @return An EventSpan notified when disposal finishes, or void.
-   */
-  onDispose?(context: DisposeContext): EventSpan | void;
-
-  /**
-   * Invoked when a method call starts on a service instance.
-   *
-   * @param context - Context of the invocation, including the service key,
-   * the method name, and its arguments.
-   * @return An EventSpan notified when the call finishes, or void.
-   */
-  onMethodCall?(context: MethodCallContext): EventSpan | void;
-}