@archi-code/ddd 0.0.0-stage → 3.0.0-alpha.2

package/dist/esm/infrastructure/logging/console-logger.js

@@ -0,0 +1,33 @@
+import { InternalErrorException } from '../exceptions/internal-error.exception.js';
+import { SystemClock } from '../clock/system-clock.js';
+import { LogSerializer } from './log-serializer.js';
+export class ConsoleLogger {
+    constructor({ level = 'info', clock = new SystemClock() } = {}) {
+        this.output = console;
+        this.minimum = ConsoleLogger.levels.indexOf(level);
+        if (this.minimum === -1) {
+            throw new InternalErrorException(`unknown log level "${String(level)}": use ${ConsoleLogger.levels.join(', ')}`);
+        }
+        this.clock = clock;
+    }
+    debug(message, context) {
+        this.write('debug', message, context);
+    }
+    info(message, context) {
+        this.write('info', message, context);
+    }
+    warn(message, context) {
+        this.write('warn', message, context);
+    }
+    error(message, context) {
+        this.write('error', message, context);
+    }
+    write(level, message, context) {
+        if (ConsoleLogger.levels.indexOf(level) < this.minimum) {
+            return;
+        }
+        const entry = { time: this.clock.now().toISOString(), level, message };
+        this.output[level](LogSerializer.line(entry, context));
+    }
+}
+ConsoleLogger.levels = ['debug', 'info', 'warn', 'error'];

package/dist/esm/infrastructure/logging/in-memory-logger.d.ts

@@ -0,0 +1,15 @@
+import type { LogContext, Logger, LogLevel } from '../../application/index.js';
+export interface LogEntry {
+    readonly level: LogLevel;
+    readonly message: string;
+    readonly context?: LogContext;
+}
+export declare class InMemoryLogger implements Logger {
+    private readonly recorded;
+    get entries(): readonly LogEntry[];
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+    private record;
+}

package/dist/esm/infrastructure/logging/in-memory-logger.js

@@ -0,0 +1,23 @@
+export class InMemoryLogger {
+    constructor() {
+        this.recorded = [];
+    }
+    get entries() {
+        return [...this.recorded];
+    }
+    debug(message, context) {
+        this.record('debug', message, context);
+    }
+    info(message, context) {
+        this.record('info', message, context);
+    }
+    warn(message, context) {
+        this.record('warn', message, context);
+    }
+    error(message, context) {
+        this.record('error', message, context);
+    }
+    record(level, message, context) {
+        this.recorded.push(context === undefined ? { level, message } : { level, message, context });
+    }
+}

package/dist/esm/infrastructure/logging/log-serializer.d.ts

@@ -0,0 +1,7 @@
+import type { LogContext } from '../../application/index.js';
+export declare class LogSerializer {
+    static line(entry: Readonly<Record<string, string>>, context: LogContext | undefined): string;
+    private static plain;
+    private static plainObject;
+    private static plainError;
+}

package/dist/esm/infrastructure/logging/log-serializer.js

@@ -0,0 +1,55 @@
+export class LogSerializer {
+    static line(entry, context) {
+        if (context === undefined) {
+            return JSON.stringify(entry);
+        }
+        try {
+            return JSON.stringify({ ...entry, context: LogSerializer.plain(context, new Set()) });
+        }
+        catch {
+            return JSON.stringify({ ...entry, context: '[Unserializable]' });
+        }
+    }
+    static plain(value, ancestors) {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value !== 'object' || value === null) {
+            return value;
+        }
+        if (ancestors.has(value)) {
+            return '[Circular]';
+        }
+        ancestors.add(value);
+        try {
+            return LogSerializer.plainObject(value, ancestors);
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    }
+    static plainObject(value, ancestors) {
+        if (value instanceof Error) {
+            return LogSerializer.plainError(value, ancestors);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => LogSerializer.plain(item, ancestors));
+        }
+        const { toJSON } = value;
+        if (typeof toJSON === 'function') {
+            return LogSerializer.plain(toJSON.call(value), ancestors);
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, LogSerializer.plain(item, ancestors)]));
+    }
+    static plainError(error, ancestors) {
+        const { code, errors, cause } = error;
+        return {
+            name: error.name,
+            message: error.message,
+            ...(typeof code === 'string' ? { code } : {}),
+            ...(Array.isArray(errors) ? { errors: LogSerializer.plain(errors, ancestors) } : {}),
+            ...(error.stack === undefined ? {} : { stack: error.stack }),
+            ...(cause === undefined ? {} : { cause: LogSerializer.plain(cause, ancestors) }),
+        };
+    }
+}

