@cullet/erp-core 1.1.0 → 1.3.0

package/dist/value-object.js

@@ -0,0 +1,191 @@
+import { t as InvariantViolationException } from "./invariant-violation-exception.js";
+import { i as version, n as __decorate, t as makeImmutable } from "./immutable.js";
+import { n as cloneDate, t as assertValidDate } from "./temporal-guards.js";
+import { t as PluginManager } from "./plugin.js";
+//#region src/core/shared/aggregate-version.ts
+function assertValidAggregateVersion(aggregateVersion) {
+	if (!Number.isInteger(aggregateVersion) || aggregateVersion < 0) throw new InvariantViolationException(`aggregateVersion must be a non-negative integer. Received: ${aggregateVersion}`);
+}
+//#endregion
+//#region src/core/domain/entity.ts
+var _Entity;
+/**
+* Base class for domain entities — objects defined by a stable identity rather
+* than by their attributes. Two entities are "the same" when their `id`
+* matches, even if every other field differs; this is the opposite of a
+* {@link ValueObject}, which is defined entirely by its contents.
+*
+* The class owns the bookkeeping common to every aggregate root: a creation
+* timestamp that never changes, a last-modified timestamp, and an
+* `aggregateVersion` counter used for optimistic concurrency control. All three
+* are validated on construction and the dates are defensively cloned, so an
+* entity can never be built into — or leak — an inconsistent temporal state.
+*
+* @typeParam TIdentifier - The identity type (e.g. a branded string id or a VO).
+*/
+let Entity = class Entity {
+	static {
+		_Entity = this;
+	}
+	/**
+	* Reconstitutes an entity from its persisted {@link EntityState}.
+	*
+	* Validates the temporal invariants up front so an invalid entity is
+	* impossible to construct: both dates must be valid, the aggregate version
+	* must be a non-negative integer, and `updatedAt` may not predate
+	* `createdAt`. Both dates are cloned on the way in so a later mutation of
+	* the caller's `Date` objects cannot reach into the entity's internal state.
+	*
+	* Declared `protected` because entities are reconstituted through a
+	* subclass factory, never instantiated directly by application code.
+	*
+	* @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.
+	*/
+	constructor(state) {
+		assertValidDate("createdAt", state.createdAt);
+		assertValidDate("updatedAt", state.updatedAt);
+		assertValidAggregateVersion(state.aggregateVersion);
+		if (state.updatedAt.getTime() < state.createdAt.getTime()) throw new InvariantViolationException("updatedAt cannot be earlier than createdAt");
+		this._id = state.id;
+		this._createdAt = cloneDate(state.createdAt);
+		this._updatedAt = cloneDate(state.updatedAt);
+		this._aggregateVersion = state.aggregateVersion;
+	}
+	/** The entity's stable identity — the basis for equality between entities. */
+	get id() {
+		return this._id;
+	}
+	/**
+	* When the entity was first created.
+	*
+	* Returns a clone so callers cannot mutate the entity's internal `Date`;
+	* the value is fixed at construction and never changes thereafter.
+	*/
+	get createdAt() {
+		return cloneDate(this._createdAt);
+	}
+	/**
+	* When the entity was last modified.
+	*
+	* Returns a clone for the same encapsulation reason as {@link createdAt};
+	* the underlying value advances only through {@link markAsModified}.
+	*/
+	get updatedAt() {
+		return cloneDate(this._updatedAt);
+	}
+	/**
+	* Monotonic counter incremented on every mutation, used for optimistic
+	* concurrency control: a writer reads this value, and the persistence layer
+	* rejects the write if the stored version has moved on in the meantime.
+	*/
+	get aggregateVersion() {
+		return this._aggregateVersion;
+	}
+	/**
+	* The schema/contract version stamped on this entity type by the
+	* `@version` decorator — used to detect and migrate state persisted under
+	* an older shape.
+	*/
+	get contractVersion() {
+		return _Entity.CONTRACT_VERSION;
+	}
+	/**
+	* The single seam through which an entity records a mutation: it advances
+	* `updatedAt` and bumps {@link aggregateVersion} by one. Subclasses must
+	* call this from every state-changing method so the version counter stays
+	* an accurate optimistic-lock token.
+	*
+	* @param updatedAt - The modification instant; defaults to now. Validated
+	*   and required not to predate `createdAt`, preserving the same invariant
+	*   the constructor enforces.
+	* @returns The new aggregate version after the increment.
+	* @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.
+	*/
+	markAsModified(updatedAt = /* @__PURE__ */ new Date()) {
+		assertValidDate("updatedAt", updatedAt);
+		if (updatedAt.getTime() < this._createdAt.getTime()) throw new InvariantViolationException("updatedAt cannot be earlier than createdAt");
+		this._updatedAt = cloneDate(updatedAt);
+		this._aggregateVersion += 1;
+		return this._aggregateVersion;
+	}
+};
+Entity = _Entity = __decorate([version("1.0")], Entity);
+//#endregion
+//#region src/core/domain/value-object.ts
+var _ValueObject;
+/**
+* Base class for value objects — domain concepts defined entirely by their
+* contents, with no identity of their own. Two value objects are
+* interchangeable when they hold equal data, which is the opposite of an
+* {@link Entity} (compared by id). Money, a CPF, a date range: replacing one
+* instance with an equal one changes nothing about the model.
+*
+* Immutability is the defining guarantee here. The wrapped `value` is
+* deep-frozen on construction, so a value object can be shared freely without
+* any risk of a consumer mutating shared state. Subclasses seal the instance
+* itself with {@link finalize} once their own fields are set.
+*
+* @typeParam T - The shape of the wrapped data.
+* @typeParam P - The primitive form produced by {@link toPrimitive} / {@link toJSON}.
+*/
+let ValueObject = class ValueObject {
+	static {
+		_ValueObject = this;
+	}
+	static {
+		this.plugins = new PluginManager();
+	}
+	/**
+	* Wraps `value`, deep-freezing it so the value object is immutable from the
+	* moment it exists. Declared `protected` because value objects are built
+	* through a validating subclass factory, never instantiated directly.
+	*/
+	constructor(value) {
+		this.value = makeImmutable(value);
+	}
+	/**
+	* The schema/contract version stamped on this value-object type by the
+	* `@version` decorator — used to detect state persisted under an older shape.
+	*/
+	get contractVersion() {
+		return _ValueObject.CONTRACT_VERSION;
+	}
+	/**
+	* Freezes the instance shell, blocking reassignment of any own field.
+	*
+	* `value` is already deep-frozen by the constructor, so the wrapped data is
+	* immutable regardless. The instance itself is NOT frozen automatically
+	* because a subclass may still need to assign its own fields after
+	* `super(value)` runs. Call `finalize()` at the very end of the subclass
+	* constructor (after all fields are set) to make the whole value object
+	* immutable.
+	*/
+	finalize() {
+		Object.freeze(this);
+	}
+	/**
+	* Hook for `JSON.stringify`. Delegates to {@link toPrimitive} so a value
+	* object serializes to its primitive form rather than exposing the internal
+	* `value` wrapper.
+	*/
+	toJSON() {
+		return this.toPrimitive();
+	}
+	/**
+	* Compares this value object with another by content. Because value objects
+	* carry no identity, two independently constructed instances holding the
+	* same data are considered equal.
+	*
+	* Delegates to the registered equality {@link plugins}; with no plugin
+	* registered it falls back to comparing the serialized wrapped `value`.
+	* Subclasses may still override for a faster or domain-specific comparison.
+	*/
+	equals(other) {
+		return _ValueObject.plugins.invoke("equals", [this, other], { fallback: (a, b) => JSON.stringify(a.value) === JSON.stringify(b.value) });
+	}
+};
+ValueObject = _ValueObject = __decorate([version("1.0")], ValueObject);
+//#endregion
+export { Entity as n, assertValidAggregateVersion as r, ValueObject as t };
+
+//# sourceMappingURL=value-object.js.map

