@cqrs-ddd/core 0.2.0

package/dist/domain/rules/number.rule.js

@@ -0,0 +1,81 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberRule = numberRule;
+const rule_support_1 = require("./rule-support");
+function assertBound(name, value) {
+    if (value !== undefined && !Number.isFinite(value)) {
+        throw new TypeError(`numberRule: ${name} must be a finite number.`);
+    }
+}
+/**
+ * Defines the rule for one number field of an aggregate: declared once, used
+ * by the aggregate to parse the value, and read by other layers (such as a
+ * request schema) for its limits.
+ *
+ * `parse(value)` checks, in this order:
+ * 1. `null` or `undefined`: `null`, or a `required` violation;
+ * 2. not a number: a `type` violation (a numeric string is not converted);
+ * 3. `NaN` or an infinity: a `finite` violation;
+ * 4. with `integer`, not a safe integer: an `integer` violation;
+ * 5. `min`, then `max`.
+ *
+ * @param options - The field name, its constraints and its error.
+ * @returns The frozen rule.
+ * @throws TypeError when an option is invalid: an empty `field`, a bound that
+ *   is not a finite number, or `min` above `max`.
+ *
+ * @example
+ * ```ts
+ * export class Order extends RootEntity<OrderSnapshot> {
+ *   static readonly rules = {
+ *     quantity: numberRule({
+ *       field: 'quantity',
+ *       integer: true,
+ *       min: 1,
+ *       max: 100,
+ *       error: (violation) => new InvalidQuantityException(violation),
+ *     }),
+ *   } as const;
+ *
+ *   @Mutable<number>({ normalize: (value) => Order.rules.quantity.parse(value) })
+ *   private _quantity: number;
+ * }
+ *
+ * Order.rules.quantity.parse(0);
+ * // throws InvalidQuantityException: "quantity must be at least 1."
+ * ```
+ */
+function numberRule(options) {
+    (0, rule_support_1.assertField)(options.field, 'numberRule');
+    assertBound('min', options.min);
+    assertBound('max', options.max);
+    const { field, required = true, integer = false, min, max } = options;
+    if (min !== undefined && max !== undefined && min > max) {
+        throw new TypeError('numberRule: min must not exceed max.');
+    }
+    const fail = (0, rule_support_1.violationThrower)(options.error);
+    const parse = (value) => {
+        if (value === null || value === undefined) {
+            return required ? fail({ field, rule: 'required' }) : null;
+        }
+        if (typeof value !== 'number') {
+            return fail({ field, rule: 'type', expected: 'number' });
+        }
+        if (!Number.isFinite(value)) {
+            return fail({ field, rule: 'finite' });
+        }
+        if (integer && !Number.isSafeInteger(value)) {
+            return fail({ field, rule: 'integer' });
+        }
+        if (min !== undefined && value < min) {
+            return fail({ field, rule: 'min', limit: min });
+        }
+        if (max !== undefined && value > max) {
+            return fail({ field, rule: 'max', limit: max });
+        }
+        return value;
+    };
+    return Object.freeze({ ...options, parse });
+}
+//# sourceMappingURL=number.rule.js.map

package/dist/domain/rules/number.rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.rule.js","sourceRoot":"","sources":["../../../domain/rules/number.rule.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AA8FtE,gCAoCC;AAhID,iDAA+D;AAgD/D,SAAS,WAAW,CAAC,IAAY,EAAE,KAAyB;IAC1D,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,SAAS,CAAC,eAAe,IAAI,2BAA2B,CAAC,CAAC;IACtE,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,SAAgB,UAAU,CACxB,OAAiB;IAEjB,IAAA,0BAAW,EAAC,OAAO,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACzC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IAChC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IAChC,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC;IACtE,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC;QACxD,MAAM,IAAI,SAAS,CAAC,sCAAsC,CAAC,CAAC;IAC9D,CAAC;IAED,MAAM,IAAI,GAAG,IAAA,+BAAgB,EAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAE7C,MAAM,KAAK,GAAG,CAAC,KAAc,EAAiB,EAAE;QAC9C,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC1C,OAAO,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC7D,CAAC;QACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3D,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5C,OAAO,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;QAC1C,CAAC;QACD,IAAI,GAAG,KAAK,SAAS,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;YACrC,OAAO,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;QAClD,CAAC;QACD,IAAI,GAAG,KAAK,SAAS,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;YACrC,OAAO,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,CAAyB,CAAC;AACtE,CAAC"}