package/dist/esm/infrastructure/logging/silent-logger.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from '../../application/index.js';
+export declare class SilentLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}

package/dist/esm/infrastructure/logging/silent-logger.js

@@ -0,0 +1,14 @@
+export class SilentLogger {
+    debug() {
+        return undefined;
+    }
+    info() {
+        return undefined;
+    }
+    warn() {
+        return undefined;
+    }
+    error() {
+        return undefined;
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/shared/exceptions/abstract.exception.d.ts

@@ -0,0 +1,25 @@
+export interface ExceptionOptions {
+    cause?: unknown;
+}
+export type ExceptionCodeNames = Readonly<Record<string, string>>;
+export declare abstract class AbstractException extends Error {
+    private static readonly fallbackCode;
+    readonly cause?: unknown;
+    private readonly exceptionCodes;
+    private readonly codeNames;
+    readonly code: string;
+    private readonly createdAt;
+    static [Symbol.hasInstance](candidate: unknown): boolean;
+    constructor(message: string, exceptionCodes: string[], options?: ExceptionOptions, codeNames?: ExceptionCodeNames);
+    get timestamp(): Date;
+    get description(): string;
+    private labelOf;
+    print(): string;
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        description: string;
+        timestamp: string;
+    };
+}

package/dist/esm/shared/exceptions/abstract.exception.js

@@ -0,0 +1,55 @@
+var _a;
+import { ExceptionBrand } from './brand/exception-brand.js';
+export class AbstractException extends Error {
+    static [Symbol.hasInstance](candidate) {
+        return (Function.prototype[Symbol.hasInstance].call(this, candidate) ||
+            ExceptionBrand.matches(this, candidate));
+    }
+    constructor(message, exceptionCodes, options = {}, codeNames = {}) {
+        super(message);
+        this.name = this.constructor.name;
+        this.exceptionCodes = exceptionCodes;
+        this.codeNames = codeNames;
+        this.code =
+            exceptionCodes.length > 0
+                ? exceptionCodes[exceptionCodes.length - 1]
+                : _a.fallbackCode;
+        this.createdAt = Date.now();
+        if ('cause' in options) {
+            Object.defineProperty(this, 'cause', {
+                value: options.cause,
+                writable: true,
+                configurable: true,
+            });
+        }
+        ExceptionBrand.brandInstance(this, exceptionCodes);
+        Error.captureStackTrace?.(this, this.constructor);
+    }
+    get timestamp() {
+        return new Date(this.createdAt);
+    }
+    get description() {
+        return this.exceptionCodes.map((code) => `${this.labelOf(code)} (${code})`).join(', ');
+    }
+    labelOf(code) {
+        const name = Object.keys(this.codeNames).find((key) => this.codeNames[key] === code);
+        return name === undefined ? this.name : name.replace(/([A-Z])/g, ' $1').trim();
+    }
+    print() {
+        return `[${this.description}]: ${this.message}, ${this.timestamp.toISOString()}`;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            description: this.description,
+            timestamp: this.timestamp.toISOString(),
+        };
+    }
+}
+_a = AbstractException;
+AbstractException.fallbackCode = 'E000';
+(() => {
+    ExceptionBrand.brandClass(_a, ExceptionBrand.anyCode);
+})();

package/dist/esm/shared/exceptions/brand/exception-brand.d.ts