package/dist/value-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-object.js","names":[],"sources":["../src/core/shared/aggregate-version.ts","../src/core/domain/entity.ts","../src/core/domain/value-object.ts"],"sourcesContent":["import { InvariantViolationException } from \"../exceptions/invariant-violation-exception.js\";\n\nfunction assertValidAggregateVersion(aggregateVersion: number): void {\n    if (!Number.isInteger(aggregateVersion) || aggregateVersion < 0) {\n        throw new InvariantViolationException(\n            `aggregateVersion must be a non-negative integer. Received: ${aggregateVersion}`,\n        );\n    }\n}\n\nexport { assertValidAggregateVersion };\n","import { InvariantViolationException } from \"../exceptions/invariant-violation-exception.js\";\nimport { assertValidAggregateVersion } from \"../shared/aggregate-version.js\";\nimport { assertValidDate, cloneDate } from \"../shared/temporal-guards.js\";\nimport { type ContractVersion, version } from \"../versioning/version.js\";\n\n/**\n * The minimal persisted shape needed to reconstitute an {@link Entity}.\n *\n * This is the contract between storage and the domain: a repository maps a row\n * (or document) onto these four fields and hands them to a subclass constructor.\n * `aggregateVersion` travels with the state so optimistic-concurrency checks\n * survive a round-trip through the database.\n */\ninterface EntityState<TIdentifier> {\n    readonly id: TIdentifier;\n    readonly createdAt: Date;\n    readonly updatedAt: Date;\n    readonly aggregateVersion: number;\n}\n\n/**\n * Base class for domain entities — objects defined by a stable identity rather\n * than by their attributes. Two entities are \"the same\" when their `id`\n * matches, even if every other field differs; this is the opposite of a\n * {@link ValueObject}, which is defined entirely by its contents.\n *\n * The class owns the bookkeeping common to every aggregate root: a creation\n * timestamp that never changes, a last-modified timestamp, and an\n * `aggregateVersion` counter used for optimistic concurrency control. All three\n * are validated on construction and the dates are defensively cloned, so an\n * entity can never be built into — or leak — an inconsistent temporal state.\n *\n * @typeParam TIdentifier - The identity type (e.g. a branded string id or a VO).\n */\n@version(\"1.0\")\nabstract class Entity<TIdentifier> {\n    declare public static readonly CONTRACT_VERSION: ContractVersion;\n\n    private readonly _id: TIdentifier;\n    private readonly _createdAt: Date;\n    private _updatedAt: Date;\n    private _aggregateVersion: number;\n\n    /**\n     * Reconstitutes an entity from its persisted {@link EntityState}.\n     *\n     * Validates the temporal invariants up front so an invalid entity is\n     * impossible to construct: both dates must be valid, the aggregate version\n     * must be a non-negative integer, and `updatedAt` may not predate\n     * `createdAt`. Both dates are cloned on the way in so a later mutation of\n     * the caller's `Date` objects cannot reach into the entity's internal state.\n     *\n     * Declared `protected` because entities are reconstituted through a\n     * subclass factory, never instantiated directly by application code.\n     *\n     * @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.\n     */\n    protected constructor(state: EntityState<TIdentifier>) {\n        assertValidDate(\"createdAt\", state.createdAt);\n        assertValidDate(\"updatedAt\", state.updatedAt);\n        assertValidAggregateVersion(state.aggregateVersion);\n\n        if (state.updatedAt.getTime() < state.createdAt.getTime()) {\n            throw new InvariantViolationException(\n                \"updatedAt cannot be earlier than createdAt\",\n            );\n        }\n\n        this._id = state.id;\n        this._createdAt = cloneDate(state.createdAt);\n        this._updatedAt = cloneDate(state.updatedAt);\n        this._aggregateVersion = state.aggregateVersion;\n    }\n\n    /** The entity's stable identity — the basis for equality between entities. */\n    public get id(): TIdentifier {\n        return this._id;\n    }\n\n    /**\n     * When the entity was first created.\n     *\n     * Returns a clone so callers cannot mutate the entity's internal `Date`;\n     * the value is fixed at construction and never changes thereafter.\n     */\n    public get createdAt(): Date {\n        return cloneDate(this._createdAt);\n    }\n\n    /**\n     * When the entity was last modified.\n     *\n     * Returns a clone for the same encapsulation reason as {@link createdAt};\n     * the underlying value advances only through {@link markAsModified}.\n     */\n    public get updatedAt(): Date {\n        return cloneDate(this._updatedAt);\n    }\n\n    /**\n     * Monotonic counter incremented on every mutation, used for optimistic\n     * concurrency control: a writer reads this value, and the persistence layer\n     * rejects the write if the stored version has moved on in the meantime.\n     */\n    public get aggregateVersion(): number {\n        return this._aggregateVersion;\n    }\n\n    /**\n     * The schema/contract version stamped on this entity type by the\n     * `@version` decorator — used to detect and migrate state persisted under\n     * an older shape.\n     */\n    public get contractVersion(): ContractVersion {\n        return Entity.CONTRACT_VERSION;\n    }\n\n    /**\n     * The single seam through which an entity records a mutation: it advances\n     * `updatedAt` and bumps {@link aggregateVersion} by one. Subclasses must\n     * call this from every state-changing method so the version counter stays\n     * an accurate optimistic-lock token.\n     *\n     * @param updatedAt - The modification instant; defaults to now. Validated\n     *   and required not to predate `createdAt`, preserving the same invariant\n     *   the constructor enforces.\n     * @returns The new aggregate version after the increment.\n     * @throws {InvariantViolationException} When `updatedAt` is earlier than `createdAt`.\n     */\n    protected markAsModified(updatedAt: Date = new Date()): number {\n        assertValidDate(\"updatedAt\", updatedAt);\n\n        if (updatedAt.getTime() < this._createdAt.getTime()) {\n            throw new InvariantViolationException(\n                \"updatedAt cannot be earlier than createdAt\",\n            );\n        }\n\n        this._updatedAt = cloneDate(updatedAt);\n        this._aggregateVersion += 1;\n\n        return this._aggregateVersion;\n    }\n}\n\nexport { Entity, type EntityState };\n","import { PluginManager } from \"../plugins/index.js\";\nimport { type DeepReadonly, makeImmutable } from \"../shared/immutable.js\";\nimport { type ContractVersion, version } from \"../versioning/version.js\";\n\n/**\n * Extension point for value-object equality. A plugin implementing this\n * contract overrides how any two value objects are compared, letting the host\n * application swap in a structural comparator (e.g. `lodash.isEqual` over the\n * wrapped `value`) without every value object having to implement `equals` by\n * hand.\n */\ntype ValueObjectPluginContract = {\n    equals: (\n        a: ValueObject<unknown, unknown>,\n        b: ValueObject<unknown, unknown>,\n    ) => boolean;\n};\n\n/**\n * Base class for value objects — domain concepts defined entirely by their\n * contents, with no identity of their own. Two value objects are\n * interchangeable when they hold equal data, which is the opposite of an\n * {@link Entity} (compared by id). Money, a CPF, a date range: replacing one\n * instance with an equal one changes nothing about the model.\n *\n * Immutability is the defining guarantee here. The wrapped `value` is\n * deep-frozen on construction, so a value object can be shared freely without\n * any risk of a consumer mutating shared state. Subclasses seal the instance\n * itself with {@link finalize} once their own fields are set.\n *\n * @typeParam T - The shape of the wrapped data.\n * @typeParam P - The primitive form produced by {@link toPrimitive} / {@link toJSON}.\n */\n@version(\"1.0\")\nabstract class ValueObject<T, P> {\n    declare public static readonly CONTRACT_VERSION: ContractVersion;\n\n    /**\n     * Registry of equality plugins shared by every value object. Empty by\n     * default — when nothing is registered, {@link equals} falls back to a\n     * structural comparison of the wrapped `value`. Hosts register a plugin\n     * (e.g. `lodash.isEqual`) once at startup to customise equality globally.\n     */\n    public static readonly plugins =\n        new PluginManager<ValueObjectPluginContract>();\n\n    /** The wrapped data, deep-frozen so it can never be mutated after construction. */\n    public readonly value: DeepReadonly<T>;\n\n    /**\n     * Wraps `value`, deep-freezing it so the value object is immutable from the\n     * moment it exists. Declared `protected` because value objects are built\n     * through a validating subclass factory, never instantiated directly.\n     */\n    protected constructor(value: T) {\n        this.value = makeImmutable(value);\n    }\n\n    /**\n     * The schema/contract version stamped on this value-object type by the\n     * `@version` decorator — used to detect state persisted under an older shape.\n     */\n    public get contractVersion(): ContractVersion {\n        return ValueObject.CONTRACT_VERSION;\n    }\n\n    /**\n     * Freezes the instance shell, blocking reassignment of any own field.\n     *\n     * `value` is already deep-frozen by the constructor, so the wrapped data is\n     * immutable regardless. The instance itself is NOT frozen automatically\n     * because a subclass may still need to assign its own fields after\n     * `super(value)` runs. Call `finalize()` at the very end of the subclass\n     * constructor (after all fields are set) to make the whole value object\n     * immutable.\n     */\n    protected finalize(): void {\n        Object.freeze(this);\n    }\n\n    /**\n     * Hook for `JSON.stringify`. Delegates to {@link toPrimitive} so a value\n     * object serializes to its primitive form rather than exposing the internal\n     * `value` wrapper.\n     */\n    public toJSON(): P {\n        return this.toPrimitive();\n    }\n\n    /**\n     * Compares this value object with another by content. Because value objects\n     * carry no identity, two independently constructed instances holding the\n     * same data are considered equal.\n     *\n     * Delegates to the registered equality {@link plugins}; with no plugin\n     * registered it falls back to comparing the serialized wrapped `value`.\n     * Subclasses may still override for a faster or domain-specific comparison.\n     */\n    public equals(other: this): boolean {\n        return ValueObject.plugins.invoke(\"equals\", [this, other], {\n            fallback: (a, b) =>\n                JSON.stringify(a.value) === JSON.stringify(b.value),\n        });\n    }\n\n    /**\n     * Projects the value object down to a plain, serializable primitive form —\n     * the representation suitable for persistence, transport, or comparison.\n     */\n    public abstract toPrimitive(): P;\n}\n\nexport { type DeepReadonly, ValueObject, type ValueObjectPluginContract };\n"],"mappings":";;;;;AAEA,SAAS,4BAA4B,kBAAgC;CACjE,IAAI,CAAC,OAAO,UAAU,gBAAgB,KAAK,mBAAmB,GAC1D,MAAM,IAAI,4BACN,8DAA8D,kBAClE;AAER;;;;;;;;;;;;;;;;;;AC0BA,IAAA,SAAA,MACe,OAAoB;;;;;;;;;;;;;;;;;;CAsB/B,YAAsB,OAAiC;EACnD,gBAAgB,aAAa,MAAM,SAAS;EAC5C,gBAAgB,aAAa,MAAM,SAAS;EAC5C,4BAA4B,MAAM,gBAAgB;EAElD,IAAI,MAAM,UAAU,QAAQ,IAAI,MAAM,UAAU,QAAQ,GACpD,MAAM,IAAI,4BACN,4CACJ;EAGJ,KAAK,MAAM,MAAM;EACjB,KAAK,aAAa,UAAU,MAAM,SAAS;EAC3C,KAAK,aAAa,UAAU,MAAM,SAAS;EAC3C,KAAK,oBAAoB,MAAM;CACnC;;CAGA,IAAW,KAAkB;EACzB,OAAO,KAAK;CAChB;;;;;;;CAQA,IAAW,YAAkB;EACzB,OAAO,UAAU,KAAK,UAAU;CACpC;;;;;;;CAQA,IAAW,YAAkB;EACzB,OAAO,UAAU,KAAK,UAAU;CACpC;;;;;;CAOA,IAAW,mBAA2B;EAClC,OAAO,KAAK;CAChB;;;;;;CAOA,IAAW,kBAAmC;EAC1C,OAAA,QAAc;CAClB;;;;;;;;;;;;;CAcA,eAAyB,4BAAkB,IAAI,KAAK,GAAW;EAC3D,gBAAgB,aAAa,SAAS;EAEtC,IAAI,UAAU,QAAQ,IAAI,KAAK,WAAW,QAAQ,GAC9C,MAAM,IAAI,4BACN,4CACJ;EAGJ,KAAK,aAAa,UAAU,SAAS;EACrC,KAAK,qBAAqB;EAE1B,OAAO,KAAK;CAChB;AACJ;+BA7GC,QAAQ,KAAK,CAAA,GAAA,MAAA;;;;;;;;;;;;;;;;;;;ACDd,IAAA,cAAA,MACe,YAAkB;;;;;iBAUzB,IAAI,cAAyC;;;;;;;CAUjD,YAAsB,OAAU;EAC5B,KAAK,QAAQ,cAAc,KAAK;CACpC;;;;;CAMA,IAAW,kBAAmC;EAC1C,OAAA,aAAmB;CACvB;;;;;;;;;;;CAYA,WAA2B;EACvB,OAAO,OAAO,IAAI;CACtB;;;;;;CAOA,SAAmB;EACf,OAAO,KAAK,YAAY;CAC5B;;;;;;;;;;CAWA,OAAc,OAAsB;EAChC,OAAA,aAAmB,QAAQ,OAAO,UAAU,CAAC,MAAM,KAAK,GAAG,EACvD,WAAW,GAAG,MACV,KAAK,UAAU,EAAE,KAAK,MAAM,KAAK,UAAU,EAAE,KAAK,EAC1D,CAAC;CACL;AAOJ;yCA7EC,QAAQ,KAAK,CAAA,GAAA,WAAA"}

