@cullet/erp-core 1.1.0 → 1.3.0

package/KIT_CONTEXT.md

@@ -22,73 +22,7 @@ Núcleo arquitetural para sistemas ERP (e domínios transacionais com temporalid
 - **Policies como dados**, não como if-statements: avaliáveis, compostas, serializáveis.
 - **Policies permitem disable sem remover código**: `PolicyDefinition` aceita `enabled: false` e o repositório ignora definições desabilitadas.
 - **Composição isolada é de primeira classe**: use `new CoreConfig()`, `new ContextResolverRegistry()` e `registerNamespacedContextResolversIn(...)` quando precisar evitar singletons compartilhados.
-
-## [example] Exemplo end-to-end (Command + Repository + PolicyPort)
-
-Um `Command` carrega o agregado por um `ResultRepository`, consulta um
-`PolicyPort` (gate `ALLOW`/`DENY`) e persiste. Falhas recuperáveis voltam como
-`Result.err`, nunca como exceção.
-
-```ts
-class CancelOrder extends Command<
-    CancelOrderInput,
-    Result<Order, CancelOrderError>
-> {
-    constructor(
-        private readonly orders: ResultRepository<
-            Order,
-            string,
-            CancelOrderError
-        >,
-        private readonly policies: PolicyPort,
-    ) {
-        super();
-    }
-
-    protected async execute(input: CancelOrderInput) {
-        const found = await this.orders.findById(input.orderId);
-        if (found.isErr()) return found;
-        const order = found.getOrThrow();
-        if (!order)
-            return Result.err(
-                new NotFoundError("Order", { id: input.orderId }),
-            );
-
-        const evaluated = await this.policies.evaluate({
-            decisionId: asPolicyDecisionId(input.orderId),
-            policyKey: "order.cancel",
-            scopeChain: [],
-            contextVersion: 1,
-            seed: {
-                tenantId: asTenantId(input.tenantId),
-                schoolId: asSchoolId(input.schoolId),
-                fields: { orderStatus: order.status },
-            },
-        });
-        if (evaluated.isErr()) return evaluated;
-
-        const result = evaluated.getOrThrow();
-        if (result.kind === "GATE" && result.decision.status === "DENY") {
-            return Result.err(
-                AuthorizationError.policyDenied({
-                    action: "order.cancel",
-                    policyId: result.ref.definitionId,
-                    policyVersion: Number(result.ref.policyVersion),
-                    evaluatedAtIso: result.evaluatedAt.toISOString(),
-                }),
-            );
-        }
-
-        const saved = await this.orders.save({ ...order, status: "CANCELLED" });
-        if (saved.isErr()) return saved;
-        return Result.ok({ ...order, status: "CANCELLED" });
-    }
-}
-```
-
-- **Imports**: tudo do root `@cullet/erp-core`.
-- **`Repository` vs `ResultRepository`**: `Repository` (`save`/`delete` → `Promise<void>`) é o estilo imperativo; `ResultRepository` devolve `Result` para sinalizar not-found / concorrência otimista sem quebrar o fluxo.
-- **Referência compilada/testada**: `src/examples/application/cancel-order.example.ts` (+ `.spec.ts`).
+- **`Repository` vs `ResultRepository`**: `Repository` (`save`/`delete` → `Promise<void>`) é o estilo imperativo; `ResultRepository` devolve `Result` para sinalizar not-found / concorrência otimista sem quebrar o fluxo. Exemplo end-to-end (Command + ResultRepository + PolicyPort) compilado e testado em `src/examples/application/cancel-order.example.ts` (+ `.spec.ts`).
 
 ## [extension-points] Pontos de extensão
 

package/dist/app-error.d.cts

@@ -0,0 +1,108 @@
+//#region src/core/errors/types.d.ts
+type ErrorSeverity = "low" | "medium" | "high" | "critical";
+type JsonSafePrimitive = string | number | boolean | null;
+type JsonSafeValue = JsonSafePrimitive | JsonSafeValue[] | {
+  [key: string]: JsonSafeValue;
+};
+type JsonSafeRecord = Record<string, JsonSafeValue>;
+/**
+ * Options accepted by the AppError constructor.
+ * Subclasses can extend or pick from this type.
+ */
+type AppErrorOptions = {
+  /** Original error or exception that caused this error. */
+  cause?: unknown;
+  /** Arbitrary key-value metadata (will be sanitized to JSON-safe values). */
+  metadata?: Record<string, unknown>;
+  /** Error category/type for grouping (e.g., "authentication", "validation"). */
+  type?: string;
+  /** severity level for alerting/logging prioritization. */
+  severity?: ErrorSeverity;
+  /**
+   * Identifies a single execution "story" in the system. All operations
+   * related to the same logical flow must share the same correlationId.
+   */
+  correlationId?: string;
+  /**
+   * Identifies a specific technical request attempt (each retry may produce
+   * a new requestId), even when the correlationId stays the same.
+   */
+  requestId?: string;
+  /**
+   * Identifies a unique business intent (idempotency key); stays the same
+   * across technical retries and multiple requests that represent the same intent.
+   */
+  commandId?: string;
+  /** ISO timestamp of when the error was created (defaults to now). */
+  createdAtIso?: string;
+  /** Safe message that can be exposed to end users (no internal details). */
+  publicMessage?: string;
+};
+//#endregion
+//#region src/core/errors/app-error.d.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`.
+ */
+declare abstract class AppError extends Error {
+  readonly code: string;
+  readonly cause?: unknown;
+  readonly metadata?: JsonSafeRecord;
+  readonly type?: string;
+  readonly severity?: ErrorSeverity;
+  readonly createdAtIso: string;
+  readonly publicMessage?: string;
+  /**
+   * Identifies a single execution "story" in the system. All operations
+   * related to the same logical flow must share the same correlationId.
+   */
+  readonly correlationId?: string;
+  /**
+   * Identifies a specific technical request attempt (each retry may produce
+   * a new requestId), even when the correlationId stays the same.
+   */
+  readonly requestId?: string;
+  /**
+   * Marks the business intent / idempotency key; stays the same across
+   * technical retries and multiple requests that represent the same intent.
+   */
+  readonly commandId?: string;
+  /**
+   * 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.
+   */
+  protected constructor(message: string, code: string, options?: AppErrorOptions);
+  /**
+   * Returns a JSON-safe representation of the error.
+   * Does NOT include `cause` by default (to avoid leaking internal details).
+   */
+  toJSON(): Record<string, unknown>;
+}
+//#endregion
+export { JsonSafeRecord as a, JsonSafePrimitive as i, AppErrorOptions as n, JsonSafeValue as o, ErrorSeverity as r, AppError as t };
+//# sourceMappingURL=app-error.d.cts.map

package/dist/application/index.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_use_case = require("../use-case.cjs");
+const require_temporal_use_case = require("../temporal-use-case.cjs");
+Object.defineProperty(exports, "Command", {
+	enumerable: true,
+	get: function() {
+		return require_temporal_use_case.Command;
+	}
+});
+Object.defineProperty(exports, "Query", {
+	enumerable: true,
+	get: function() {
+		return require_temporal_use_case.Query;
+	}
+});
+exports.RequestedBy = require_temporal_use_case.RequestedBy;
+exports.TemporalUseCase = require_temporal_use_case.TemporalUseCase;
+Object.defineProperty(exports, "UseCase", {
+	enumerable: true,
+	get: function() {
+		return require_use_case.UseCase;
+	}
+});
+exports.assertTemporalContext = require_temporal_use_case.assertTemporalContext;
+exports.createTemporalContext = require_temporal_use_case.createTemporalContext;
+exports.mapPolicyEvaluationError = require_temporal_use_case.mapPolicyEvaluationError;

package/dist/application/index.d.cts

@@ -0,0 +1,2 @@
+import { A as MetricLabels, C as RequestedByKind, D as TraceAttributeValue, E as UseCaseObservability, M as LogPayload, N as LoggerPort, O as TraceSpan, S as RequestedBy, T as UseCase, _ as PolicyEvaluationOutput, a as TemporalContext, b as Command, c as CacheStrategy, d as mapPolicyEvaluationError, f as TemporalHistory, g as PolicyEvaluationInput, h as ResultRepository, i as CreateTemporalContextInput, j as MetricsPort, k as TracerPort, l as Page, m as Repository, n as TemporalUseCaseInput, o as assertTemporalContext, p as TemporalRepository, r as TemporalizedContextSeed, s as createTemporalContext, t as TemporalUseCase, u as Query, v as PolicyPort, w as MaybePromise, x as CommandInput, y as PolicyPortError } from "../temporal-use-case.cjs";
+export { CacheStrategy, Command, CommandInput, CreateTemporalContextInput, LogPayload, LoggerPort, MaybePromise, MetricLabels, MetricsPort, Page, PolicyEvaluationInput, PolicyEvaluationOutput, PolicyPort, PolicyPortError, Query, Repository, RequestedBy, RequestedByKind, ResultRepository, TemporalContext, TemporalHistory, TemporalRepository, TemporalUseCase, TemporalUseCaseInput, TemporalizedContextSeed, TraceAttributeValue, TraceSpan, TracerPort, UseCase, UseCaseObservability, assertTemporalContext, createTemporalContext, mapPolicyEvaluationError };

package/dist/application/index.d.ts

@@ -1,2 +1,2 @@
-import { A as TracerPort, C as RequestedBy, D as UseCaseObservability, E as UseCase, M as MetricsPort, N as LogPayload, O as TraceAttributeValue, P as LoggerPort, S as CommandInput, T as MaybePromise, _ as PolicyEvaluationInput, a as TemporalContext, b as PolicyPortError, c as CacheStrategy, d as mapPolicyEvaluationError, f as TemporalHistory, g as ResultRepository, h as Repository, i as CreateTemporalContextInput, j as MetricLabels, k as TraceSpan, l as Page, n as TemporalUseCaseInput, o as assertTemporalContext, p as TemporalRepository, r as TemporalizedContextSeed, s as createTemporalContext, t as TemporalUseCase, u as Query, v as PolicyEvaluationOutput, w as RequestedByKind, x as Command, y as PolicyPort } from "../temporal-use-case.js";
+import { A as MetricLabels, C as RequestedByKind, D as TraceAttributeValue, E as UseCaseObservability, M as LogPayload, N as LoggerPort, O as TraceSpan, S as RequestedBy, T as UseCase, _ as PolicyEvaluationOutput, a as TemporalContext, b as Command, c as CacheStrategy, d as mapPolicyEvaluationError, f as TemporalHistory, g as PolicyEvaluationInput, h as ResultRepository, i as CreateTemporalContextInput, j as MetricsPort, k as TracerPort, l as Page, m as Repository, n as TemporalUseCaseInput, o as assertTemporalContext, p as TemporalRepository, r as TemporalizedContextSeed, s as createTemporalContext, t as TemporalUseCase, u as Query, v as PolicyPort, w as MaybePromise, x as CommandInput, y as PolicyPortError } from "../temporal-use-case.js";
 export { CacheStrategy, Command, CommandInput, CreateTemporalContextInput, LogPayload, LoggerPort, MaybePromise, MetricLabels, MetricsPort, Page, PolicyEvaluationInput, PolicyEvaluationOutput, PolicyPort, PolicyPortError, Query, Repository, RequestedBy, RequestedByKind, ResultRepository, TemporalContext, TemporalHistory, TemporalRepository, TemporalUseCase, TemporalUseCaseInput, TemporalizedContextSeed, TraceAttributeValue, TraceSpan, TracerPort, UseCase, UseCaseObservability, assertTemporalContext, createTemporalContext, mapPolicyEvaluationError };

package/dist/application/index.js

@@ -1,2 +1,3 @@
-import { a as Query, c as RequestedBy, l as UseCase, n as assertTemporalContext, o as mapPolicyEvaluationError, r as createTemporalContext, s as Command, t as TemporalUseCase } from "../temporal-use-case.js";
+import { t as UseCase } from "../use-case.js";
+import { a as mapPolicyEvaluationError, i as Query, n as assertTemporalContext, o as Command, r as createTemporalContext, s as RequestedBy, t as TemporalUseCase } from "../temporal-use-case.js";
 export { Command, Query, RequestedBy, TemporalUseCase, UseCase, assertTemporalContext, createTemporalContext, mapPolicyEvaluationError };

package/dist/domain/index.cjs

@@ -0,0 +1,16 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_value_object = require("../value-object.cjs");
+const require_uuid_identifier = require("../uuid-identifier.cjs");
+Object.defineProperty(exports, "Entity", {
+	enumerable: true,
+	get: function() {
+		return require_value_object.Entity;
+	}
+});
+exports.UuidIdentifier = require_uuid_identifier.UuidIdentifier;
+Object.defineProperty(exports, "ValueObject", {
+	enumerable: true,
+	get: function() {
+		return require_value_object.ValueObject;
+	}
+});

package/dist/domain/index.d.cts

@@ -0,0 +1,3 @@
+import { t as DeepReadonly } from "../immutable.cjs";
+import { a as EntityState, i as Entity, n as ValueObject, r as ValueObjectPluginContract, t as UuidIdentifier } from "../uuid-identifier.cjs";
+export { type DeepReadonly, Entity, type EntityState, UuidIdentifier, ValueObject, type ValueObjectPluginContract };

package/dist/domain/index.d.ts

@@ -0,0 +1,3 @@
+import { t as DeepReadonly } from "../immutable.js";
+import { a as EntityState, i as Entity, n as ValueObject, r as ValueObjectPluginContract, t as UuidIdentifier } from "../uuid-identifier.js";
+export { type DeepReadonly, Entity, type EntityState, UuidIdentifier, ValueObject, type ValueObjectPluginContract };

package/dist/domain/index.js

@@ -0,0 +1,3 @@
+import { n as Entity, t as ValueObject } from "../value-object.js";
+import { t as UuidIdentifier } from "../uuid-identifier.js";
+export { Entity, UuidIdentifier, ValueObject };

package/dist/domain-event-contracts.cjs

@@ -0,0 +1,33 @@
+const require_use_case = require("./use-case.cjs");
+const require_value_object = require("./value-object.cjs");
+//#region src/core/versioning/domain-event-contracts.ts
+function buildDomainEventContractVersions(selection) {
+	const contractVersions = {};
+	if (selection.entity) contractVersions.entity_contract = require_value_object.Entity.CONTRACT_VERSION;
+	if (selection.valueObject) contractVersions.value_object_contract = require_value_object.ValueObject.CONTRACT_VERSION;
+	if (selection.useCase) contractVersions.use_case_contract = require_use_case.UseCase.CONTRACT_VERSION;
+	return Object.freeze(contractVersions);
+}
+function createDomainEventEnvelope(input) {
+	require_value_object.assertValidAggregateVersion(input.aggregateVersion);
+	return Object.freeze({
+		aggregate_version: input.aggregateVersion,
+		payload: input.payload,
+		...buildDomainEventContractVersions(input.contracts)
+	});
+}
+//#endregion
+Object.defineProperty(exports, "buildDomainEventContractVersions", {
+	enumerable: true,
+	get: function() {
+		return buildDomainEventContractVersions;
+	}
+});
+Object.defineProperty(exports, "createDomainEventEnvelope", {
+	enumerable: true,
+	get: function() {
+		return createDomainEventEnvelope;
+	}
+});
+
+//# sourceMappingURL=domain-event-contracts.cjs.map

package/dist/domain-event-contracts.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event-contracts.cjs","names":["Entity","ValueObject","UseCase"],"sources":["../src/core/versioning/domain-event-contracts.ts"],"sourcesContent":["import { UseCase } from \"../application/use-case.js\";\nimport { Entity } from \"../domain/entity.js\";\nimport { ValueObject } from \"../domain/value-object.js\";\nimport { assertValidAggregateVersion } from \"../shared/aggregate-version.js\";\nimport { type ContractVersion } from \"./version.js\";\n\ninterface DomainEventContractSelection {\n    readonly entity?: boolean;\n    readonly valueObject?: boolean;\n    readonly useCase?: boolean;\n}\n\ninterface DomainEventContractVersions {\n    readonly entity_contract?: ContractVersion;\n    readonly value_object_contract?: ContractVersion;\n    readonly use_case_contract?: ContractVersion;\n}\n\ninterface CreateDomainEventEnvelopeInput<TPayload> {\n    readonly aggregateVersion: number;\n    readonly payload: TPayload;\n    readonly contracts: DomainEventContractSelection;\n}\n\ninterface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {\n    readonly aggregate_version: number;\n    readonly payload: TPayload;\n}\n\nfunction buildDomainEventContractVersions(\n    selection: DomainEventContractSelection,\n): DomainEventContractVersions {\n    const contractVersions: {\n        entity_contract?: ContractVersion;\n        value_object_contract?: ContractVersion;\n        use_case_contract?: ContractVersion;\n    } = {};\n\n    if (selection.entity) {\n        contractVersions.entity_contract = Entity.CONTRACT_VERSION;\n    }\n\n    if (selection.valueObject) {\n        contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;\n    }\n\n    if (selection.useCase) {\n        contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;\n    }\n\n    return Object.freeze(contractVersions);\n}\n\nfunction createDomainEventEnvelope<TPayload>(\n    input: CreateDomainEventEnvelopeInput<TPayload>,\n): DomainEventEnvelope<TPayload> {\n    assertValidAggregateVersion(input.aggregateVersion);\n\n    return Object.freeze({\n        aggregate_version: input.aggregateVersion,\n        payload: input.payload,\n        ...buildDomainEventContractVersions(input.contracts),\n    });\n}\n\nexport {\n    buildDomainEventContractVersions,\n    createDomainEventEnvelope,\n    type CreateDomainEventEnvelopeInput,\n    type DomainEventContractSelection,\n    type DomainEventContractVersions,\n    type DomainEventEnvelope,\n};\n"],"mappings":";;;AA6BA,SAAS,iCACL,WAC2B;CAC3B,MAAM,mBAIF,CAAC;CAEL,IAAI,UAAU,QACV,iBAAiB,kBAAkBA,qBAAAA,OAAO;CAG9C,IAAI,UAAU,aACV,iBAAiB,wBAAwBC,qBAAAA,YAAY;CAGzD,IAAI,UAAU,SACV,iBAAiB,oBAAoBC,iBAAAA,QAAQ;CAGjD,OAAO,OAAO,OAAO,gBAAgB;AACzC;AAEA,SAAS,0BACL,OAC6B;CAC7B,qBAAA,4BAA4B,MAAM,gBAAgB;CAElD,OAAO,OAAO,OAAO;EACjB,mBAAmB,MAAM;EACzB,SAAS,MAAM;EACf,GAAG,iCAAiC,MAAM,SAAS;CACvD,CAAC;AACL"}

