@cullet/erp-core 1.3.0 → 1.5.0

package/dist/uuid-identifier.d.cts

@@ -1,6 +1,5 @@
 import { n as ContractVersion } from "./version.cjs";
-import { t as DeepReadonly } from "./immutable.cjs";
-import { t as PluginManager } from "./plugin.cjs";
+import { t as ValueObject } from "./value-object.cjs";
 
 //#region src/core/domain/entity.d.ts
 
@@ -96,88 +95,6 @@ declare abstract class Entity<TIdentifier> {
   protected markAsModified(updatedAt?: Date): number;
 }
 //#endregion
-//#region src/core/domain/value-object.d.ts
-/**
- * Extension point for value-object equality. A plugin implementing this
- * contract overrides how any two value objects are compared, letting the host
- * application swap in a structural comparator (e.g. `lodash.isEqual` over the
- * wrapped `value`) without every value object having to implement `equals` by
- * hand.
- */
-type ValueObjectPluginContract = {
-  equals: (a: ValueObject<unknown, unknown>, b: ValueObject<unknown, unknown>) => boolean;
-};
-/**
- * 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}.
- */
-declare abstract class ValueObject<T, P> {
-  static readonly CONTRACT_VERSION: ContractVersion;
-  /**
-   * Registry of equality plugins shared by every value object. Empty by
-   * default — when nothing is registered, {@link equals} falls back to a
-   * structural comparison of the wrapped `value`. Hosts register a plugin
-   * (e.g. `lodash.isEqual`) once at startup to customise equality globally.
-   */
-  static readonly plugins: PluginManager<ValueObjectPluginContract>;
-  /** The wrapped data, deep-frozen so it can never be mutated after construction. */
-  readonly value: DeepReadonly<T>;
-  /**
-   * 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.
-   */
-  protected constructor(value: T);
-  /**
-   * 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(): ContractVersion;
-  /**
-   * 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.
-   */
-  protected finalize(): void;
-  /**
-   * 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(): P;
-  /**
-   * 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: this): boolean;
-  /**
-   * Projects the value object down to a plain, serializable primitive form —
-   * the representation suitable for persistence, transport, or comparison.
-   */
-  abstract toPrimitive(): P;
-}
-//#endregion
 //#region src/core/domain/uuid-identifier.d.ts
 /**
  * Base class for UUID-backed identity value objects.
@@ -226,5 +143,5 @@ declare abstract class UuidIdentifier<TBrand extends string = string> extends Va
   static isValid(candidate: string): boolean;
 }
 //#endregion
-export { EntityState as a, Entity as i, ValueObject as n, ValueObjectPluginContract as r, UuidIdentifier as t };
+export { Entity as n, EntityState as r, UuidIdentifier as t };
 //# sourceMappingURL=uuid-identifier.d.cts.map

package/dist/uuid-identifier.d.ts

@@ -1,6 +1,5 @@
 import { n as ContractVersion } from "./version.js";
-import { t as DeepReadonly } from "./immutable.js";
-import { t as PluginManager } from "./plugin.js";
+import { t as ValueObject } from "./value-object.js";
 
 //#region src/core/domain/entity.d.ts
 
@@ -96,88 +95,6 @@ declare abstract class Entity<TIdentifier> {
   protected markAsModified(updatedAt?: Date): number;
 }
 //#endregion
-//#region src/core/domain/value-object.d.ts
-/**
- * Extension point for value-object equality. A plugin implementing this
- * contract overrides how any two value objects are compared, letting the host
- * application swap in a structural comparator (e.g. `lodash.isEqual` over the
- * wrapped `value`) without every value object having to implement `equals` by
- * hand.
- */
-type ValueObjectPluginContract = {
-  equals: (a: ValueObject<unknown, unknown>, b: ValueObject<unknown, unknown>) => boolean;
-};
-/**
- * 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}.
- */
-declare abstract class ValueObject<T, P> {
-  static readonly CONTRACT_VERSION: ContractVersion;
-  /**
-   * Registry of equality plugins shared by every value object. Empty by
-   * default — when nothing is registered, {@link equals} falls back to a
-   * structural comparison of the wrapped `value`. Hosts register a plugin
-   * (e.g. `lodash.isEqual`) once at startup to customise equality globally.
-   */
-  static readonly plugins: PluginManager<ValueObjectPluginContract>;
-  /** The wrapped data, deep-frozen so it can never be mutated after construction. */
-  readonly value: DeepReadonly<T>;
-  /**
-   * 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.
-   */
-  protected constructor(value: T);
-  /**
-   * 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(): ContractVersion;
-  /**
-   * 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.
-   */
-  protected finalize(): void;
-  /**
-   * 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(): P;
-  /**
-   * 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: this): boolean;
-  /**
-   * Projects the value object down to a plain, serializable primitive form —
-   * the representation suitable for persistence, transport, or comparison.
-   */
-  abstract toPrimitive(): P;
-}
-//#endregion
 //#region src/core/domain/uuid-identifier.d.ts
 /**
  * Base class for UUID-backed identity value objects.
@@ -226,5 +143,5 @@ declare abstract class UuidIdentifier<TBrand extends string = string> extends Va
   static isValid(candidate: string): boolean;
 }
 //#endregion
-export { EntityState as a, Entity as i, ValueObject as n, ValueObjectPluginContract as r, UuidIdentifier as t };
+export { Entity as n, EntityState as r, UuidIdentifier as t };
 //# sourceMappingURL=uuid-identifier.d.ts.map

package/dist/uuid-identifier.js

@@ -1,12 +1,7 @@
+import { t as UUID_PATTERN } from "./uuid.js";
 import { t as ValueObject } from "./value-object.js";
 //#region src/core/domain/uuid-identifier.ts
 /**
-* 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` —

package/dist/uuid-identifier.js.map

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

package/dist/uuid.cjs

@@ -0,0 +1,18 @@
+//#region src/core/shared/uuid.ts
+/**
+* Canonical RFC-4122 UUID (versions 1–5, variant 8/9/a/b), matched
+* case-insensitively. The single source of truth for the UUID format —
+* `UuidIdentifier` (domain ids) and `RequestedBy` (command actor) both
+* validate against this pattern, so an identity accepted at the application
+* boundary is always one the domain also considers valid.
+*/
+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;
+//#endregion
+Object.defineProperty(exports, "UUID_PATTERN", {
+	enumerable: true,
+	get: function() {
+		return UUID_PATTERN;
+	}
+});
+
+//# sourceMappingURL=uuid.cjs.map