package/dist/version.d.cts

@@ -0,0 +1,10 @@
+//#region src/core/versioning/version.d.ts
+type ContractVersion = `${number}.${number}`;
+type VersionedTarget = {
+  readonly prototype: object;
+};
+declare const CONTRACT_VERSION_PROPERTY: "CONTRACT_VERSION";
+declare function version<const TVersion extends ContractVersion>(contractVersion: TVersion): (target: VersionedTarget) => void;
+//#endregion
+export { version as i, ContractVersion as n, VersionedTarget as r, CONTRACT_VERSION_PROPERTY as t };
+//# sourceMappingURL=version.d.cts.map

package/dist/version.d.ts

@@ -0,0 +1,10 @@
+//#region src/core/versioning/version.d.ts
+type ContractVersion = `${number}.${number}`;
+type VersionedTarget = {
+  readonly prototype: object;
+};
+declare const CONTRACT_VERSION_PROPERTY: "CONTRACT_VERSION";
+declare function version<const TVersion extends ContractVersion>(contractVersion: TVersion): (target: VersionedTarget) => void;
+//#endregion
+export { version as i, ContractVersion as n, VersionedTarget as r, CONTRACT_VERSION_PROPERTY as t };
+//# sourceMappingURL=version.d.ts.map

package/dist/versioning/index.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_immutable = require("../immutable.cjs");
+const require_domain_event_contracts = require("../domain-event-contracts.cjs");
+exports.CONTRACT_VERSION_PROPERTY = require_immutable.CONTRACT_VERSION_PROPERTY;
+exports.buildDomainEventContractVersions = require_domain_event_contracts.buildDomainEventContractVersions;
+exports.createDomainEventEnvelope = require_domain_event_contracts.createDomainEventEnvelope;
+exports.version = require_immutable.version;