package/dist/domain-event-contracts.d.cts

@@ -0,0 +1,27 @@
+import { n as ContractVersion } from "./version.cjs";
+
+//#region src/core/versioning/domain-event-contracts.d.ts
+interface DomainEventContractSelection {
+  readonly entity?: boolean;
+  readonly valueObject?: boolean;
+  readonly useCase?: boolean;
+}
+interface DomainEventContractVersions {
+  readonly entity_contract?: ContractVersion;
+  readonly value_object_contract?: ContractVersion;
+  readonly use_case_contract?: ContractVersion;
+}
+interface CreateDomainEventEnvelopeInput<TPayload> {
+  readonly aggregateVersion: number;
+  readonly payload: TPayload;
+  readonly contracts: DomainEventContractSelection;
+}
+interface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {
+  readonly aggregate_version: number;
+  readonly payload: TPayload;
+}
+declare function buildDomainEventContractVersions(selection: DomainEventContractSelection): DomainEventContractVersions;
+declare function createDomainEventEnvelope<TPayload>(input: CreateDomainEventEnvelopeInput<TPayload>): DomainEventEnvelope<TPayload>;
+//#endregion
+export { buildDomainEventContractVersions as a, DomainEventEnvelope as i, DomainEventContractSelection as n, createDomainEventEnvelope as o, DomainEventContractVersions as r, CreateDomainEventEnvelopeInput as t };
+//# sourceMappingURL=domain-event-contracts.d.cts.map