package/dist/domain/rules/rule-support.d.ts

@@ -0,0 +1,6 @@
+import type { ValueViolation, ValueViolationError } from './value-violation';
+/** Throws a `TypeError` naming the rule when `field` is not a non-empty string. */
+export declare function assertField(field: unknown, rule: string): void;
+/** Returns a function that throws the rule's error for a violation, frozen. */
+export declare function violationThrower(error?: ValueViolationError): (violation: ValueViolation) => never;
+//# sourceMappingURL=rule-support.d.ts.map

package/dist/domain/rules/rule-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-support.d.ts","sourceRoot":"","sources":["../../../domain/rules/rule-support.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7E,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAI9D;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAC9B,KAAK,GAAE,mBAC+B,GACrC,CAAC,SAAS,EAAE,cAAc,KAAK,KAAK,CAItC"}

package/dist/domain/rules/rule-support.js

@@ -0,0 +1,19 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertField = assertField;
+exports.violationThrower = violationThrower;
+const invalid_value_exception_1 = require("../exceptions/invalid-value.exception");
+/** Throws a `TypeError` naming the rule when `field` is not a non-empty string. */
+function assertField(field, rule) {
+    if (typeof field !== 'string' || field.trim().length === 0) {
+        throw new TypeError(`${rule}: field must be a non-empty string.`);
+    }
+}
+/** Returns a function that throws the rule's error for a violation, frozen. */
+function violationThrower(error = (violation) => new invalid_value_exception_1.InvalidValueException(violation)) {
+    return (violation) => {
+        throw error(Object.freeze(violation));
+    };
+}
+//# sourceMappingURL=rule-support.js.map

package/dist/domain/rules/rule-support.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-support.js","sourceRoot":"","sources":["../../../domain/rules/rule-support.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AAMtE,kCAIC;AAGD,4CAOC;AAlBD,mFAA8E;AAG9E,mFAAmF;AACnF,SAAgB,WAAW,CAAC,KAAc,EAAE,IAAY;IACtD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3D,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,qCAAqC,CAAC,CAAC;IACpE,CAAC;AACH,CAAC;AAED,+EAA+E;AAC/E,SAAgB,gBAAgB,CAC9B,QAA6B,CAAC,SAAS,EAAE,EAAE,CACzC,IAAI,+CAAqB,CAAC,SAAS,CAAC;IAEtC,OAAO,CAAC,SAAS,EAAE,EAAE;QACnB,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IACxC,CAAC,CAAC;AACJ,CAAC"}

package/dist/domain/rules/text.rule.d.ts

