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

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

@@ -0,0 +1,17 @@
+import type { Clock, LogContext, Logger, LogLevel } from '../../application/index.js';
+export interface ConsoleLoggerOptions {
+    readonly level?: LogLevel;
+    readonly clock?: Clock;
+}
+export declare class ConsoleLogger implements Logger {
+    private static readonly levels;
+    private readonly output;
+    private readonly minimum;
+    private readonly clock;
+    constructor({ level, clock }?: ConsoleLoggerOptions);
+    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 write;
+}

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

@@ -0,0 +1,33 @@
+import { InternalErrorException } from '../../exceptions/index.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/package.json

@@ -1,6 +1,108 @@
 {
   "name": "@archi-code/ddd",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "3.0.0-alpha.1",
+  "keywords": [
+    "DDD",
+    "domain-driven design",
+    "hexagonal",
+    "clean architecture",
+    "value object",
+    "aggregate",
+    "domain events",
+    "use case",
+    "repository",
+    "node"
+  ],
+  "author": "Jose Guillermo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jguillermo/archi-code-core"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./exceptions": {
+      "import": {
+        "types": "./dist/esm/exceptions/index.d.ts",
+        "default": "./dist/esm/exceptions/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/exceptions/index.d.ts",
+        "default": "./dist/cjs/exceptions/index.js"
+      }
+    },
+    "./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": {
+    "*": {
+      "exceptions": [
+        "./dist/cjs/exceptions/index.d.ts"
+      ],
+      "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/"
+  ],
+  "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 .",
+    "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.5",
+    "uuid": "^11.1.1"
+  },
+  "releaseCommit": "bc311704e70020684524c1243de19329cb5c4511"
+}