package/dist/domain-event-contracts.d.ts

@@ -0,0 +1,27 @@
+import { n as ContractVersion } from "./version.js";
+
+//#region src/core/versioning/domain-event-contracts.d.ts
+interface DomainEventContractSelection {
+  readonly entity?: boolean;
+  readonly valueObject?: boolean;
+  readonly useCase?: boolean;
+}
+interface DomainEventContractVersions {
+  readonly entity_contract?: ContractVersion;
+  readonly value_object_contract?: ContractVersion;
+  readonly use_case_contract?: ContractVersion;
+}
+interface CreateDomainEventEnvelopeInput<TPayload> {
+  readonly aggregateVersion: number;
+  readonly payload: TPayload;
+  readonly contracts: DomainEventContractSelection;
+}
+interface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {
+  readonly aggregate_version: number;
+  readonly payload: TPayload;
+}
+declare function buildDomainEventContractVersions(selection: DomainEventContractSelection): DomainEventContractVersions;
+declare function createDomainEventEnvelope<TPayload>(input: CreateDomainEventEnvelopeInput<TPayload>): DomainEventEnvelope<TPayload>;
+//#endregion
+export { buildDomainEventContractVersions as a, DomainEventEnvelope as i, DomainEventContractSelection as n, createDomainEventEnvelope as o, DomainEventContractVersions as r, CreateDomainEventEnvelopeInput as t };
+//# sourceMappingURL=domain-event-contracts.d.ts.map