package/dist/versioning/index.d.cts

@@ -0,0 +1,3 @@
+import { i as version, n as ContractVersion, r as VersionedTarget, t as CONTRACT_VERSION_PROPERTY } from "../version.cjs";
+import { a as buildDomainEventContractVersions, i as DomainEventEnvelope, n as DomainEventContractSelection, o as createDomainEventEnvelope, r as DomainEventContractVersions, t as CreateDomainEventEnvelopeInput } from "../domain-event-contracts.cjs";
+export { CONTRACT_VERSION_PROPERTY, ContractVersion, CreateDomainEventEnvelopeInput, DomainEventContractSelection, DomainEventContractVersions, DomainEventEnvelope, VersionedTarget, buildDomainEventContractVersions, createDomainEventEnvelope, version };

package/dist/versioning/index.d.ts

@@ -0,0 +1,3 @@
+import { i as version, n as ContractVersion, r as VersionedTarget, t as CONTRACT_VERSION_PROPERTY } from "../version.js";
+import { a as buildDomainEventContractVersions, i as DomainEventEnvelope, n as DomainEventContractSelection, o as createDomainEventEnvelope, r as DomainEventContractVersions, t as CreateDomainEventEnvelopeInput } from "../domain-event-contracts.js";
+export { CONTRACT_VERSION_PROPERTY, ContractVersion, CreateDomainEventEnvelopeInput, DomainEventContractSelection, DomainEventContractVersions, DomainEventEnvelope, VersionedTarget, buildDomainEventContractVersions, createDomainEventEnvelope, version };