@@ -0,0 +1,98 @@
+import type { ValueViolationError } from './value-violation';
+/** Options of {@link textRule}. */
+export interface TextRuleOptions {
+    /** Field name reported in the violation and in the default message. */
+    readonly field: string;
+    /**
+     * `false` accepts `null`, `undefined` and blank text, and normalizes them
+     * to `null`. Defaults to `true`: they are a `required` violation.
+     */
+    readonly required?: boolean;
+    /**
+     * Fewest characters after normalization, counted in UTF-16 code units like
+     * `String.length` and Zod's `.min()`.
+     */
+    readonly minLength?: number;
+    /**
+     * Most characters after normalization, counted like {@link minLength}. A
+     * column limit counted in code points, such as `varchar(n)`, is never
+     * exceeded by a value within it.
+     */
+    readonly maxLength?: number;
+    /**
+     * Pattern the normalized text must match. A `g` or `y` flag is rejected,
+     * because `test()` would then depend on the previous call.
+     */
+    readonly pattern?: RegExp;
+    /**
+     * `true` accepts tab, line feed and carriage return inside the text.
+     * Defaults to `false`: they are a `characters` violation.
+     */
+    readonly multiline?: boolean;
+    /**
+     * Builds the error thrown for a violation. Defaults to
+     * `InvalidValueException`.
+     */
+    readonly error?: ValueViolationError;
+}
+/** What {@link TextRule.parse} returns: `string | null` when not required. */
+export type TextRuleValue<TOptions extends TextRuleOptions> = TOptions extends {
+    readonly required: true;
+} ? string : TOptions extends {
+    readonly required: boolean;
+} ? string | null : string;
+/** A text rule: its options, frozen, and the parser that enforces them. */
+export type TextRule<TOptions extends TextRuleOptions = TextRuleOptions> = Readonly<TOptions> & {
+    /**
+     * Returns the value in Unicode NFC form and trimmed, or `null` for blank
+     * text the rule does not require. A standalone function: pass it without
+     * binding.
+     *
+     * @throws The `error` option's result, by default `InvalidValueException`.
+     */
+    readonly parse: (value: unknown) => TextRuleValue<TOptions>;
+};
+/**
+ * Defines the rule for one text field of an aggregate: declared once, used by
+ * the aggregate to parse the value, and read by other layers (such as a
+ * request schema) for its limits.
+ *
+ * `parse(value)` checks, in this order:
+ * 1. `null` or `undefined`: `null`, or a `required` violation;
+ * 2. not a string: a `type` violation;
+ * 3. an unpaired surrogate: a `characters` violation, since it cannot be
+ *    stored as UTF-8;
+ * 4. Unicode NFC normalization, then trimming; blank text is `null`, or a
+ *    `required` violation;
+ * 5. a control character (tab and line breaks too, unless `multiline`): a
+ *    `characters` violation;
+ * 6. `minLength`, `maxLength`, then `pattern`.
+ *
+ * @param options - The field name, its constraints and its error.
+ * @returns The frozen rule.
+ * @throws TypeError when an option is invalid: an empty `field`, a length
+ *   that is not a non-negative integer, `minLength` above `maxLength`, or a
+ *   `pattern` with a `g` or `y` flag.
+ *
+ * @example
+ * ```ts
+ * export class User extends RootEntity<UserSnapshot> {
+ *   static readonly rules = {
+ *     username: textRule({
+ *       field: 'username',
+ *       minLength: 3,
+ *       maxLength: 255,
+ *       error: (violation) => new InvalidUsernameException(violation),
+ *     }),
+ *   } as const;
+ *
+ *   @Mutable<string>({ normalize: (value) => User.rules.username.parse(value) })
+ *   private _username: string;
+ * }
+ *
+ * User.rules.username.parse('  Ana María  '); // 'Ana María'
+ * z.string().trim().min(User.rules.username.minLength); // a request schema
+ * ```
+ */
+export declare function textRule<const TOptions extends TextRuleOptions>(options: TOptions): TextRule<TOptions>;
+//# sourceMappingURL=text.rule.d.ts.map

package/dist/domain/rules/text.rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.rule.d.ts","sourceRoot":"","sources":["../../../domain/rules/text.rule.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,mCAAmC;AACnC,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAC;CACtC;AAED,8EAA8E;AAC9E,MAAM,MAAM,aAAa,CAAC,QAAQ,SAAS,eAAe,IAAI,QAAQ,SAAS;IAC7E,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;CACzB,GACG,MAAM,GACN,QAAQ,SAAS;IAAE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAC7C,MAAM,GAAG,IAAI,GACb,MAAM,CAAC;AAEb,2EAA2E;AAC3E,MAAM,MAAM,QAAQ,CAAC,QAAQ,SAAS,eAAe,GAAG,eAAe,IACrE,QAAQ,CAAC,QAAQ,CAAC,GAAG;IACnB;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,QAAQ,CAAC,CAAC;CAC7D,CAAC;AAaJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,QAAQ,SAAS,eAAe,EAC7D,OAAO,EAAE,QAAQ,GAChB,QAAQ,CAAC,QAAQ,CAAC,CA0DpB"}

package/dist/domain/rules/text.rule.js