package/dist/domain-event-contracts.js

@@ -0,0 +1,22 @@
+import { t as UseCase } from "./use-case.js";
+import { n as Entity, r as assertValidAggregateVersion, t as ValueObject } from "./value-object.js";
+//#region src/core/versioning/domain-event-contracts.ts
+function buildDomainEventContractVersions(selection) {
+	const contractVersions = {};
+	if (selection.entity) contractVersions.entity_contract = Entity.CONTRACT_VERSION;
+	if (selection.valueObject) contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;
+	if (selection.useCase) contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;
+	return Object.freeze(contractVersions);
+}
+function createDomainEventEnvelope(input) {
+	assertValidAggregateVersion(input.aggregateVersion);
+	return Object.freeze({
+		aggregate_version: input.aggregateVersion,
+		payload: input.payload,
+		...buildDomainEventContractVersions(input.contracts)
+	});
+}
+//#endregion
+export { createDomainEventEnvelope as n, buildDomainEventContractVersions as t };
+
+//# sourceMappingURL=domain-event-contracts.js.map

package/dist/domain-event-contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event-contracts.js","names":[],"sources":["../src/core/versioning/domain-event-contracts.ts"],"sourcesContent":["import { UseCase } from \"../application/use-case.js\";\nimport { Entity } from \"../domain/entity.js\";\nimport { ValueObject } from \"../domain/value-object.js\";\nimport { assertValidAggregateVersion } from \"../shared/aggregate-version.js\";\nimport { type ContractVersion } from \"./version.js\";\n\ninterface DomainEventContractSelection {\n    readonly entity?: boolean;\n    readonly valueObject?: boolean;\n    readonly useCase?: boolean;\n}\n\ninterface DomainEventContractVersions {\n    readonly entity_contract?: ContractVersion;\n    readonly value_object_contract?: ContractVersion;\n    readonly use_case_contract?: ContractVersion;\n}\n\ninterface CreateDomainEventEnvelopeInput<TPayload> {\n    readonly aggregateVersion: number;\n    readonly payload: TPayload;\n    readonly contracts: DomainEventContractSelection;\n}\n\ninterface DomainEventEnvelope<TPayload> extends DomainEventContractVersions {\n    readonly aggregate_version: number;\n    readonly payload: TPayload;\n}\n\nfunction buildDomainEventContractVersions(\n    selection: DomainEventContractSelection,\n): DomainEventContractVersions {\n    const contractVersions: {\n        entity_contract?: ContractVersion;\n        value_object_contract?: ContractVersion;\n        use_case_contract?: ContractVersion;\n    } = {};\n\n    if (selection.entity) {\n        contractVersions.entity_contract = Entity.CONTRACT_VERSION;\n    }\n\n    if (selection.valueObject) {\n        contractVersions.value_object_contract = ValueObject.CONTRACT_VERSION;\n    }\n\n    if (selection.useCase) {\n        contractVersions.use_case_contract = UseCase.CONTRACT_VERSION;\n    }\n\n    return Object.freeze(contractVersions);\n}\n\nfunction createDomainEventEnvelope<TPayload>(\n    input: CreateDomainEventEnvelopeInput<TPayload>,\n): DomainEventEnvelope<TPayload> {\n    assertValidAggregateVersion(input.aggregateVersion);\n\n    return Object.freeze({\n        aggregate_version: input.aggregateVersion,\n        payload: input.payload,\n        ...buildDomainEventContractVersions(input.contracts),\n    });\n}\n\nexport {\n    buildDomainEventContractVersions,\n    createDomainEventEnvelope,\n    type CreateDomainEventEnvelopeInput,\n    type DomainEventContractSelection,\n    type DomainEventContractVersions,\n    type DomainEventEnvelope,\n};\n"],"mappings":";;;AA6BA,SAAS,iCACL,WAC2B;CAC3B,MAAM,mBAIF,CAAC;CAEL,IAAI,UAAU,QACV,iBAAiB,kBAAkB,OAAO;CAG9C,IAAI,UAAU,aACV,iBAAiB,wBAAwB,YAAY;CAGzD,IAAI,UAAU,SACV,iBAAiB,oBAAoB,QAAQ;CAGjD,OAAO,OAAO,OAAO,gBAAgB;AACzC;AAEA,SAAS,0BACL,OAC6B;CAC7B,4BAA4B,MAAM,gBAAgB;CAElD,OAAO,OAAO,OAAO;EACjB,mBAAmB,MAAM;EACzB,SAAS,MAAM;EACf,GAAG,iCAAiC,MAAM,SAAS;CACvD,CAAC;AACL"}