@@ -0,0 +1,6 @@
+export declare class ExceptionBrand {
+    static readonly anyCode = "*";
+    static brandClass(exceptionClass: object, code: string): void;
+    static brandInstance(exception: object, codes: readonly string[]): void;
+    static matches(exceptionClass: object, candidate: unknown): boolean;
+}

package/dist/esm/shared/exceptions/brand/exception-brand.js

@@ -0,0 +1,25 @@
+const INSTANCE_CODES = Symbol.for('@archi-code/ddd/exception-codes.v1');
+const CLASS_CODE = Symbol.for('@archi-code/ddd/exception-class-code.v1');
+export class ExceptionBrand {
+    static brandClass(exceptionClass, code) {
+        Object.defineProperty(exceptionClass, CLASS_CODE, { value: code });
+    }
+    static brandInstance(exception, codes) {
+        Object.defineProperty(exception, INSTANCE_CODES, { value: Object.freeze([...codes]) });
+    }
+    static matches(exceptionClass, candidate) {
+        if (!Object.prototype.hasOwnProperty.call(exceptionClass, CLASS_CODE)) {
+            return false;
+        }
+        if (typeof candidate !== 'object' || candidate === null) {
+            return false;
+        }
+        const codes = candidate[INSTANCE_CODES];
+        if (!Array.isArray(codes)) {
+            return false;
+        }
+        const code = exceptionClass[CLASS_CODE];
+        return code === ExceptionBrand.anyCode || codes.includes(code);
+    }
+}
+ExceptionBrand.anyCode = '*';

package/dist/esm/shared/exceptions/received/received-value.d.ts

@@ -0,0 +1,4 @@
+export declare class ReceivedValue {
+    static readonly maxLength = 64;
+    static describe(value: unknown): string;
+}

package/dist/esm/shared/exceptions/received/received-value.js

@@ -0,0 +1,9 @@
+import { anyToString } from '@archi-code/validation';
+export class ReceivedValue {
+    static describe(value) {
+        const text = typeof value === 'string' ? value : anyToString(value);
+        const shown = text.length > ReceivedValue.maxLength ? `${text.slice(0, ReceivedValue.maxLength)}…` : text;
+        return typeof value === 'string' ? `"${shown}"` : shown;
+    }
+}
+ReceivedValue.maxLength = 64;

package/dist/esm/shared/index.d.ts

@@ -0,0 +1,8 @@
+export { AbstractException } from './exceptions/abstract.exception.js';
+export type { ExceptionCodeNames, ExceptionOptions } from './exceptions/abstract.exception.js';
+export { ExceptionBrand } from './exceptions/brand/exception-brand.js';
+export { ReceivedValue } from './exceptions/received/received-value.js';
+export { IssueCollector } from './issue-collector.js';
+export type { IssueReader } from './issue-collector.js';
+export { IssueCollectionError } from './issue-collection-error.js';
+export type { CollectedIssue } from './issue-collection-error.js';

package/dist/esm/shared/index.js

@@ -0,0 +1,5 @@
+export { AbstractException } from './exceptions/abstract.exception.js';
+export { ExceptionBrand } from './exceptions/brand/exception-brand.js';
+export { ReceivedValue } from './exceptions/received/received-value.js';
+export { IssueCollector } from './issue-collector.js';
+export { IssueCollectionError } from './issue-collection-error.js';

package/dist/esm/shared/issue-collection-error.d.ts

@@ -0,0 +1,9 @@
+export interface CollectedIssue {
+    readonly field: string | null;
+    readonly code: string;
+    readonly message: string;
+}
+export declare class IssueCollectionError extends Error {
+    readonly issues: readonly CollectedIssue[];
+    constructor(issues: readonly CollectedIssue[]);
+}

package/dist/esm/shared/issue-collection-error.js

@@ -0,0 +1,7 @@
+export class IssueCollectionError extends Error {
+    constructor(issues) {
+        super(`${issues.length} issues collected`);
+        this.name = 'IssueCollectionError';
+        this.issues = Object.freeze([...issues]);
+    }
+}

package/dist/esm/shared/issue-collector.d.ts

