@cullet/erp-core 1.2.0 → 1.3.0

package/dist/temporal-use-case.d.cts

@@ -0,0 +1,304 @@
+import { n as ContractVersion } from "./version.cjs";
+import { a as Result } from "./outcome.cjs";
+import { t as AppError } from "./app-error.cjs";
+import { b as ContextSeed, r as PolicyEvaluationResult, s as PolicyEvaluationError, t as EvaluateInput } from "./policy-service.cjs";
+import { t as DeepReadonly } from "./immutable.cjs";
+
+//#region src/core/application/ports/logger.port.d.ts
+type LogPayload = Record<string, unknown>;
+interface LoggerPort {
+  debug(message: string, payload?: LogPayload): void;
+  info(message: string, payload?: LogPayload): void;
+  warn(message: string, payload?: LogPayload): void;
+  error(message: string, payload?: LogPayload): void;
+}
+//#endregion
+//#region src/core/application/ports/metrics.port.d.ts
+type MetricLabels = Readonly<Record<string, string | number | boolean>>;
+interface MetricsPort {
+  counter(name: string, value: number, labels?: MetricLabels): void;
+  gauge(name: string, value: number, labels?: MetricLabels): void;
+  histogram(name: string, value: number, labels?: MetricLabels): void;
+}
+//#endregion
+//#region src/core/application/ports/tracer.port.d.ts
+type TraceAttributeValue = string | number | boolean;
+interface TraceSpan {
+  setAttribute(key: string, value: TraceAttributeValue): void;
+  recordException(error: unknown): void;
+  end(): void;
+}
+interface TracerPort {
+  startSpan(name: string, attributes?: Record<string, TraceAttributeValue>): TraceSpan;
+}
+//#endregion
+//#region src/core/application/use-case.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Observability adapters a use case may opt into.
+ *
+ * All fields are optional: a use case that provides none keeps the plain
+ * `input → Result` behavior with zero overhead. When provided, {@link UseCase.run}
+ * instruments every execution around `execute()` — opening a span, recording
+ * duration, counting outcomes, and logging business/unexpected failures.
+ */
+interface UseCaseObservability {
+  readonly logger?: LoggerPort;
+  readonly metrics?: MetricsPort;
+  readonly tracer?: TracerPort;
+}
+declare abstract class UseCase<Input = void, Output extends Result<unknown, unknown> = Result<void, never>> {
+  static readonly CONTRACT_VERSION: ContractVersion;
+  get contractVersion(): ContractVersion;
+  /**
+   * Runs the use case.
+   *
+   * `run()` is the single seam every use case crosses, so it is where
+   * cross-cutting instrumentation lives. When {@link observability} exposes
+   * any adapter, the call to `execute()` is wrapped with tracing, metrics and
+   * failure logging; otherwise it delegates directly with no overhead.
+   *
+   * Observability is strictly side-effecting: a misbehaving adapter never
+   * changes the business result nor masks a thrown error — its own failures
+   * are swallowed.
+   */
+  run(input: Input): Promise<Output>;
+  /**
+   * Adapters used to instrument {@link run}. Override to opt a use case into
+   * tracing/metrics/logging. Returns an empty object by default, which keeps
+   * the plain delegating behavior.
+   */
+  protected observability(): UseCaseObservability;
+  /**
+   * Stable identity used for span names and metric labels. Defaults to the
+   * runtime class name; override when bundling/minification would otherwise
+   * erase a meaningful name.
+   */
+  protected get useCaseName(): string;
+  protected abstract execute(input: Input): MaybePromise<Output>;
+  private runInstrumented;
+}
+//#endregion
+//#region src/core/application/commands/requested-by.d.ts
+type RequestedByKind = "user" | "system";
+declare class RequestedBy {
+  readonly kind: RequestedByKind;
+  readonly raw: string;
+  private constructor();
+  /** Builds from a human user ID (must be a UUID). */
+  static fromUser(userId: string): RequestedBy;
+  /**
+   * Builds from a system identity.
+   * Only accepts the format "system:<job>", where <job> matches [a-z][a-z0-9]*(-[a-z0-9]+)*.
+   */
+  static fromSystem(systemIdentity: string): RequestedBy;
+  /**
+   * Infers the kind from the raw value.
+   * Use when the origin (user vs system) is not known at the call-site.
+   */
+  static parse(raw: string): RequestedBy;
+  get isUser(): boolean;
+  get isSystem(): boolean;
+  toString(): string;
+}
+//#endregion
+//#region src/core/application/commands/command.d.ts
+interface CommandInput {
+  readonly requestedBy: RequestedBy;
+}
+/**
+ * Base for use cases that **mutate state** (writes), following CQS.
+ *
+ * - `Input extends CommandInput` ensures every mutation records who triggered it.
+ * - `Output extends Result<unknown, unknown>` ensures business errors are
+ *   explicit values, never thrown exceptions.
+ *
+ * The Command/Query distinction is semantic: the type declares the intent
+ * before any implementation exists, guiding code review and API contracts.
+ */
+declare abstract class Command<Input extends CommandInput, Output extends Result<unknown, unknown> = Result<void, never>> extends UseCase<Input, Output> {}
+//#endregion
+//#region src/core/application/ports/policy-port.d.ts
+type PolicyEvaluationInput = EvaluateInput;
+type PolicyEvaluationOutput = PolicyEvaluationResult;
+/**
+ * Failure surfaced by {@link PolicyPort.evaluate}.
+ *
+ * This is the *post-mapping* boundary: the structured `PolicyEvaluationError`
+ * union produced inside the policies module is expected to have already been
+ * translated into an {@link AppError} (e.g. via `mapPolicyEvaluationError`)
+ * before it reaches a use case. Named distinctly from the policies-layer
+ * `PolicyEvaluationError` to avoid a collision on the public surface.
+ */
+type PolicyPortError = AppError;
+interface PolicyPort {
+  evaluate(input: PolicyEvaluationInput): Promise<Result<PolicyEvaluationOutput, PolicyPortError>>;
+}
+//#endregion
+//#region src/core/application/ports/repository.port.d.ts
+/**
+ * Persistence port for an aggregate in the imperative style: absence is
+ * modelled as `null`, and failures (missing row on delete, optimistic
+ * concurrency conflicts, infrastructure errors) surface as thrown exceptions.
+ *
+ * Prefer {@link ResultRepository} when you want those persistence outcomes to
+ * be explicit, recoverable values rather than exceptions.
+ */
+interface Repository<TEntity, TId> {
+  findById(id: TId): Promise<TEntity | null>;
+  save(entity: TEntity): Promise<void>;
+  delete(id: TId): Promise<void>;
+}
+/**
+ * `Result`-returning counterpart of {@link Repository}, aligned with the
+ * "errors as values" philosophy used by `Command` / `UseCase`.
+ *
+ * Where {@link Repository} returns `Promise<void>` from `save`/`delete` and
+ * relies on thrown exceptions, this variant lets a repository *signal*
+ * recoverable persistence outcomes without breaking control flow — for
+ * example a `NotFoundError` when updating/deleting a missing aggregate, or a
+ * `ConflictError` on an optimistic-concurrency version mismatch. A successful
+ * write resolves to `Result.ok(undefined)`.
+ *
+ * `findById` keeps `null` as the "not present" answer to a lookup (not an
+ * error) while still wrapping the call in a `Result` so genuine failures
+ * (e.g. a connectivity error) stay in band.
+ *
+ * `TError` defaults to {@link AppError} to match the rest of the application
+ * boundary (see `PolicyPortError`); narrow it per repository when the failure
+ * set is known, e.g. `ResultRepository<Order, OrderId, NotFoundError | ConflictError>`.
+ */
+interface ResultRepository<TEntity, TId, TError = AppError> {
+  findById(id: TId): Promise<Result<TEntity | null, TError>>;
+  save(entity: TEntity): Promise<Result<void, TError>>;
+  delete(id: TId): Promise<Result<void, TError>>;
+}
+//#endregion
+//#region src/core/domain/temporal/transaction-time.d.ts
+/**
+ * Represents transaction time (Transaction Time).
+ * Defines when the system learned about or recorded a piece of information.
+ * Useful for auditing and reconstructing system state at a specific past moment.
+ */
+interface TransactionTime {
+  /** When the information was first recorded in the system. */
+  readonly recordedAt: Date;
+  /** When this information was superseded or invalidated by a newer version. */
+  readonly supersededAt?: Date;
+}
+//#endregion
+//#region src/core/domain/temporal/valid-time.d.ts
+/**
+ * Represents business time (Valid Time).
+ * Defines when a piece of information is considered true or in effect in the real world.
+ */
+interface ValidTime {
+  /** Start of the validity window (inclusive). */
+  readonly from: Date;
+  /** End of the validity window (exclusive). When absent, the information is still in effect. */
+  readonly to?: Date;
+}
+//#endregion
+//#region src/core/domain/temporal/temporal-snapshot.d.ts
+/**
+ * Pairs a domain datum with its time dimensions (Business and Transaction).
+ * It is the representation of an entry in the append-only (historical) table.
+ */
+interface TemporalSnapshot<T> {
+  /** The data or state captured by the snapshot. */
+  readonly data: DeepReadonly<T>;
+  /** Period during which this datum was valid in the real world. */
+  readonly validTime: ValidTime;
+  /** Period during which this record was the state known to the system. */
+  readonly txTime: TransactionTime;
+}
+//#endregion
+//#region src/core/application/ports/temporal-repository.port.d.ts
+type TemporalHistory<TEntity> = readonly TemporalSnapshot<TEntity>[];
+interface TemporalRepository<TEntity, TId> extends Repository<TEntity, TId> {
+  findAsOf(id: TId, asOf: Date): Promise<TEntity | null>;
+  findAtTransaction(id: TId, txTime: Date): Promise<TEntity | null>;
+  findHistory(id: TId): Promise<TemporalHistory<TEntity>>;
+  save(entity: TEntity, validFrom?: Date): Promise<void>;
+}
+//#endregion
+//#region src/core/application/policy-error-mapper.d.ts
+declare function mapPolicyEvaluationError(err: PolicyEvaluationError): AppError;
+//#endregion
+//#region src/core/application/queries/query.d.ts
+/**
+ * Paginated result of a list query.
+ * Use as `Output` when the query returns a collection with pagination metadata.
+ */
+interface Page<T> {
+  readonly items: readonly T[];
+  readonly total: number;
+  readonly page: number;
+  readonly pageSize: number;
+}
+/**
+ * Cache strategy declared by the query type.
+ * Infrastructure reads this value to decide whether and how to cache the result.
+ */
+type CacheStrategy = {
+  readonly kind: "NO_CACHE";
+} | {
+  readonly kind: "TIME_TO_LIVE";
+  readonly ttlMs: number;
+} | {
+  readonly kind: "STALE_WHILE_REVALIDATE";
+  readonly ttlMs: number;
+};
+type QueryOutput = object | string | number | boolean | bigint | symbol | null;
+/**
+ * Base for use cases that **only read state**, with no side effects, following CQS.
+ *
+ * - `Data extends QueryOutput` prevents a query from declaring a `void` or
+ *   `undefined` success payload, while still allowing primitive projections
+ *   and `null` when that makes sense for the read. Failures stay explicit in
+ *   `Result<T, E>`.
+ * - Override `cacheStrategy()` to declare how infrastructure should cache the
+ *   result. By default, no cache is applied.
+ *
+ * A Query must never mutate persisted data — its execution must be idempotent
+ * and safe to call multiple times with the same input.
+ */
+declare abstract class Query<Input = void, Data extends QueryOutput = never, Failure = AppError> extends UseCase<Input, Result<Data, Failure>> {
+  protected cacheStrategy(): CacheStrategy;
+}
+//#endregion
+//#region src/core/application/temporal/temporal-context.d.ts
+interface TemporalContext {
+  readonly asOf: Date;
+  readonly requestedAt: Date;
+}
+interface CreateTemporalContextInput {
+  readonly asOf?: Date;
+  readonly requestedAt?: Date;
+}
+declare function assertTemporalContext(temporalContext: TemporalContext, fieldName?: string): void;
+declare function createTemporalContext(input?: CreateTemporalContextInput): TemporalContext;
+//#endregion
+//#region src/core/application/temporal/temporal-use-case.d.ts
+interface TemporalUseCaseInput {
+  readonly temporalContext?: TemporalContext;
+}
+/**
+ * A {@link ContextSeed} after temporal enrichment by
+ * {@link TemporalUseCase.buildPolicySeed}: structurally identical to `TSeed`,
+ * except `fields.now` is now guaranteed present as a `Date` (injected from the
+ * resolved {@link TemporalContext}). Downstream policies can therefore read
+ * `seed.fields.now` without a presence/type guard.
+ */
+type TemporalizedContextSeed<TSeed extends ContextSeed> = Omit<TSeed, "fields"> & {
+  readonly fields: TSeed["fields"] & {
+    readonly now: Date;
+  };
+};
+declare abstract class TemporalUseCase<Input extends object, Output extends Result<unknown, unknown>> extends UseCase<Input & TemporalUseCaseInput, Output> {
+  protected resolveTemporalContext(input: Input & TemporalUseCaseInput): TemporalContext;
+  protected buildPolicySeed<TSeed extends ContextSeed>(seed: TSeed, temporalContext: TemporalContext): TemporalizedContextSeed<TSeed>;
+}
+//#endregion
+export { MetricLabels as A, RequestedByKind as C, TraceAttributeValue as D, UseCaseObservability as E, LogPayload as M, LoggerPort as N, TraceSpan as O, RequestedBy as S, UseCase as T, PolicyEvaluationOutput as _, TemporalContext as a, Command as b, CacheStrategy as c, mapPolicyEvaluationError as d, TemporalHistory as f, PolicyEvaluationInput as g, ResultRepository as h, CreateTemporalContextInput as i, MetricsPort as j, TracerPort as k, Page as l, Repository as m, TemporalUseCaseInput as n, assertTemporalContext as o, TemporalRepository as p, TemporalizedContextSeed as r, createTemporalContext as s, TemporalUseCase as t, Query as u, PolicyPort as v, MaybePromise as w, CommandInput as x, PolicyPortError as y };
+//# sourceMappingURL=temporal-use-case.d.cts.map