package/dist/domain-exception.cjs

@@ -0,0 +1,17 @@
+//#region src/core/exceptions/domain-exception.ts
+var DomainException = class extends Error {
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.name = new.target.name;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "DomainException", {
+	enumerable: true,
+	get: function() {
+		return DomainException;
+	}
+});
+
+//# sourceMappingURL=domain-exception.cjs.map

package/dist/domain-exception.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-exception.cjs","names":[],"sources":["../src/core/exceptions/domain-exception.ts"],"sourcesContent":["abstract class DomainException extends Error {\n    constructor(message: string) {\n        super(message);\n        Object.setPrototypeOf(this, new.target.prototype);\n        this.name = new.target.name;\n    }\n}\n\nexport { DomainException };\n"],"mappings":";AAAA,IAAe,kBAAf,cAAuC,MAAM;CACzC,YAAY,SAAiB;EACzB,MAAM,OAAO;EACb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAChD,KAAK,OAAO,IAAI,OAAO;CAC3B;AACJ"}

package/dist/domain-exception.d.cts

@@ -0,0 +1,7 @@
+//#region src/core/exceptions/domain-exception.d.ts
+declare abstract class DomainException extends Error {
+  constructor(message: string);
+}
+//#endregion
+export { DomainException as t };
+//# sourceMappingURL=domain-exception.d.cts.map