@@ -0,0 +1,103 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textRule = textRule;
+const rule_support_1 = require("./rule-support");
+const CONTROL_CHARACTER = /\p{Cc}/u;
+const CONTROL_CHARACTER_EXCEPT_LINE_BREAK = /(?![\t\n\r])\p{Cc}/u;
+const UNPAIRED_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+function assertLength(name, value) {
+    if (value !== undefined && !(Number.isSafeInteger(value) && value >= 0)) {
+        throw new TypeError(`textRule: ${name} must be a non-negative integer.`);
+    }
+}
+/**
+ * Defines the rule for one text field of an aggregate: declared once, used by
+ * the aggregate to parse the value, and read by other layers (such as a
+ * request schema) for its limits.
+ *
+ * `parse(value)` checks, in this order:
+ * 1. `null` or `undefined`: `null`, or a `required` violation;
+ * 2. not a string: a `type` violation;
+ * 3. an unpaired surrogate: a `characters` violation, since it cannot be
+ *    stored as UTF-8;
+ * 4. Unicode NFC normalization, then trimming; blank text is `null`, or a
+ *    `required` violation;
+ * 5. a control character (tab and line breaks too, unless `multiline`): a
+ *    `characters` violation;
+ * 6. `minLength`, `maxLength`, then `pattern`.
+ *
+ * @param options - The field name, its constraints and its error.
+ * @returns The frozen rule.
+ * @throws TypeError when an option is invalid: an empty `field`, a length
+ *   that is not a non-negative integer, `minLength` above `maxLength`, or a
+ *   `pattern` with a `g` or `y` flag.
+ *
+ * @example
+ * ```ts
+ * export class User extends RootEntity<UserSnapshot> {
+ *   static readonly rules = {
+ *     username: textRule({
+ *       field: 'username',
+ *       minLength: 3,
+ *       maxLength: 255,
+ *       error: (violation) => new InvalidUsernameException(violation),
+ *     }),
+ *   } as const;
+ *
+ *   @Mutable<string>({ normalize: (value) => User.rules.username.parse(value) })
+ *   private _username: string;
+ * }
+ *
+ * User.rules.username.parse('  Ana María  '); // 'Ana María'
+ * z.string().trim().min(User.rules.username.minLength); // a request schema
+ * ```
+ */
+function textRule(options) {
+    (0, rule_support_1.assertField)(options.field, 'textRule');
+    assertLength('minLength', options.minLength);
+    assertLength('maxLength', options.maxLength);
+    const { field, required = true, minLength, maxLength, pattern, multiline = false, } = options;
+    if (minLength !== undefined &&
+        maxLength !== undefined &&
+        minLength > maxLength) {
+        throw new TypeError('textRule: minLength must not exceed maxLength.');
+    }
+    if (pattern !== undefined && (pattern.global || pattern.sticky)) {
+        throw new TypeError('textRule: pattern must not use the g or y flag.');
+    }
+    const fail = (0, rule_support_1.violationThrower)(options.error);
+    const controlCharacter = multiline
+        ? CONTROL_CHARACTER_EXCEPT_LINE_BREAK
+        : CONTROL_CHARACTER;
+    const parse = (value) => {
+        if (value === null || value === undefined) {
+            return required ? fail({ field, rule: 'required' }) : null;
+        }
+        if (typeof value !== 'string') {
+            return fail({ field, rule: 'type', expected: 'string' });
+        }
+        if (UNPAIRED_SURROGATE.test(value)) {
+            return fail({ field, rule: 'characters' });
+        }
+        const text = value.normalize('NFC').trim();
+        if (text.length === 0) {
+            return required ? fail({ field, rule: 'required' }) : null;
+        }
+        if (controlCharacter.test(text)) {
+            return fail({ field, rule: 'characters' });
+        }
+        if (minLength !== undefined && text.length < minLength) {
+            return fail({ field, rule: 'minLength', limit: minLength });
+        }
+        if (maxLength !== undefined && text.length > maxLength) {
+            return fail({ field, rule: 'maxLength', limit: maxLength });
+        }
+        if (pattern !== undefined && !pattern.test(text)) {
+            return fail({ field, rule: 'pattern' });
+        }
+        return text;
+    };
+    return Object.freeze({ ...options, parse });
+}
+//# sourceMappingURL=text.rule.js.map

package/dist/domain/rules/text.rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.rule.js","sourceRoot":"","sources":["../../../domain/rules/text.rule.ts"],"names":[],"mappings":"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"}