package/dist/uuid.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.cjs","names":[],"sources":["../src/core/shared/uuid.ts"],"sourcesContent":["/**\n * Canonical RFC-4122 UUID (versions 1–5, variant 8/9/a/b), matched\n * case-insensitively. The single source of truth for the UUID format —\n * `UuidIdentifier` (domain ids) and `RequestedBy` (command actor) both\n * validate against this pattern, so an identity accepted at the application\n * boundary is always one the domain also considers valid.\n */\nconst UUID_PATTERN =\n    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n\nexport { UUID_PATTERN };\n"],"mappings":";;;;;;;;AAOA,MAAM,eACF"}

package/dist/uuid.js

@@ -0,0 +1,13 @@
+//#region src/core/shared/uuid.ts
+/**
+* Canonical RFC-4122 UUID (versions 1–5, variant 8/9/a/b), matched
+* case-insensitively. The single source of truth for the UUID format —
+* `UuidIdentifier` (domain ids) and `RequestedBy` (command actor) both
+* validate against this pattern, so an identity accepted at the application
+* boundary is always one the domain also considers valid.
+*/
+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;
+//#endregion
+export { UUID_PATTERN as t };
+
+//# sourceMappingURL=uuid.js.map

package/dist/uuid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.js","names":[],"sources":["../src/core/shared/uuid.ts"],"sourcesContent":["/**\n * Canonical RFC-4122 UUID (versions 1–5, variant 8/9/a/b), matched\n * case-insensitively. The single source of truth for the UUID format —\n * `UuidIdentifier` (domain ids) and `RequestedBy` (command actor) both\n * validate against this pattern, so an identity accepted at the application\n * boundary is always one the domain also considers valid.\n */\nconst UUID_PATTERN =\n    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n\nexport { UUID_PATTERN };\n"],"mappings":";;;;;;;;AAOA,MAAM,eACF"}