package/dist/domain-exception.d.ts

@@ -0,0 +1,7 @@
+//#region src/core/exceptions/domain-exception.d.ts
+declare abstract class DomainException extends Error {
+  constructor(message: string);
+}
+//#endregion
+export { DomainException as t };
+//# sourceMappingURL=domain-exception.d.ts.map

package/dist/domain-exception.js

@@ -0,0 +1,12 @@
+//#region src/core/exceptions/domain-exception.ts
+var DomainException = class extends Error {
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.name = new.target.name;
+	}
+};
+//#endregion
+export { DomainException as t };
+
+//# sourceMappingURL=domain-exception.js.map

package/dist/domain-exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-exception.js","names":[],"sources":["../src/core/exceptions/domain-exception.ts"],"sourcesContent":["abstract class DomainException extends Error {\n    constructor(message: string) {\n        super(message);\n        Object.setPrototypeOf(this, new.target.prototype);\n        this.name = new.target.name;\n    }\n}\n\nexport { DomainException };\n"],"mappings":";AAAA,IAAe,kBAAf,cAAuC,MAAM;CACzC,YAAY,SAAiB;EACzB,MAAM,OAAO;EACb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAChD,KAAK,OAAO,IAAI,OAAO;CAC3B;AACJ"}

package/dist/errors/index.cjs

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_unexpected_error = require("../unexpected-error.cjs");
+const require_validation_error = require("../validation-error.cjs");
+const require_not_found_error = require("../not-found-error.cjs");
+const require_hashing = require("../hashing.cjs");
+exports.AlreadyExistsError = require_validation_error.AlreadyExistsError;
+exports.AppError = require_unexpected_error.AppError;
+exports.AuthenticationError = require_validation_error.AuthenticationError;
+exports.AuthorizationError = require_validation_error.AuthorizationError;
+exports.BusinessRuleViolationError = require_not_found_error.BusinessRuleViolationError;
+exports.ConflictError = require_validation_error.ConflictError;
+exports.DeserializationError = require_validation_error.SerializationInError;
+exports.DuplicateError = require_validation_error.DuplicateError;
+exports.ErrorCodes = require_unexpected_error.ErrorCodes;
+exports.ExpiredError = require_validation_error.ExpiredError;
+exports.IdempotencyError = require_validation_error.IdempotencyError;
+exports.IdempotencyInProgressError = require_validation_error.IdempotencyInProgressError;
+exports.IdempotencyKeyMissingError = require_validation_error.IdempotencyKeyMissingError;
+exports.IdempotencyPayloadMismatchError = require_validation_error.IdempotencyPayloadMismatchError;
+exports.IdempotencyReplayNotSupportedError = require_validation_error.IdempotencyReplayNotSupportedError;
+exports.IntegrationError = require_validation_error.IntegrationError;
+exports.LegacyIncompatibleError = require_validation_error.LegacyIncompatibleError;
+exports.NotFoundError = require_not_found_error.NotFoundError;
+exports.NotYetValidError = require_validation_error.NotYetValidError;
+exports.SerializationCodes = require_validation_error.SerializationCodes;
+exports.SerializationError = require_validation_error.SerializationError;
+exports.SerializationInError = require_validation_error.SerializationInError;
+exports.SerializationMessages = require_validation_error.SerializationMessages;
+exports.SerializationOutError = require_validation_error.SerializationOutError;
+exports.TemporalError = require_validation_error.TemporalError;
+exports.UnexpectedError = require_unexpected_error.UnexpectedError;
+exports.UniqueConstraintViolationError = require_validation_error.UniqueConstraintViolationError;
+exports.ValidationError = require_validation_error.ValidationError;
+exports.assertJsonSafeMetadata = require_unexpected_error.assertJsonSafeMetadata;
+exports.evaluateTemporalWindow = require_validation_error.evaluateTemporalWindow;
+exports.payloadHash = require_hashing.payloadHash;
+exports.safePreview = require_validation_error.safePreview;
+exports.serializationErrorCode = require_unexpected_error.serializationErrorCode;
+exports.sha256Hex = require_hashing.sha256Hex;
+exports.stableStringify = require_hashing.stableStringify;
+exports.translateUniqueViolationToDuplicate = require_validation_error.translateUniqueViolationToDuplicate;