package/dist/domain/rules/value-violation.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The rule a value broke, as reported by {@link textRule} and
+ * {@link numberRule}. `field` is the rule's field name; `limit` is the
+ * configured bound of a length or range rule.
+ *
+ * | `rule` | Broken when the value |
+ * |---|---|
+ * | `required` | is `null`, `undefined` or blank, and the rule requires it |
+ * | `type` | is not a string (`textRule`) or not a number (`numberRule`) |
+ * | `characters` | contains a control character or an unpaired surrogate |
+ * | `minLength`, `maxLength` | is shorter or longer than `limit` |
+ * | `pattern` | does not match the rule's pattern |
+ * | `finite` | is `NaN` or infinite |
+ * | `integer` | is not a safe integer |
+ * | `min`, `max` | is below or above `limit` |
+ */
+export type ValueViolation = {
+    readonly field: string;
+    readonly rule: 'required';
+} | {
+    readonly field: string;
+    readonly rule: 'type';
+    readonly expected: 'string' | 'number';
+} | {
+    readonly field: string;
+    readonly rule: 'characters';
+} | {
+    readonly field: string;
+    readonly rule: 'minLength' | 'maxLength';
+    readonly limit: number;
+} | {
+    readonly field: string;
+    readonly rule: 'pattern';
+} | {
+    readonly field: string;
+    readonly rule: 'finite' | 'integer';
+} | {
+    readonly field: string;
+    readonly rule: 'min' | 'max';
+    readonly limit: number;
+};
+/** Builds the error a rule throws for a violation. */
+export type ValueViolationError = (violation: ValueViolation) => Error;
+//# sourceMappingURL=value-violation.d.ts.map

package/dist/domain/rules/value-violation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-violation.d.ts","sourceRoot":"","sources":["../../../domain/rules/value-violation.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACrD;IACE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACxC,GACD;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;CAAE,GACvD;IACE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,GACD;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAA;CAAE,GAC/D;IACE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEN,sDAAsD;AACtD,MAAM,MAAM,mBAAmB,GAAG,CAAC,SAAS,EAAE,cAAc,KAAK,KAAK,CAAC"}

package/dist/domain/rules/value-violation.js

@@ -0,0 +1,4 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=value-violation.js.map

package/dist/domain/rules/value-violation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-violation.js","sourceRoot":"","sources":["../../../domain/rules/value-violation.ts"],"names":[],"mappings":";AAAA,sEAAsE"}

package/dist/http/domain-error-http-status.d.ts

@@ -0,0 +1,43 @@
+import { DomainException } from '../domain/exceptions/domain.exception';
+/** HTTP answer for a {@link DomainException}, as plain values. */
+export interface DomainErrorHttpStatus {
+    /** HTTP status code. */
+    readonly statusCode: number;
+    /** Reason phrase of `statusCode`, such as `'Conflict'`. */
+    readonly error: string;
+    /**
+     * Message safe to return to the caller: the exception's own message, or a
+     * generic one when the exception message is meant for developers.
+     */
+    readonly message: string;
+}
+/**
+ * Maps this package's errors to an HTTP status, for any HTTP framework.
+ *
+ * | Exception | Status | Message |
+ * |---|---|---|
+ * | {@link ConcurrencyConflictError} | 409 Conflict | the exception's |
+ * | {@link EntityNotFoundException} | 404 Not Found | the exception's |
+ * | {@link MissingTenantContextError} | 500 Internal Server Error | `'Internal server error'` |
+ * | any other {@link DomainException} | 400 Bad Request | the exception's |
+ *
+ * A missing tenant is a server misconfiguration, not a caller mistake, so it
+ * answers 500 and keeps its message, which names the failed operation, out of
+ * the response.
+ *
+ * An application maps its own `DomainException` subclasses first and passes the
+ * rest here. Anything that is not a `DomainException` returns `undefined`, so
+ * the framework's default handling still applies.
+ *
+ * @example An Express error handler
+ * ```ts
+ * app.use((err, req, res, next) => {
+ *   const mapped = domainErrorHttpStatus(err);
+ *   if (!mapped) return next(err);
+ *   res.status(mapped.statusCode).json(mapped);
+ * });
+ * ```
+ */
+export declare function domainErrorHttpStatus(error: DomainException): DomainErrorHttpStatus;
+export declare function domainErrorHttpStatus(error: unknown): DomainErrorHttpStatus | undefined;
+//# sourceMappingURL=domain-error-http-status.d.ts.map