@@ -0,0 +1,8 @@
+import type { CollectedIssue } from './issue-collection-error.js';
+export type IssueReader = (error: unknown) => readonly CollectedIssue[] | null;
+export declare class IssueCollector {
+    static collectFields(builds: Readonly<Record<string, () => unknown>>, readIssues: IssueReader): Record<string, unknown>;
+    static collectItems<Item, Built>(items: readonly Item[], build: (item: Item, index: number) => Built, readIssues: IssueReader): Built[];
+    private static collect;
+    private static issuesAt;
+}

package/dist/esm/shared/issue-collector.js

@@ -0,0 +1,37 @@
+import { IssueCollectionError } from './issue-collection-error.js';
+export class IssueCollector {
+    static collectFields(builds, readIssues) {
+        return Object.fromEntries(IssueCollector.collect(Object.entries(builds), readIssues));
+    }
+    static collectItems(items, build, readIssues) {
+        const builds = items.map((item, index) => [String(index), () => build(item, index)]);
+        return IssueCollector.collect(builds, readIssues).map(([, built]) => built);
+    }
+    static collect(builds, readIssues) {
+        const built = [];
+        const issues = [];
+        for (const [path, build] of builds) {
+            try {
+                built.push([path, build()]);
+            }
+            catch (error) {
+                issues.push(...IssueCollector.issuesAt(path, error, readIssues));
+            }
+        }
+        if (issues.length > 0) {
+            throw new IssueCollectionError(issues);
+        }
+        return built;
+    }
+    static issuesAt(path, error, readIssues) {
+        const issues = readIssues(error);
+        if (issues === null) {
+            throw error;
+        }
+        return issues.map((issue) => ({
+            field: issue.field === null ? path : `${path}.${issue.field}`,
+            code: issue.code,
+            message: issue.message,
+        }));
+    }
+}

package/package.json

@@ -1,6 +1,97 @@
 {
   "name": "@archi-code/ddd",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "3.0.0-alpha.2",
+  "keywords": [
+    "DDD",
+    "domain-driven design",
+    "hexagonal",
+    "clean architecture",
+    "value object",
+    "aggregate",
+    "domain events",
+    "use case",
+    "repository",
+    "node",
+    "browser"
+  ],
+  "author": "Jose Guillermo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jguillermo/archi-code-core"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./domain": {
+      "import": {
+        "types": "./dist/esm/domain/index.d.ts",
+        "default": "./dist/esm/domain/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/domain/index.d.ts",
+        "default": "./dist/cjs/domain/index.js"
+      }
+    },
+    "./application": {
+      "import": {
+        "types": "./dist/esm/application/index.d.ts",
+        "default": "./dist/esm/application/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/application/index.d.ts",
+        "default": "./dist/cjs/application/index.js"
+      }
+    },
+    "./infrastructure": {
+      "import": {
+        "types": "./dist/esm/infrastructure/index.d.ts",
+        "default": "./dist/esm/infrastructure/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/infrastructure/index.d.ts",
+        "default": "./dist/cjs/infrastructure/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "domain": [
+        "./dist/cjs/domain/index.d.ts"
+      ],
+      "application": [
+        "./dist/cjs/application/index.d.ts"
+      ],
+      "infrastructure": [
+        "./dist/cjs/infrastructure/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist/",
+    "SKILL.md",
+    "ddd-skills/"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "prebuild": "rm -rf dist || true",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json && node ../../scripts/fix-esm.js",
+    "build": "npm run build:cjs && npm run build:esm",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "check:types": "tsc -p tsconfig.json --noEmit --incremental false",
+    "check:dist": "node ../../scripts/check-dist.js && attw --pack . && node ../../scripts/check-browser.js",
+    "check:all": "npm run check:types && npm run test:coverage && npm run build && npm run check:dist"
+  },
+  "dependencies": {
+    "@archi-code/validation": "3.0.0-alpha.6",
+    "uuid": "^11.1.1"
+  },
+  "releaseCommit": "90204648d023639e296f0946e2c715b8a32a47ef"
+}