package/dist/errors/index.d.cts

@@ -0,0 +1,3 @@
+import { a as JsonSafeRecord, i as JsonSafePrimitive, n as AppErrorOptions, o as JsonSafeValue, r as ErrorSeverity, t as AppError } from "../app-error.cjs";
+import { $ as serializationErrorCode, A as IdempotencyPayloadMismatchError, B as UniqueConstraintViolation, C as IntegrationErrorMetadata, D as IdempotencyFailureKind, E as IdempotencyErrorMetadata, F as AlreadyExistsError, G as AuthorizationErrorMetadata, H as translateUniqueViolationToDuplicate, I as ConflictError, J as AuthenticationError, K as AuthorizationErrorReason, L as ConflictErrorMetadata, M as payloadHash, N as sha256Hex, O as IdempotencyInProgressError, P as stableStringify, Q as ErrorCodes, R as ConflictKind, S as IntegrationError, T as IdempotencyError, U as BusinessRuleViolationError, V as UniqueConstraintViolationError, W as AuthorizationError, X as AuthenticationErrorReason, Y as AuthenticationErrorMetadata, Z as assertJsonSafeMetadata, _ as SerializationMessages, a as TemporalError, b as NotFoundError, c as TemporalPrecision, d as SerializationCodes, f as SerializationDirection, g as SerializationInError, h as SerializationFailureCategory, i as NotYetValidError, j as IdempotencyReplayNotSupportedError, k as IdempotencyKeyMissingError, l as evaluateTemporalWindow, m as SerializationErrorMetadata, n as UnexpectedError, o as TemporalErrorMetadata, p as SerializationError, q as AuthorizationRequirement, r as ExpiredError, s as TemporalKind, t as ValidationError, u as SerializationBoundary, v as SerializationOutError, w as IntegrationErrorReason, x as LegacyIncompatibleError, y as safePreview, z as DuplicateError } from "../validation-error.cjs";
+export { AlreadyExistsError, AppError, AppErrorOptions, AuthenticationError, AuthenticationErrorMetadata, AuthenticationErrorReason, AuthorizationError, AuthorizationErrorMetadata, AuthorizationErrorReason, AuthorizationRequirement, BusinessRuleViolationError, ConflictError, ConflictErrorMetadata, ConflictKind, SerializationInError as DeserializationError, SerializationInError, DuplicateError, ErrorCodes, ErrorSeverity, ExpiredError, TemporalErrorMetadata as ExpiredErrorMetadata, TemporalErrorMetadata, TemporalPrecision as ExpiredErrorPrecision, TemporalPrecision, IdempotencyError, IdempotencyErrorMetadata, IdempotencyFailureKind, IdempotencyInProgressError, IdempotencyKeyMissingError, IdempotencyPayloadMismatchError, IdempotencyReplayNotSupportedError, IntegrationError, IntegrationErrorMetadata, IntegrationErrorReason, JsonSafePrimitive, JsonSafeRecord, JsonSafeValue, LegacyIncompatibleError, NotFoundError, NotYetValidError, SerializationBoundary, SerializationCodes, SerializationDirection, SerializationError, SerializationErrorMetadata, SerializationFailureCategory, SerializationMessages, SerializationOutError, TemporalError, TemporalKind, UnexpectedError, UniqueConstraintViolation, UniqueConstraintViolationError, ValidationError, assertJsonSafeMetadata, evaluateTemporalWindow, payloadHash, safePreview, serializationErrorCode, sha256Hex, stableStringify, translateUniqueViolationToDuplicate };

package/dist/errors/index.js