package/dist/http/domain-error-http-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-error-http-status.d.ts","sourceRoot":"","sources":["../../http/domain-error-http-status.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAIxE,kEAAkE;AAClE,MAAM,WAAW,qBAAqB;IACpC,wBAAwB;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,eAAe,GACrB,qBAAqB,CAAC;AACzB,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,GACb,qBAAqB,GAAG,SAAS,CAAC"}

package/dist/http/domain-error-http-status.js

@@ -0,0 +1,27 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.domainErrorHttpStatus = domainErrorHttpStatus;
+const concurrency_conflict_error_1 = require("../domain/exceptions/concurrency-conflict.error");
+const domain_exception_1 = require("../domain/exceptions/domain.exception");
+const entity_not_found_exception_1 = require("../domain/exceptions/entity-not-found.exception");
+const missing_tenant_context_exception_1 = require("../domain/exceptions/missing-tenant-context.exception");
+function domainErrorHttpStatus(error) {
+    if (!(error instanceof domain_exception_1.DomainException))
+        return undefined;
+    if (error instanceof missing_tenant_context_exception_1.MissingTenantContextError) {
+        return {
+            statusCode: 500,
+            error: 'Internal Server Error',
+            message: 'Internal server error',
+        };
+    }
+    if (error instanceof concurrency_conflict_error_1.ConcurrencyConflictError) {
+        return { statusCode: 409, error: 'Conflict', message: error.message };
+    }
+    if (error instanceof entity_not_found_exception_1.EntityNotFoundException) {
+        return { statusCode: 404, error: 'Not Found', message: error.message };
+    }
+    return { statusCode: 400, error: 'Bad Request', message: error.message };
+}
+//# sourceMappingURL=domain-error-http-status.js.map

package/dist/http/domain-error-http-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-error-http-status.js","sourceRoot":"","sources":["../../http/domain-error-http-status.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AAqDtE,sDAmBC;AAtED,gGAA2F;AAC3F,4EAAwE;AACxE,gGAA0F;AAC1F,4GAAkG;AAgDlG,SAAgB,qBAAqB,CACnC,KAAc;IAEd,IAAI,CAAC,CAAC,KAAK,YAAY,kCAAe,CAAC;QAAE,OAAO,SAAS,CAAC;IAE1D,IAAI,KAAK,YAAY,4DAAyB,EAAE,CAAC;QAC/C,OAAO;YACL,UAAU,EAAE,GAAG;YACf,KAAK,EAAE,uBAAuB;YAC9B,OAAO,EAAE,uBAAuB;SACjC,CAAC;IACJ,CAAC;IACD,IAAI,KAAK,YAAY,qDAAwB,EAAE,CAAC;QAC9C,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IACxE,CAAC;IACD,IAAI,KAAK,YAAY,oDAAuB,EAAE,CAAC;QAC7C,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IACzE,CAAC;IACD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;AAC3E,CAAC"}

package/dist/http/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * HTTP status mapping for this package's errors.
+ *
+ * It returns plain numbers and strings and loads no HTTP framework, so an
+ * application's own error handler or exception filter decides how to send it.
+ * HTTP stays out of `/domain` and `/application`.
+ */
+export * from './domain-error-http-status';
+//# sourceMappingURL=index.d.ts.map

package/dist/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../http/index.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,cAAc,4BAA4B,CAAC"}

package/dist/http/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * HTTP status mapping for this package's errors.
+ *
+ * It returns plain numbers and strings and loads no HTTP framework, so an
+ * application's own error handler or exception filter decides how to send it.
+ * HTTP stays out of `/domain` and `/application`.
+ */
+__exportStar(require("./domain-error-http-status"), exports);
+//# sourceMappingURL=index.js.map