package/dist/unexpected-error.cjs

@@ -0,0 +1,208 @@
+//#region src/core/errors/error-codes.ts
+const ErrorCodes = {
+	authentication: {
+		missingToken: "sec.authn.missing_token",
+		invalidToken: "sec.authn.invalid_token",
+		expiredToken: "sec.authn.expired_token",
+		invalidCredentials: "sec.authn.invalid_credentials"
+	},
+	authorization: {
+		forbidden: "sec.authz.forbidden",
+		policyDenied: "sec.authz.policy_denied",
+		missingCapability: "sec.authz.missing_capability",
+		outOfScope: "sec.authz.out_of_scope"
+	},
+	businessRuleViolation: "business_rule_violation",
+	conflict: {
+		alreadyExists: "conf.already_exists",
+		duplicate: "conf.duplicate",
+		uniqueViolation: "conf.unique_violation"
+	},
+	idempotency: {
+		keyMissing: "idemp.key_missing",
+		inProgress: "idemp.in_progress",
+		payloadMismatch: "idemp.payload_mismatch",
+		replayNotSupported: "idemp.replay_not_supported"
+	},
+	integration: {
+		timeout: "int.timeout",
+		unreachable: "int.unreachable",
+		badResponse: "int.bad_response"
+	},
+	legacyIncompatible: "legacy_incompatible",
+	notFound: "not_found",
+	serialization: {
+		deserializePrefix: "ser.des",
+		serializePrefix: "ser.ser"
+	},
+	temporal: {
+		expired: "tmp.expired",
+		notYetValid: "tmp.not_yet_valid"
+	},
+	unexpected: "unexpected",
+	validation: "validation_error"
+};
+function serializationErrorCode(direction, category) {
+	return `${direction === "deserialize" ? ErrorCodes.serialization.deserializePrefix : ErrorCodes.serialization.serializePrefix}.${category}`;
+}
+//#endregion
+//#region src/core/errors/utils/json-safe.ts
+const NON_SERIALIZABLE_PLACEHOLDER = "[NonSerializable]";
+const CIRCULAR_REFERENCE_PLACEHOLDER = "[Circular]";
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function sanitizeValue(value, seen) {
+	if (value === null) return null;
+	const type = typeof value;
+	if (type === "string" || type === "number" || type === "boolean") return value;
+	if (type === "bigint" || type === "function" || type === "symbol" || value === void 0) return NON_SERIALIZABLE_PLACEHOLDER;
+	if (Array.isArray(value)) {
+		if (seen.has(value)) return CIRCULAR_REFERENCE_PLACEHOLDER;
+		seen.add(value);
+		const sanitized = value.map((item) => sanitizeValue(item, seen));
+		seen.delete(value);
+		return sanitized;
+	}
+	if (value instanceof Date) return NON_SERIALIZABLE_PLACEHOLDER;
+	if (!isPlainObject(value)) return NON_SERIALIZABLE_PLACEHOLDER;
+	if (seen.has(value)) return CIRCULAR_REFERENCE_PLACEHOLDER;
+	seen.add(value);
+	const result = {};
+	for (const [key, val] of Object.entries(value)) result[key] = sanitizeValue(val, seen);
+	seen.delete(value);
+	return result;
+}
+/**
+* Ensures metadata is JSON-serializable.
+*
+* **Allowed:** string, number, boolean, null, arrays, and plain objects.
+*
+* **Converted to placeholder:** Date, BigInt, class instances, functions,
+* symbols, undefined, and circular references (which would otherwise make
+* `JSON.stringify` throw).
+*
+* @throws {TypeError} If `input` is not a plain object at the root level.
+*/
+function assertJsonSafeMetadata(input) {
+	if (input === void 0) return {};
+	if (!isPlainObject(input)) throw new TypeError("metadata must be a plain object (Record<string, unknown>).");
+	return sanitizeValue(input, /* @__PURE__ */ new WeakSet());
+}
+//#endregion
+//#region src/core/errors/app-error.ts
+/**
+* Root of the application/domain error hierarchy. Every error the system raises
+* on purpose extends `AppError`, which gives callers a single `instanceof` to
+* catch and a uniform, serializable shape to log and transport.
+*
+* Beyond the native `Error` message it carries a stable `code` (the contract the
+* outside world matches on), an optional non-leaking `publicMessage`, a
+* severity, JSON-safe `metadata`, and the correlation/request/command ids that
+* stitch an error back to the request that produced it. The metadata is
+* validated as JSON-safe on construction, so a logger can serialize any
+* `AppError` without hitting a circular reference or a non-serializable value.
+*
+* Abstract on purpose: callers should throw a specific subclass (e.g.
+* {@link ValidationError}, {@link NotFoundError}) so the `code` and shape are
+* meaningful, never a bare `AppError`.
+*/
+var AppError = class extends Error {
+	/**
+	* Builds the common error envelope shared by every subclass.
+	*
+	* `name` is taken from `new.target` so the thrown instance reports its
+	* concrete subclass name (not `"AppError"`), and the prototype is re-pinned
+	* via `setPrototypeOf` so `instanceof` keeps working after transpilation to
+	* older targets where extending built-ins breaks the chain. `createdAtIso`
+	* defaults to now, and `metadata` is validated as JSON-safe so the error is
+	* always serializable.
+	*
+	* Declared `protected`: instantiate a concrete subclass, never `AppError`.
+	*
+	* @param message - The internal, developer-facing message.
+	* @param code - The stable machine-readable code callers match on.
+	* @param options - Optional cause, metadata, severity, and correlation ids.
+	* @throws When `options.metadata` contains a value that is not JSON-safe.
+	*/
+	constructor(message, code, options) {
+		super(message);
+		this.name = new.target.name;
+		this.code = code;
+		this.cause = options?.cause;
+		this.type = options?.type;
+		this.severity = options?.severity;
+		this.correlationId = options?.correlationId;
+		this.requestId = options?.requestId;
+		this.commandId = options?.commandId;
+		this.createdAtIso = options?.createdAtIso ?? (/* @__PURE__ */ new Date()).toISOString();
+		this.publicMessage = options?.publicMessage;
+		this.metadata = options?.metadata ? assertJsonSafeMetadata(options.metadata) : void 0;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	/**
+	* Returns a JSON-safe representation of the error.
+	* Does NOT include `cause` by default (to avoid leaking internal details).
+	*/
+	toJSON() {
+		const payload = {
+			name: this.name,
+			code: this.code,
+			message: this.message,
+			createdAtIso: this.createdAtIso
+		};
+		if (this.type !== void 0) payload.type = this.type;
+		if (this.severity !== void 0) payload.severity = this.severity;
+		if (this.publicMessage !== void 0) payload.publicMessage = this.publicMessage;
+		if (this.metadata !== void 0) payload.metadata = this.metadata;
+		if (this.correlationId !== void 0) payload.correlationId = this.correlationId;
+		if (this.requestId !== void 0) payload.requestId = this.requestId;
+		if (this.commandId !== void 0) payload.commandId = this.commandId;
+		return payload;
+	}
+};
+//#endregion
+//#region src/core/errors/unexpected-error.ts
+var UnexpectedError = class extends AppError {
+	constructor(message = "Unexpected error", cause, options) {
+		super(message, ErrorCodes.unexpected, {
+			cause,
+			...options
+		});
+	}
+};
+//#endregion
+Object.defineProperty(exports, "AppError", {
+	enumerable: true,
+	get: function() {
+		return AppError;
+	}
+});
+Object.defineProperty(exports, "ErrorCodes", {
+	enumerable: true,
+	get: function() {
+		return ErrorCodes;
+	}
+});
+Object.defineProperty(exports, "UnexpectedError", {
+	enumerable: true,
+	get: function() {
+		return UnexpectedError;
+	}
+});
+Object.defineProperty(exports, "assertJsonSafeMetadata", {
+	enumerable: true,
+	get: function() {
+		return assertJsonSafeMetadata;
+	}
+});
+Object.defineProperty(exports, "serializationErrorCode", {
+	enumerable: true,
+	get: function() {
+		return serializationErrorCode;
+	}
+});
+
+//# sourceMappingURL=unexpected-error.cjs.map

package/dist/unexpected-error.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unexpected-error.cjs","names":[],"sources":["../src/core/errors/error-codes.ts","../src/core/errors/utils/json-safe.ts","../src/core/errors/app-error.ts","../src/core/errors/unexpected-error.ts"],"sourcesContent":["const ErrorCodes = {\n    authentication: {\n        missingToken: \"sec.authn.missing_token\",\n        invalidToken: \"sec.authn.invalid_token\",\n        expiredToken: \"sec.authn.expired_token\",\n        invalidCredentials: \"sec.authn.invalid_credentials\",\n    },\n    authorization: {\n        forbidden: \"sec.authz.forbidden\",\n        policyDenied: \"sec.authz.policy_denied\",\n        missingCapability: \"sec.authz.missing_capability\",\n        outOfScope: \"sec.authz.out_of_scope\",\n    },\n    businessRuleViolation: \"business_rule_violation\",\n    conflict: {\n        alreadyExists: \"conf.already_exists\",\n        duplicate: \"conf.duplicate\",\n        uniqueViolation: \"conf.unique_violation\",\n    },\n    idempotency: {\n        keyMissing: \"idemp.key_missing\",\n        inProgress: \"idemp.in_progress\",\n        payloadMismatch: \"idemp.payload_mismatch\",\n        replayNotSupported: \"idemp.replay_not_supported\",\n    },\n    integration: {\n        timeout: \"int.timeout\",\n        unreachable: \"int.unreachable\",\n        badResponse: \"int.bad_response\",\n    },\n    legacyIncompatible: \"legacy_incompatible\",\n    notFound: \"not_found\",\n    serialization: {\n        deserializePrefix: \"ser.des\",\n        serializePrefix: \"ser.ser\",\n    },\n    temporal: {\n        expired: \"tmp.expired\",\n        notYetValid: \"tmp.not_yet_valid\",\n    },\n    unexpected: \"unexpected\",\n    validation: \"validation_error\",\n} as const;\n\ntype SerializationCodeDirection = \"deserialize\" | \"serialize\";\n\nfunction serializationErrorCode(\n    direction: SerializationCodeDirection,\n    category: string,\n): string {\n    const prefix =\n        direction === \"deserialize\"\n            ? ErrorCodes.serialization.deserializePrefix\n            : ErrorCodes.serialization.serializePrefix;\n\n    return `${prefix}.${category}`;\n}\n\nexport { ErrorCodes, serializationErrorCode };\nexport type { SerializationCodeDirection };\n","// Utilities for ensuring metadata is JSON-serializable.\n\nimport type { JsonSafeRecord, JsonSafeValue } from \"../types.js\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Constants\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst NON_SERIALIZABLE_PLACEHOLDER = \"[NonSerializable]\";\nconst CIRCULAR_REFERENCE_PLACEHOLDER = \"[Circular]\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Internal helpers\n// ─────────────────────────────────────────────────────────────────────────────\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (value === null || typeof value !== \"object\") return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n// `seen` tracks the ancestors on the current traversal branch (a DFS path), not\n// every object visited. This collapses true circular references to a placeholder\n// while still serializing the same object referenced more than once across\n// sibling branches (a DAG) — matching `JSON.stringify`, which only rejects\n// cycles, not shared references.\nfunction sanitizeValue(value: unknown, seen: WeakSet<object>): JsonSafeValue {\n    // Null passthrough\n    if (value === null) return null;\n\n    const type = typeof value;\n\n    // Primitives\n    if (type === \"string\" || type === \"number\" || type === \"boolean\") {\n        return value as JsonSafeValue;\n    }\n\n    // Non-serializable primitives\n    if (\n        type === \"bigint\" ||\n        type === \"function\" ||\n        type === \"symbol\" ||\n        value === undefined\n    ) {\n        return NON_SERIALIZABLE_PLACEHOLDER;\n    }\n\n    // Arrays (recursive)\n    if (Array.isArray(value)) {\n        if (seen.has(value)) return CIRCULAR_REFERENCE_PLACEHOLDER;\n        seen.add(value);\n        const sanitized = value.map((item) => sanitizeValue(item, seen));\n        seen.delete(value);\n        return sanitized;\n    }\n\n    // Date → placeholder (could also use .toISOString() if preferred)\n    if (value instanceof Date) {\n        return NON_SERIALIZABLE_PLACEHOLDER;\n    }\n\n    // Class instances and non-plain objects → placeholder\n    if (!isPlainObject(value)) {\n        return NON_SERIALIZABLE_PLACEHOLDER;\n    }\n\n    // Plain object (recursive)\n    if (seen.has(value)) return CIRCULAR_REFERENCE_PLACEHOLDER;\n    seen.add(value);\n    const result: Record<string, JsonSafeValue> = {};\n    for (const [key, val] of Object.entries(value)) {\n        result[key] = sanitizeValue(val, seen);\n    }\n    seen.delete(value);\n    return result;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Public API\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Ensures metadata is JSON-serializable.\n *\n * **Allowed:** string, number, boolean, null, arrays, and plain objects.\n *\n * **Converted to placeholder:** Date, BigInt, class instances, functions,\n * symbols, undefined, and circular references (which would otherwise make\n * `JSON.stringify` throw).\n *\n * @throws {TypeError} If `input` is not a plain object at the root level.\n */\nfunction assertJsonSafeMetadata(input: unknown): JsonSafeRecord {\n    if (input === undefined) {\n        return {};\n    }\n\n    if (!isPlainObject(input)) {\n        throw new TypeError(\n            \"metadata must be a plain object (Record<string, unknown>).\",\n        );\n    }\n\n    return sanitizeValue(input, new WeakSet<object>()) as JsonSafeRecord;\n}\n\nexport {\n    assertJsonSafeMetadata,\n    CIRCULAR_REFERENCE_PLACEHOLDER,\n    NON_SERIALIZABLE_PLACEHOLDER,\n};\n","// Base application error for the domain/application layer.\n// Encapsulates a code, optional cause, and JSON-safe metadata.\n\nimport type {\n    AppErrorOptions,\n    ErrorSeverity,\n    JsonSafeRecord,\n} from \"./types.js\";\nimport { assertJsonSafeMetadata } from \"./utils/index.js\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// AppError (abstract base class)\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Root of the application/domain error hierarchy. Every error the system raises\n * on purpose extends `AppError`, which gives callers a single `instanceof` to\n * catch and a uniform, serializable shape to log and transport.\n *\n * Beyond the native `Error` message it carries a stable `code` (the contract the\n * outside world matches on), an optional non-leaking `publicMessage`, a\n * severity, JSON-safe `metadata`, and the correlation/request/command ids that\n * stitch an error back to the request that produced it. The metadata is\n * validated as JSON-safe on construction, so a logger can serialize any\n * `AppError` without hitting a circular reference or a non-serializable value.\n *\n * Abstract on purpose: callers should throw a specific subclass (e.g.\n * {@link ValidationError}, {@link NotFoundError}) so the `code` and shape are\n * meaningful, never a bare `AppError`.\n */\nabstract class AppError extends Error {\n    public readonly code: string;\n    public readonly cause?: unknown;\n    public readonly metadata?: JsonSafeRecord;\n    public readonly type?: string;\n    public readonly severity?: ErrorSeverity;\n    public readonly createdAtIso: string;\n    public readonly publicMessage?: string;\n    /**\n     * Identifies a single execution \"story\" in the system. All operations\n     * related to the same logical flow must share the same correlationId.\n     */\n    public readonly correlationId?: string;\n    /**\n     * Identifies a specific technical request attempt (each retry may produce\n     * a new requestId), even when the correlationId stays the same.\n     */\n    public readonly requestId?: string;\n    /**\n     * Marks the business intent / idempotency key; stays the same across\n     * technical retries and multiple requests that represent the same intent.\n     */\n    public readonly commandId?: string;\n\n    /**\n     * Builds the common error envelope shared by every subclass.\n     *\n     * `name` is taken from `new.target` so the thrown instance reports its\n     * concrete subclass name (not `\"AppError\"`), and the prototype is re-pinned\n     * via `setPrototypeOf` so `instanceof` keeps working after transpilation to\n     * older targets where extending built-ins breaks the chain. `createdAtIso`\n     * defaults to now, and `metadata` is validated as JSON-safe so the error is\n     * always serializable.\n     *\n     * Declared `protected`: instantiate a concrete subclass, never `AppError`.\n     *\n     * @param message - The internal, developer-facing message.\n     * @param code - The stable machine-readable code callers match on.\n     * @param options - Optional cause, metadata, severity, and correlation ids.\n     * @throws When `options.metadata` contains a value that is not JSON-safe.\n     */\n    protected constructor(\n        message: string,\n        code: string,\n        options?: AppErrorOptions,\n    ) {\n        super(message);\n\n        this.name = new.target.name;\n        this.code = code;\n        this.cause = options?.cause;\n        this.type = options?.type;\n        this.severity = options?.severity;\n        this.correlationId = options?.correlationId;\n        this.requestId = options?.requestId;\n        this.commandId = options?.commandId;\n        this.createdAtIso = options?.createdAtIso ?? new Date().toISOString();\n        this.publicMessage = options?.publicMessage;\n\n        this.metadata = options?.metadata\n            ? assertJsonSafeMetadata(options.metadata)\n            : undefined;\n\n        Object.setPrototypeOf(this, new.target.prototype);\n    }\n\n    /**\n     * Returns a JSON-safe representation of the error.\n     * Does NOT include `cause` by default (to avoid leaking internal details).\n     */\n    public toJSON(): Record<string, unknown> {\n        const payload: Record<string, unknown> = {\n            name: this.name,\n            code: this.code,\n            message: this.message,\n            createdAtIso: this.createdAtIso,\n        };\n\n        // Optional fields are emitted only when defined, so the serialized\n        // shape never carries `undefined`-valued keys (consistent with how the\n        // correlation/request/command ids are handled).\n        if (this.type !== undefined) payload.type = this.type;\n        if (this.severity !== undefined) payload.severity = this.severity;\n        if (this.publicMessage !== undefined)\n            payload.publicMessage = this.publicMessage;\n        if (this.metadata !== undefined) payload.metadata = this.metadata;\n        if (this.correlationId !== undefined)\n            payload.correlationId = this.correlationId;\n        if (this.requestId !== undefined) payload.requestId = this.requestId;\n        if (this.commandId !== undefined) payload.commandId = this.commandId;\n\n        return payload;\n    }\n}\n\nexport { AppError };\n","import { AppError } from \"./app-error.js\";\nimport { ErrorCodes } from \"./error-codes.js\";\nimport type { AppErrorOptions } from \"./types.js\";\n\n// ─────────────────────────────────────────────────────────────────────────────\n// UnexpectedError\n// ─────────────────────────────────────────────────────────────────────────────\n\nclass UnexpectedError extends AppError {\n    constructor(\n        message = \"Unexpected error\",\n        cause?: unknown,\n        options?: Omit<AppErrorOptions, \"cause\">,\n    ) {\n        super(message, ErrorCodes.unexpected, {\n            cause,\n            ...options,\n        });\n    }\n}\n\nexport { UnexpectedError };\n"],"mappings":"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"}

package/dist/use-case.cjs

@@ -0,0 +1,96 @@
+const require_immutable = require("./immutable.cjs");
+//#region src/core/application/use-case.ts
+var _UseCase;
+const EXECUTION_COUNTER = "use_case.executions";
+const DURATION_HISTOGRAM = "use_case.duration_ms";
+let UseCase = class UseCase {
+	static {
+		_UseCase = this;
+	}
+	get contractVersion() {
+		return _UseCase.CONTRACT_VERSION;
+	}
+	/**
+	* Runs the use case.
+	*
+	* `run()` is the single seam every use case crosses, so it is where
+	* cross-cutting instrumentation lives. When {@link observability} exposes
+	* any adapter, the call to `execute()` is wrapped with tracing, metrics and
+	* failure logging; otherwise it delegates directly with no overhead.
+	*
+	* Observability is strictly side-effecting: a misbehaving adapter never
+	* changes the business result nor masks a thrown error — its own failures
+	* are swallowed.
+	*/
+	async run(input) {
+		const observability = this.observability();
+		if (!observability.logger && !observability.metrics && !observability.tracer) return await this.execute(input);
+		return await this.runInstrumented(input, observability);
+	}
+	/**
+	* Adapters used to instrument {@link run}. Override to opt a use case into
+	* tracing/metrics/logging. Returns an empty object by default, which keeps
+	* the plain delegating behavior.
+	*/
+	observability() {
+		return {};
+	}
+	/**
+	* Stable identity used for span names and metric labels. Defaults to the
+	* runtime class name; override when bundling/minification would otherwise
+	* erase a meaningful name.
+	*/
+	get useCaseName() {
+		return this.constructor.name;
+	}
+	async runInstrumented(input, observability) {
+		const { logger, metrics, tracer } = observability;
+		const name = this.useCaseName;
+		const span = safely(() => tracer?.startSpan(name, { "use_case.name": name }));
+		const startedAt = Date.now();
+		try {
+			const output = await this.execute(input);
+			const outcome = output.isOk() ? "ok" : "error";
+			if (outcome === "error") safely(() => logger?.warn(`${name} returned a business error`, { useCase: name }));
+			safely(() => span?.setAttribute("use_case.outcome", outcome));
+			safely(() => metrics?.counter(EXECUTION_COUNTER, 1, {
+				useCase: name,
+				outcome
+			}));
+			return output;
+		} catch (error) {
+			safely(() => logger?.error(`${name} threw an unexpected error`, { useCase: name }));
+			safely(() => span?.setAttribute("use_case.outcome", "exception"));
+			safely(() => span?.recordException(error));
+			safely(() => metrics?.counter(EXECUTION_COUNTER, 1, {
+				useCase: name,
+				outcome: "exception"
+			}));
+			throw error;
+		} finally {
+			safely(() => metrics?.histogram(DURATION_HISTOGRAM, Date.now() - startedAt, { useCase: name }));
+			safely(() => span?.end());
+		}
+	}
+};
+UseCase = _UseCase = require_immutable.__decorate([require_immutable.version("1.0")], UseCase);
+/**
+* Invokes an observability side effect, isolating any adapter failure so it
+* cannot alter the use case outcome.
+*/
+function safely(effect) {
+	try {
+		return effect();
+	} catch {
+		return;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "UseCase", {
+	enumerable: true,
+	get: function() {
+		return UseCase;
+	}
+});
+
+//# sourceMappingURL=use-case.cjs.map

package/dist/use-case.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-case.cjs","names":["version"],"sources":["../src/core/application/use-case.ts"],"sourcesContent":["import { type ContractVersion, version } from \"../versioning/version.js\";\nimport type { Result } from \"../result/result.js\";\n\nimport type { LoggerPort } from \"./ports/logger.port.js\";\nimport type { MetricsPort } from \"./ports/metrics.port.js\";\nimport type { TracerPort } from \"./ports/tracer.port.js\";\n\ntype MaybePromise<T> = T | Promise<T>;\n\n/**\n * Observability adapters a use case may opt into.\n *\n * All fields are optional: a use case that provides none keeps the plain\n * `input → Result` behavior with zero overhead. When provided, {@link UseCase.run}\n * instruments every execution around `execute()` — opening a span, recording\n * duration, counting outcomes, and logging business/unexpected failures.\n */\ninterface UseCaseObservability {\n    readonly logger?: LoggerPort;\n    readonly metrics?: MetricsPort;\n    readonly tracer?: TracerPort;\n}\n\nconst EXECUTION_COUNTER = \"use_case.executions\";\nconst DURATION_HISTOGRAM = \"use_case.duration_ms\";\n\ntype ExecutionOutcome = \"ok\" | \"error\" | \"exception\";\n\n@version(\"1.0\")\nabstract class UseCase<\n    Input = void,\n    Output extends Result<unknown, unknown> = Result<void, never>,\n> {\n    declare public static readonly CONTRACT_VERSION: ContractVersion;\n\n    public get contractVersion(): ContractVersion {\n        return UseCase.CONTRACT_VERSION;\n    }\n\n    /**\n     * Runs the use case.\n     *\n     * `run()` is the single seam every use case crosses, so it is where\n     * cross-cutting instrumentation lives. When {@link observability} exposes\n     * any adapter, the call to `execute()` is wrapped with tracing, metrics and\n     * failure logging; otherwise it delegates directly with no overhead.\n     *\n     * Observability is strictly side-effecting: a misbehaving adapter never\n     * changes the business result nor masks a thrown error — its own failures\n     * are swallowed.\n     */\n    public async run(input: Input): Promise<Output> {\n        const observability = this.observability();\n        if (\n            !observability.logger &&\n            !observability.metrics &&\n            !observability.tracer\n        ) {\n            return await this.execute(input);\n        }\n\n        return await this.runInstrumented(input, observability);\n    }\n\n    /**\n     * Adapters used to instrument {@link run}. Override to opt a use case into\n     * tracing/metrics/logging. Returns an empty object by default, which keeps\n     * the plain delegating behavior.\n     */\n    protected observability(): UseCaseObservability {\n        return {};\n    }\n\n    /**\n     * Stable identity used for span names and metric labels. Defaults to the\n     * runtime class name; override when bundling/minification would otherwise\n     * erase a meaningful name.\n     */\n    protected get useCaseName(): string {\n        return this.constructor.name;\n    }\n\n    protected abstract execute(input: Input): MaybePromise<Output>;\n\n    private async runInstrumented(\n        input: Input,\n        observability: UseCaseObservability,\n    ): Promise<Output> {\n        const { logger, metrics, tracer } = observability;\n        const name = this.useCaseName;\n        const span = safely(() =>\n            tracer?.startSpan(name, { \"use_case.name\": name }),\n        );\n        const startedAt = Date.now();\n\n        try {\n            const output = await this.execute(input);\n            const outcome: ExecutionOutcome = output.isOk() ? \"ok\" : \"error\";\n\n            if (outcome === \"error\") {\n                safely(() =>\n                    logger?.warn(`${name} returned a business error`, {\n                        useCase: name,\n                    }),\n                );\n            }\n            safely(() => span?.setAttribute(\"use_case.outcome\", outcome));\n            safely(() =>\n                metrics?.counter(EXECUTION_COUNTER, 1, {\n                    useCase: name,\n                    outcome,\n                }),\n            );\n\n            return output;\n        } catch (error) {\n            safely(() =>\n                logger?.error(`${name} threw an unexpected error`, {\n                    useCase: name,\n                }),\n            );\n            safely(() => span?.setAttribute(\"use_case.outcome\", \"exception\"));\n            safely(() => span?.recordException(error));\n            safely(() =>\n                metrics?.counter(EXECUTION_COUNTER, 1, {\n                    useCase: name,\n                    outcome: \"exception\",\n                }),\n            );\n\n            throw error;\n        } finally {\n            safely(() =>\n                metrics?.histogram(DURATION_HISTOGRAM, Date.now() - startedAt, {\n                    useCase: name,\n                }),\n            );\n            safely(() => span?.end());\n        }\n    }\n}\n\n/**\n * Invokes an observability side effect, isolating any adapter failure so it\n * cannot alter the use case outcome.\n */\nfunction safely<R>(effect: () => R): R | undefined {\n    try {\n        return effect();\n    } catch {\n        return undefined;\n    }\n}\n\nexport { type MaybePromise, UseCase, type UseCaseObservability };\n"],"mappings":";;;AAuBA,MAAM,oBAAoB;AAC1B,MAAM,qBAAqB;AAI3B,IAAA,UAAA,MACe,QAGb;;;;CAGE,IAAW,kBAAmC;EAC1C,OAAA,SAAe;CACnB;;;;;;;;;;;;;CAcA,MAAa,IAAI,OAA+B;EAC5C,MAAM,gBAAgB,KAAK,cAAc;EACzC,IACI,CAAC,cAAc,UACf,CAAC,cAAc,WACf,CAAC,cAAc,QAEf,OAAO,MAAM,KAAK,QAAQ,KAAK;EAGnC,OAAO,MAAM,KAAK,gBAAgB,OAAO,aAAa;CAC1D;;;;;;CAOA,gBAAgD;EAC5C,OAAO,CAAC;CACZ;;;;;;CAOA,IAAc,cAAsB;EAChC,OAAO,KAAK,YAAY;CAC5B;CAIA,MAAc,gBACV,OACA,eACe;EACf,MAAM,EAAE,QAAQ,SAAS,WAAW;EACpC,MAAM,OAAO,KAAK;EAClB,MAAM,OAAO,aACT,QAAQ,UAAU,MAAM,EAAE,iBAAiB,KAAK,CAAC,CACrD;EACA,MAAM,YAAY,KAAK,IAAI;EAE3B,IAAI;GACA,MAAM,SAAS,MAAM,KAAK,QAAQ,KAAK;GACvC,MAAM,UAA4B,OAAO,KAAK,IAAI,OAAO;GAEzD,IAAI,YAAY,SACZ,aACI,QAAQ,KAAK,GAAG,KAAK,6BAA6B,EAC9C,SAAS,KACb,CAAC,CACL;GAEJ,aAAa,MAAM,aAAa,oBAAoB,OAAO,CAAC;GAC5D,aACI,SAAS,QAAQ,mBAAmB,GAAG;IACnC,SAAS;IACT;GACJ,CAAC,CACL;GAEA,OAAO;EACX,SAAS,OAAO;GACZ,aACI,QAAQ,MAAM,GAAG,KAAK,6BAA6B,EAC/C,SAAS,KACb,CAAC,CACL;GACA,aAAa,MAAM,aAAa,oBAAoB,WAAW,CAAC;GAChE,aAAa,MAAM,gBAAgB,KAAK,CAAC;GACzC,aACI,SAAS,QAAQ,mBAAmB,GAAG;IACnC,SAAS;IACT,SAAS;GACb,CAAC,CACL;GAEA,MAAM;EACV,UAAU;GACN,aACI,SAAS,UAAU,oBAAoB,KAAK,IAAI,IAAI,WAAW,EAC3D,SAAS,KACb,CAAC,CACL;GACA,aAAa,MAAM,IAAI,CAAC;EAC5B;CACJ;AACJ;mDAhHCA,kBAAAA,QAAQ,KAAK,CAAA,GAAA,OAAA;;;;;AAsHd,SAAS,OAAU,QAAgC;CAC/C,IAAI;EACA,OAAO,OAAO;CAClB,QAAQ;EACJ;CACJ;AACJ"}