@@ -1,4 +1,4 @@
-import { a as ErrorCodes, i as assertJsonSafeMetadata, n as UnexpectedError, o as serializationErrorCode, r as AppError } from "../validation-code.js";
+import { a as serializationErrorCode, i as ErrorCodes, n as AppError, r as assertJsonSafeMetadata, t as UnexpectedError } from "../unexpected-error.js";
 import { C as translateUniqueViolationToDuplicate, S as UniqueConstraintViolationError, T as AuthenticationError, _ as IdempotencyPayloadMismatchError, a as evaluateTemporalWindow, b as ConflictError, c as SerializationInError, d as safePreview, f as LegacyIncompatibleError, g as IdempotencyKeyMissingError, h as IdempotencyInProgressError, i as TemporalError, l as SerializationMessages, m as IdempotencyError, n as ExpiredError, o as SerializationCodes, p as IntegrationError, r as NotYetValidError, s as SerializationError, t as ValidationError, u as SerializationOutError, v as IdempotencyReplayNotSupportedError, w as AuthorizationError, x as DuplicateError, y as AlreadyExistsError } from "../validation-error.js";
 import { n as BusinessRuleViolationError, t as NotFoundError } from "../not-found-error.js";
 import { n as sha256Hex, r as stableStringify, t as payloadHash } from "../hashing.js";

package/dist/exceptions/index.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_validation_code = require("../validation-code.cjs");
+const require_validation_field = require("../validation-field.cjs");
+const require_domain_exception = require("../domain-exception.cjs");
+const require_invalid_state_transition_exception = require("../invalid-state-transition-exception.cjs");
+const require_invariant_violation_exception = require("../invariant-violation-exception.cjs");
+const require_validation_exception = require("../validation-exception.cjs");
+exports.BusinessRuleViolationException = require_invalid_state_transition_exception.BusinessRuleViolationException;
+exports.DomainException = require_domain_exception.DomainException;
+exports.EntityNotFoundException = require_invalid_state_transition_exception.EntityNotFoundException;
+exports.InvalidStateTransitionException = require_invalid_state_transition_exception.InvalidStateTransitionException;
+exports.InvalidValueException = require_validation_exception.InvalidValueException;
+exports.InvariantViolationException = require_invariant_violation_exception.InvariantViolationException;
+exports.MultipleValidationException = require_validation_exception.MultipleValidationException;
+exports.ValidationCode = require_validation_code.ValidationCode;
+exports.ValidationException = require_validation_exception.ValidationException;
+exports.ValidationField = require_validation_field.ValidationField;

package/dist/exceptions/index.d.cts

@@ -0,0 +1,5 @@
+import { t as ValidationCode } from "../validation-code.cjs";
+import { t as ValidationField } from "../validation-field.cjs";
+import { t as DomainException } from "../domain-exception.cjs";
+import { a as InvariantViolationException, c as BusinessRuleViolationException, i as ValidationViolation, n as MultipleValidationException, o as InvalidStateTransitionException, r as ValidationException, s as EntityNotFoundException, t as InvalidValueException } from "../validation-exception.cjs";
+export { BusinessRuleViolationException, DomainException, EntityNotFoundException, InvalidStateTransitionException, InvalidValueException, InvariantViolationException, MultipleValidationException, ValidationCode, ValidationException, ValidationField, ValidationViolation };

package/dist/exceptions/index.d.ts

@@ -0,0 +1,5 @@
+import { t as ValidationCode } from "../validation-code.js";
+import { t as ValidationField } from "../validation-field.js";
+import { t as DomainException } from "../domain-exception.js";
+import { a as InvariantViolationException, c as BusinessRuleViolationException, i as ValidationViolation, n as MultipleValidationException, o as InvalidStateTransitionException, r as ValidationException, s as EntityNotFoundException, t as InvalidValueException } from "../validation-exception.js";
+export { BusinessRuleViolationException, DomainException, EntityNotFoundException, InvalidStateTransitionException, InvalidValueException, InvariantViolationException, MultipleValidationException, ValidationCode, ValidationException, ValidationField, ValidationViolation };

package/dist/exceptions/index.js

@@ -0,0 +1,7 @@
+import { t as ValidationCode } from "../validation-code.js";
+import { t as ValidationField } from "../validation-field.js";
+import { t as DomainException } from "../domain-exception.js";
+import { n as EntityNotFoundException, r as BusinessRuleViolationException, t as InvalidStateTransitionException } from "../invalid-state-transition-exception.js";
+import { t as InvariantViolationException } from "../invariant-violation-exception.js";
+import { n as MultipleValidationException, r as ValidationException, t as InvalidValueException } from "../validation-exception.js";
+export { BusinessRuleViolationException, DomainException, EntityNotFoundException, InvalidStateTransitionException, InvalidValueException, InvariantViolationException, MultipleValidationException, ValidationCode, ValidationException, ValidationField };

package/dist/exceptions/validation-field.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_validation_field = require("../validation-field.cjs");
+exports.ValidationField = require_validation_field.ValidationField;

package/dist/exceptions/validation-field.d.cts

@@ -0,0 +1,2 @@
+import { t as ValidationField } from "../validation-field.cjs";
+export { ValidationField };