package/dist/http/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../http/index.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;;;;;;;;;;;;;;AAEtE;;;;;;GAMG;AAEH,6DAA2C"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Convenience barrel re-exporting every layer.
+ *
+ * Prefer the layered entry points — `@cqrs-ddd/core/domain` and
+ * `.../application` — in domain and CQRS code so the layering is expressed by
+ * the import itself rather than only by convention.
+ */
+export * from './application/index';
+export * from './domain/index';
+export * from './http/index';
+export * from './persistence/index';
+export * from './types/Method.type';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Convenience barrel re-exporting every layer.
+ *
+ * Prefer the layered entry points — `@cqrs-ddd/core/domain` and
+ * `.../application` — in domain and CQRS code so the layering is expressed by
+ * the import itself rather than only by convention.
+ */
+__exportStar(require("./application/index"), exports);
+__exportStar(require("./domain/index"), exports);
+__exportStar(require("./http/index"), exports);
+__exportStar(require("./persistence/index"), exports);
+__exportStar(require("./types/Method.type"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";AAAA,sEAAsE;;;;;;;;;;;;;;;;AAEtE;;;;;;GAMG;AAEH,sDAAoC;AACpC,iDAA+B;AAC/B,+CAA6B;AAC7B,sDAAoC;AACpC,sDAAoC"}

package/dist/persistence/cache/cache-logger.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Receives the operational warnings of the cache decorators and adapters, such as
+ * a failed cache write or a miswired repository.
+ *
+ * Pass one through the `logger` option to route these warnings into an
+ * application's logging. `console` and a NestJS `Logger` both fit. Without it,
+ * warnings go to `console.warn` with a `[CacheDecorator]`-style prefix. A logger
+ * that throws never changes a repository result.
+ *
+ * @example
+ * ```ts
+ * @Cache<User, UserSnapshot>({
+ *   setKey: (user) => cacheKey(User.aggregateName, { id: user.id }),
+ *   logger: new Logger('UserCache'), // NestJS
+ * })
+ * ```
+ */
+export interface ICacheLogger {
+    warn(message: string): unknown;
+}
+/** The default {@link ICacheLogger}: `console.warn` with a `[context]` prefix. */
+export declare function consoleCacheLogger(context: string): ICacheLogger;
+/**
+ * Writes a warning without letting the logger change the caller's outcome:
+ * cache maintenance runs after a durable write, and a throwing logger must not
+ * turn that success into an error.
+ */
+export declare function safeWarn(logger: ICacheLogger, message: string): void;
+//# sourceMappingURL=cache-logger.d.ts.map

package/dist/persistence/cache/cache-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-logger.d.ts","sourceRoot":"","sources":["../../../persistence/cache/cache-logger.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC;AAED,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAMpE"}

package/dist/persistence/cache/cache-logger.js

@@ -0,0 +1,23 @@
+"use strict";
+/* Copyright (C) 2026-present Aristotelis — see repository license. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleCacheLogger = consoleCacheLogger;
+exports.safeWarn = safeWarn;
+/** The default {@link ICacheLogger}: `console.warn` with a `[context]` prefix. */
+function consoleCacheLogger(context) {
+    return { warn: (message) => console.warn(`[${context}] ${message}`) };
+}
+/**
+ * Writes a warning without letting the logger change the caller's outcome:
+ * cache maintenance runs after a durable write, and a throwing logger must not
+ * turn that success into an error.
+ */
+function safeWarn(logger, message) {
+    try {
+        logger.warn(message);
+    }
+    catch {
+        // The logger itself failed; the warning is dropped, the result is not.
+    }
+}
+//# sourceMappingURL=cache-logger.js.map

package/dist/persistence/cache/cache-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-logger.js","sourceRoot":"","sources":["../../../persistence/cache/cache-logger.ts"],"names":[],"mappings":";AAAA,sEAAsE;;AAwBtE,gDAEC;AAOD,4BAMC;AAhBD,kFAAkF;AAClF,SAAgB,kBAAkB,CAAC,OAAe;IAChD,OAAO,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,OAAO,KAAK,OAAO,EAAE,CAAC,EAAE,CAAC;AACxE,CAAC;AAED;;;;GAIG;AACH,SAAgB,QAAQ,CAAC,MAAoB,EAAE,OAAe;IAC5D,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IAAC,MAAM,CAAC;QACP,uEAAuE;IACzE,CAAC;AACH,CAAC"}