package/dist/versioning/index.js

@@ -0,0 +1,3 @@
+import { i as version, r as CONTRACT_VERSION_PROPERTY } from "../immutable.js";
+import { n as createDomainEventEnvelope, t as buildDomainEventContractVersions } from "../domain-event-contracts.js";
+export { CONTRACT_VERSION_PROPERTY, buildDomainEventContractVersions, createDomainEventEnvelope, version };

package/meta.json

@@ -1,7 +1,7 @@
 {
     "schemaVersion": "2",
     "name": "erp-core",
-    "version": "1.1.0",
+    "version": "1.3.0",
     "description": "Núcleo arquitetural para ERP em TypeScript — entidades, value objects, erros tipados e policies declaráveis sobre clean architecture.",
     "compatibility": {
         "engines": {
@@ -12,7 +12,9 @@
             "peerDependencies": [
                 {
                     "name": "zod",
-                    "range": ">=3.22.0 <5"
+                    "range": ">=3.22.0 <5",
+                    "optional": true,
+                    "notes": "Only required by the `./policies` subpath (gate/compute engines). The domain/result/errors/exceptions/rulesets/versioning/plugins subpaths are zod-free."
                 }
             ]
         },
@@ -51,6 +53,17 @@
     "exports": [
         "Entity",
         "ValueObject",
+        "UuidIdentifier",
+        "PluginManager",
+        "Result",
+        "Outcome",
+        "RulesetRegistry",
+        "DomainException",
+        "InvariantViolationException",
+        "ValidationException",
+        "ValidationField",
+        "version",
+        "createDomainEventEnvelope",
         "AppError",
         "ValidationError",
         "NotFoundError",
@@ -76,7 +89,9 @@
         "1.0.9 - Harden erp-core invariants and error serialization",
         "1.0.10 - Stop the `meta.json` `changelog` from drifting and clarify the `ValueObject` freeze contract.",
         "1.0.11 - Document the public API surface with TSDoc.",
-        "1.1.0 - **New: `ResultRepository`, `UseCaseObservability`, and `./application` subpath**"
+        "1.1.0 - **New: `ResultRepository`, `UseCaseObservability`, and `./application` subpath**",
+        "1.2.0 - Add zod-free subpaths for the stable core primitives and a value-object equality plugin system.",
+        "1.3.0 - Add zod-free subpaths for the stable core primitives and a value-object equality plugin system."
     ],
     "deprecated": false
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cullet/erp-core",
-    "version": "1.1.0",
+    "version": "1.3.0",
     "description": "Núcleo arquitetural para ERP em TypeScript — entidades, value objects, erros tipados e policies declaráveis sobre clean architecture.",
     "type": "module",
     "repository": {
@@ -8,36 +8,179 @@
         "url": "git+https://github.com/fabiano-eduardo/cullet.git",
         "directory": "packages/erp-core"
     },
-    "main": "./dist/index.js",
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.js",
     "types": "./dist/index.d.ts",
+    "typesVersions": {
+        "*": {
+            "application": [
+                "./dist/application/index.d.ts"
+            ],
+            "domain": [
+                "./dist/domain/index.d.ts"
+            ],
+            "errors": [
+                "./dist/errors/index.d.ts"
+            ],
+            "exceptions": [
+                "./dist/exceptions/index.d.ts"
+            ],
+            "exceptions/validation-field": [
+                "./dist/exceptions/validation-field.d.ts"
+            ],
+            "plugins": [
+                "./dist/plugins/index.d.ts"
+            ],
+            "policies": [
+                "./dist/policies/index.d.ts"
+            ],
+            "policies/engines": [
+                "./dist/policies/engines/index.d.ts"
+            ],
+            "policies/engines/v1/gate": [
+                "./dist/policies/engines/v1/gate/index.d.ts"
+            ],
+            "result": [
+                "./dist/result/index.d.ts"
+            ],
+            "rulesets": [
+                "./dist/rulesets/index.d.ts"
+            ],
+            "versioning": [
+                "./dist/versioning/index.d.ts"
+            ]
+        }
+    },
     "exports": {
         ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.js"
+            "import": {
+                "types": "./dist/index.d.ts",
+                "default": "./dist/index.js"
+            },
+            "require": {
+                "types": "./dist/index.d.cts",
+                "default": "./dist/index.cjs"
+            }
         },
         "./application": {
-            "types": "./dist/application/index.d.ts",
-            "import": "./dist/application/index.js"
+            "import": {
+                "types": "./dist/application/index.d.ts",
+                "default": "./dist/application/index.js"
+            },
+            "require": {
+                "types": "./dist/application/index.d.cts",
+                "default": "./dist/application/index.cjs"
+            }
+        },
+        "./domain": {
+            "import": {
+                "types": "./dist/domain/index.d.ts",
+                "default": "./dist/domain/index.js"
+            },
+            "require": {
+                "types": "./dist/domain/index.d.cts",
+                "default": "./dist/domain/index.cjs"
+            }
         },
         "./errors": {
-            "types": "./dist/errors/index.d.ts",
-            "import": "./dist/errors/index.js"
+            "import": {
+                "types": "./dist/errors/index.d.ts",
+                "default": "./dist/errors/index.js"
+            },
+            "require": {
+                "types": "./dist/errors/index.d.cts",
+                "default": "./dist/errors/index.cjs"
+            }
+        },
+        "./exceptions": {
+            "import": {
+                "types": "./dist/exceptions/index.d.ts",
+                "default": "./dist/exceptions/index.js"
+            },
+            "require": {
+                "types": "./dist/exceptions/index.d.cts",
+                "default": "./dist/exceptions/index.cjs"
+            }
+        },
+        "./exceptions/validation-field": {
+            "import": {
+                "types": "./dist/exceptions/validation-field.d.ts",
+                "default": "./dist/exceptions/validation-field.js"
+            },
+            "require": {
+                "types": "./dist/exceptions/validation-field.d.cts",
+                "default": "./dist/exceptions/validation-field.cjs"
+            }
+        },
+        "./plugins": {
+            "import": {
+                "types": "./dist/plugins/index.d.ts",
+                "default": "./dist/plugins/index.js"
+            },
+            "require": {
+                "types": "./dist/plugins/index.d.cts",
+                "default": "./dist/plugins/index.cjs"
+            }
         },
         "./policies": {
-            "types": "./dist/policies/index.d.ts",
-            "import": "./dist/policies/index.js"
+            "import": {
+                "types": "./dist/policies/index.d.ts",
+                "default": "./dist/policies/index.js"
+            },
+            "require": {
+                "types": "./dist/policies/index.d.cts",
+                "default": "./dist/policies/index.cjs"
+            }
         },
         "./policies/engines": {
-            "types": "./dist/policies/engines/index.d.ts",
-            "import": "./dist/policies/engines/index.js"
+            "import": {
+                "types": "./dist/policies/engines/index.d.ts",
+                "default": "./dist/policies/engines/index.js"
+            },
+            "require": {
+                "types": "./dist/policies/engines/index.d.cts",
+                "default": "./dist/policies/engines/index.cjs"
+            }
         },
         "./policies/engines/v1/gate": {
-            "types": "./dist/policies/engines/v1/gate/index.d.ts",
-            "import": "./dist/policies/engines/v1/gate/index.js"
+            "import": {
+                "types": "./dist/policies/engines/v1/gate/index.d.ts",
+                "default": "./dist/policies/engines/v1/gate/index.js"
+            },
+            "require": {
+                "types": "./dist/policies/engines/v1/gate/index.d.cts",
+                "default": "./dist/policies/engines/v1/gate/index.cjs"
+            }
         },
-        "./exceptions/validation-field": {
-            "types": "./dist/exceptions/validation-field.d.ts",
-            "import": "./dist/exceptions/validation-field.js"
+        "./result": {
+            "import": {
+                "types": "./dist/result/index.d.ts",
+                "default": "./dist/result/index.js"
+            },
+            "require": {
+                "types": "./dist/result/index.d.cts",
+                "default": "./dist/result/index.cjs"
+            }
+        },
+        "./rulesets": {
+            "import": {
+                "types": "./dist/rulesets/index.d.ts",
+                "default": "./dist/rulesets/index.js"
+            },
+            "require": {
+                "types": "./dist/rulesets/index.d.cts",
+                "default": "./dist/rulesets/index.cjs"
+            }
+        },
+        "./versioning": {
+            "import": {
+                "types": "./dist/versioning/index.d.ts",
+                "default": "./dist/versioning/index.js"
+            },
+            "require": {
+                "types": "./dist/versioning/index.d.cts",
+                "default": "./dist/versioning/index.cjs"
+            }
         },
         "./package.json": "./package.json"
     },
@@ -62,6 +205,11 @@
     "peerDependencies": {
         "zod": ">=3.22.0 <5"
     },
+    "peerDependenciesMeta": {
+        "zod": {
+            "optional": true
+        }
+    },
     "publishConfig": {
         "access": "public"
     },

package/src/core/domain/rulesets/index.ts

@@ -0,0 +1,7 @@
+export {
+    type CreationRuleset,
+    type InvariantRuleset,
+} from "./entity-ruleset.contracts.js";
+export { RulesetRegistry } from "./ruleset-registry.js";
+export { type Ruleset, type RulesetId } from "./ruleset.contracts.js";
+export { type ValueObjectRuleset } from "./value-object-ruleset.contracts.js";

package/src/core/domain/uuid-identifier.ts

@@ -0,0 +1,72 @@
+import { ValueObject } from "./value-object.js";
+
+/**
+ * Canonical RFC-4122 UUID (versions 1–5), matched case-insensitively. Declared
+ * once here so the dozens of typed identifiers a domain accumulates never have
+ * to re-state the pattern.
+ */
+const UUID_PATTERN =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+/**
+ * Base class for UUID-backed identity value objects.
+ *
+ * A domain typically has many of these — `OrderId`, `CustomerId`, `InvoiceId` —
+ * all wrapping the same `string` shape. Two problems follow: the UUID format
+ * check gets copy-pasted into every one, and because the wrapped shape is
+ * identical, TypeScript's structural typing would happily accept an `OrderId`
+ * where a `CustomerId` is expected. `UuidIdentifier` solves both: the format
+ * lives here once ({@link isValid}), and the `TBrand` phantom tag makes each
+ * subtype nominally distinct so the ids cannot be swapped for one another.
+ *
+ * It deliberately does not impose a factory. Identifiers vary in how they
+ * report an invalid value (their own exception type, their own message), so a
+ * concrete id adds a validating `create` that calls {@link isValid} plus a
+ * `reconstitute` that trusts an already-persisted value:
+ *
+ * ```ts
+ * class OrderId extends UuidIdentifier<"OrderId"> {
+ *   private constructor(value: string) { super(value); }
+ *   static create(raw: string): OrderId {
+ *     if (!UuidIdentifier.isValid(raw)) throw new InvalidOrderIdError(raw);
+ *     return new OrderId(raw);
+ *   }
+ *   static reconstitute(value: string): OrderId { return new OrderId(value); }
+ * }
+ * ```
+ *
+ * @typeParam TBrand - A unique string literal that nominally tags the subtype.
+ */
+abstract class UuidIdentifier<
+    TBrand extends string = string,
+> extends ValueObject<string, string> {
+    /**
+     * Phantom brand. Never assigned at runtime (`declare`), it exists only so
+     * two identifiers with different brands are not interchangeable at the type
+     * level despite sharing the same `string` value.
+     */
+    protected declare readonly __brand: TBrand;
+
+    protected constructor(value: string) {
+        super(value);
+    }
+
+    public toPrimitive(): string {
+        return this.value;
+    }
+
+    /** The wrapped UUID string — convenient for logging and interpolation. */
+    public toString(): string {
+        return this.value;
+    }
+
+    /**
+     * Whether `candidate` is a canonical UUID (versions 1–5). The single source
+     * of truth for the format; concrete identifiers call this from `create`.
+     */
+    public static isValid(candidate: string): boolean {
+        return UUID_PATTERN.test(candidate);
+    }
+}
+
+export { UuidIdentifier };