@cullet/erp-core 1.2.0 → 1.3.0

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/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-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-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/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/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/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 };

package/dist/gate-engine-registry.cjs

@@ -0,0 +1,308 @@
+const require_gate_v1_payload_schema = require("./gate-v1-payload.schema.cjs");
+const require_result = require("./result.cjs");
+let zod = require("zod");
+//#region src/core/policies/engines/v1/compute/compute-payload.schema.ts
+const computeDecisionTableRuleSchema = zod.z.object({
+	conditions: require_gate_v1_payload_schema.conditionNodeSchema,
+	result: zod.z.unknown()
+});
+var ComputePayloadSchemaV1 = class ComputePayloadSchemaV1 {
+	static {
+		this.schema = zod.z.union([zod.z.object({
+			type: zod.z.literal("decision-table"),
+			rules: zod.z.array(computeDecisionTableRuleSchema).min(1),
+			default: zod.z.unknown()
+		}).strict(), zod.z.object({
+			type: zod.z.literal("params"),
+			data: zod.z.record(zod.z.string(), zod.z.unknown())
+		}).strict()]);
+	}
+	static parse(payload) {
+		const parsed = ComputePayloadSchemaV1.schema.safeParse(payload);
+		if (!parsed.success) {
+			const details = parsed.error.issues.map((issue) => {
+				const path = issue.path.join(".");
+				return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
+			}).join("; ");
+			return require_result.Result.err(`Invalid compute payload: ${details}`);
+		}
+		return require_result.Result.ok(parsed.data);
+	}
+};
+ComputePayloadSchemaV1.schema;
+//#endregion
+//#region src/core/policies/engines/parse-compute-payload.ts
+var ComputePayloadParserRegistry = class {
+	constructor() {
+		this.parsers = /* @__PURE__ */ new Map();
+	}
+	register(payloadSchemaVersion, parser) {
+		this.parsers.set(payloadSchemaVersion, parser);
+	}
+	get(payloadSchemaVersion) {
+		return this.parsers.get(payloadSchemaVersion);
+	}
+	parse(payloadSchemaVersion, payload) {
+		const parser = this.parsers.get(payloadSchemaVersion);
+		if (parser === void 0) return require_result.Result.err(`No compute payload parser registered for schema version "${payloadSchemaVersion}"`);
+		return parser(payload);
+	}
+};
+var ComputePayloadParsers = class ComputePayloadParsers {
+	static {
+		this.registry = new ComputePayloadParserRegistry();
+	}
+	static {
+		this.defaultsRegistered = false;
+	}
+	static ensureDefaults() {
+		if (ComputePayloadParsers.defaultsRegistered) return;
+		ComputePayloadParsers.defaultsRegistered = true;
+		ComputePayloadParsers.registry.register(1, ComputePayloadSchemaV1.parse);
+	}
+	static register(payloadSchemaVersion, parser) {
+		ComputePayloadParsers.ensureDefaults();
+		ComputePayloadParsers.registry.register(payloadSchemaVersion, parser);
+	}
+	static get(payloadSchemaVersion) {
+		ComputePayloadParsers.ensureDefaults();
+		return ComputePayloadParsers.registry.get(payloadSchemaVersion);
+	}
+	static parse(payloadSchemaVersion, payload) {
+		ComputePayloadParsers.ensureDefaults();
+		return ComputePayloadParsers.registry.parse(payloadSchemaVersion, payload);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/compute-engine-registry.ts
+var ComputeEngineRegistry = class {
+	constructor() {
+		this.engines = /* @__PURE__ */ new Map();
+	}
+	register(engine) {
+		this.engines.set(engine.version, engine);
+	}
+	get(version) {
+		return this.engines.get(version);
+	}
+	evaluate(version, params) {
+		const engine = this.get(version);
+		if (engine === void 0) return require_result.Result.err(`No compute engine registered for version "${version}"`);
+		const evaluator = params.evaluators.get(params.policyKey, version);
+		if (evaluator === void 0) return require_result.Result.err(`No compute evaluator registered for policy key "${params.policyKey}" and version "${version}"`);
+		const parsedPayloadResult = ComputePayloadParsers.parse(params.payloadSchemaVersion, params.payload);
+		if (parsedPayloadResult.isErr()) return require_result.Result.err(parsedPayloadResult.errorOrNull());
+		return engine.evaluate(parsedPayloadResult.getOrNull(), params.context, evaluator);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/compute-evaluator-registry.ts
+var ComputeEvaluatorRegistry = class ComputeEvaluatorRegistry {
+	constructor() {
+		this.evaluators = /* @__PURE__ */ new Map();
+	}
+	static toRegistryKey(policyKey, version) {
+		return `${policyKey}::${version}`;
+	}
+	register(registration) {
+		this.evaluators.set(ComputeEvaluatorRegistry.toRegistryKey(registration.policyKey, registration.version), registration.evaluator);
+	}
+	get(policyKey, version) {
+		return this.evaluators.get(ComputeEvaluatorRegistry.toRegistryKey(policyKey, version));
+	}
+};
+//#endregion
+//#region src/core/policies/engines/v1/compute/resolve-decision-table-v1.ts
+const COMPUTE_CONDITION_EVAL_FAILED_TAG = "COMPUTE_CONDITION_EVAL_FAILED";
+var DecisionTableResolverV1 = class DecisionTableResolverV1 {
+	constructor(payload, context, conditionEvaluationOptions) {
+		this.payload = payload;
+		this.context = context;
+		this.conditionEvaluationOptions = conditionEvaluationOptions;
+	}
+	wrapConditionEvaluationError(error) {
+		return require_result.Result.err(`${COMPUTE_CONDITION_EVAL_FAILED_TAG}: ${error}`);
+	}
+	resolve() {
+		const evaluator = new require_gate_v1_payload_schema.ConditionEvaluatorV1(this.context, this.conditionEvaluationOptions);
+		for (const rule of this.payload.rules) {
+			const conditionResult = evaluator.evaluate(rule.conditions);
+			if (conditionResult.isErr()) return this.wrapConditionEvaluationError(conditionResult.errorOrNull());
+			if (conditionResult.getOrNull()) return require_result.Result.ok(rule.result);
+		}
+		return require_result.Result.ok(this.payload.default);
+	}
+	static resolve(payload, context, conditionEvaluationOptions) {
+		return new DecisionTableResolverV1(payload, context, conditionEvaluationOptions).resolve();
+	}
+};
+//#endregion
+//#region src/core/policies/engines/v1/compute/compute-engine-v1.ts
+const COMPUTE_ENGINE_VERSION = 1;
+var ComputeEngineV1 = class {
+	constructor(params = {}) {
+		this.version = COMPUTE_ENGINE_VERSION;
+		this.coreConfig = params.coreConfig ?? require_gate_v1_payload_schema.coreConfig;
+	}
+	/**
+	* Evaluates an already-parsed ComputePayload against a context.
+	* Pure function — no side effects.
+	*
+	* For `params`: forwards `payload.data` directly to the evaluator.
+	* For `decision-table`: evaluates the rules in order and passes the `result`
+	* of the first one that satisfies its conditions, or `default` if none match.
+	*
+	* The evaluator is responsible for validating and transforming the final value.
+	*/
+	evaluate(payload, context, evaluator) {
+		if (payload.type === "params") return evaluator.evaluate(payload.data, context);
+		const resolvedResult = DecisionTableResolverV1.resolve(payload, context, this.coreConfig.getConditionEvaluationOptions(COMPUTE_ENGINE_VERSION));
+		if (resolvedResult.isErr()) return require_result.Result.err(resolvedResult.errorOrNull());
+		return evaluator.evaluate(resolvedResult.getOrNull(), context);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/compute-registry.ts
+var ComputeRegistry = class {
+	constructor(params = {}) {
+		this.engines = new ComputeEngineRegistry();
+		this.evaluators = new ComputeEvaluatorRegistry();
+		const resolvedCoreConfig = params.coreConfig ?? require_gate_v1_payload_schema.coreConfig;
+		this.engines.register(new ComputeEngineV1({ coreConfig: resolvedCoreConfig }));
+	}
+	register(registration) {
+		this.evaluators.register(registration);
+	}
+	registerEngine(engine) {
+		this.engines.register(engine);
+	}
+	getEngine(version) {
+		return this.engines.get(version);
+	}
+	getEvaluator(policyKey, version) {
+		return this.evaluators.get(policyKey, version);
+	}
+	evaluate(policyKey, computeEngineVersion, payloadSchemaVersion, payload, context) {
+		return this.engines.evaluate(computeEngineVersion, {
+			policyKey,
+			payloadSchemaVersion,
+			payload,
+			context,
+			evaluators: this.evaluators
+		});
+	}
+};
+//#endregion
+//#region src/core/policies/engines/parse-gate-payload.ts
+var GatePayloadParserRegistry = class {
+	constructor() {
+		this.parsers = /* @__PURE__ */ new Map();
+	}
+	register(engineVersion, parser) {
+		this.parsers.set(engineVersion, parser);
+	}
+	get(engineVersion) {
+		return this.parsers.get(engineVersion);
+	}
+	parse(engineVersion, payload) {
+		const parser = this.parsers.get(engineVersion);
+		if (parser === void 0) return require_result.Result.err(`No gate payload parser registered for engine version "${engineVersion}"`);
+		return parser(payload);
+	}
+};
+var GatePayloadParsers = class GatePayloadParsers {
+	static {
+		this.registry = new GatePayloadParserRegistry();
+	}
+	static {
+		this.defaultsRegistered = false;
+	}
+	static ensureDefaults() {
+		if (GatePayloadParsers.defaultsRegistered) return;
+		GatePayloadParsers.defaultsRegistered = true;
+		GatePayloadParsers.registry.register(1, require_gate_v1_payload_schema.GatePayloadSchemaV1.parse);
+	}
+	static register(engineVersion, parser) {
+		GatePayloadParsers.ensureDefaults();
+		GatePayloadParsers.registry.register(engineVersion, parser);
+	}
+	static get(engineVersion) {
+		GatePayloadParsers.ensureDefaults();
+		return GatePayloadParsers.registry.get(engineVersion);
+	}
+	static parse(engineVersion, payload) {
+		GatePayloadParsers.ensureDefaults();
+		return GatePayloadParsers.registry.parse(engineVersion, payload);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/gate-engine-registry.ts
+var GateEngineRegistry = class {
+	constructor() {
+		this.engines = /* @__PURE__ */ new Map();
+	}
+	register(engine) {
+		this.engines.set(engine.version, engine);
+	}
+	get(version) {
+		return this.engines.get(version);
+	}
+	evaluate(version, payload, context) {
+		const engine = this.engines.get(version);
+		if (!engine) return require_result.Result.err(`No gate engine registered for version "${version}"`);
+		const parsedPayload = GatePayloadParsers.parse(version, payload);
+		if (parsedPayload.isErr()) return require_result.Result.err(parsedPayload.errorOrNull());
+		return engine.evaluate(parsedPayload.getOrNull(), context);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "ComputeEngineRegistry", {
+	enumerable: true,
+	get: function() {
+		return ComputeEngineRegistry;
+	}
+});
+Object.defineProperty(exports, "ComputeEvaluatorRegistry", {
+	enumerable: true,
+	get: function() {
+		return ComputeEvaluatorRegistry;
+	}
+});
+Object.defineProperty(exports, "ComputePayloadParserRegistry", {
+	enumerable: true,
+	get: function() {
+		return ComputePayloadParserRegistry;
+	}
+});
+Object.defineProperty(exports, "ComputePayloadParsers", {
+	enumerable: true,
+	get: function() {
+		return ComputePayloadParsers;
+	}
+});
+Object.defineProperty(exports, "ComputeRegistry", {
+	enumerable: true,
+	get: function() {
+		return ComputeRegistry;
+	}
+});
+Object.defineProperty(exports, "GateEngineRegistry", {
+	enumerable: true,
+	get: function() {
+		return GateEngineRegistry;
+	}
+});
+Object.defineProperty(exports, "GatePayloadParserRegistry", {
+	enumerable: true,
+	get: function() {
+		return GatePayloadParserRegistry;
+	}
+});
+Object.defineProperty(exports, "GatePayloadParsers", {
+	enumerable: true,
+	get: function() {
+		return GatePayloadParsers;
+	}
+});
+
+//# sourceMappingURL=gate-engine-registry.cjs.map