ddd-node 13.0.0-0 → 14.0.0

package/.editorconfig

@@ -0,0 +1,12 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = false
+insert_final_newline = false

package/dist/core/aggregate/base.d.ts

@@ -0,0 +1,12 @@
+import { EntityBase, EntityMetadata } from "../entity";
+import { AnyEvent, EventClassWithTypedConstructor } from "../message";
+import { Props, PropsOf } from "../model";
+export interface AggregateMetadata extends EntityMetadata {
+    version: number;
+}
+export declare abstract class AggregateBase<P extends Props> extends EntityBase<P> {
+    protected readonly _version: number;
+    constructor(metadata: AggregateMetadata, props?: P);
+    abstract getVersion(): number;
+    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): E;
+}

package/dist/core/aggregate/base.js

@@ -0,0 +1,15 @@
+import { EntityBase } from "../entity";
+export class AggregateBase extends EntityBase {
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._version = metadata.version;
+    }
+    newEvent(eventClass, props) {
+        const eventSource = {
+            aggregate: this.modelName(),
+            id: this.id(),
+            version: this.getVersion(),
+        };
+        return eventClass.newEvent(eventSource, props);
+    }
+}

package/dist/core/aggregate/event-sourced-aggregate.d.ts

@@ -0,0 +1,48 @@
+import { Class } from "type-fest";
+import { ClassStatic } from "../../types";
+import { Id } from "../id";
+import { AnyCommand, AnyEvent, EventClassWithTypedConstructor } from "../message";
+import { Props, PropsOf } from "../model";
+import { AggregateBase, AggregateMetadata } from "./base";
+export interface SnapshotMetadata extends AggregateMetadata {
+}
+export interface Snapshot<T extends AnyEventSourcedAggregate> {
+    metadata: SnapshotMetadata;
+    props: PropsOf<T>;
+}
+export declare class EventSourcedAggregateBase<P extends Props> extends AggregateBase<P> {
+    private _handledCommands;
+    private _pastEvents;
+    private _events;
+    constructor(metadata: AggregateMetadata, props?: P);
+    static newStream<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClassWithTypedConstructor<T>, id?: Id): T;
+    static fromStream<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClassWithTypedConstructor<T>, id: Id, pastEvents?: AnyEvent[]): T;
+    static fromSnapshot<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClassWithTypedConstructor<T>, snapshot: Snapshot<T>, pastEventsAfterSnapshot?: AnyEvent[]): T;
+    static eventApplierMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): Map<string, EventApplier>;
+    static commandHandlerMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): Map<string, CommandHandler>;
+    getVersion(): number;
+    getPastEvents(): AnyEvent[];
+    getEvents(): AnyEvent[];
+    getHandledCommands(): AnyCommand[];
+    eventApplierMap(): Map<string, EventApplier>;
+    hasNewEvent(): boolean;
+    getApplierForEvent<E extends AnyEvent>(event: E): EventApplier<E>;
+    private validateEventBeforeApply;
+    private _applyEvent;
+    private applyPastEvent;
+    private applyPastEvents;
+    applyEvent<E extends AnyEvent>(event: E): void;
+    applyEvents(events: AnyEvent[]): void;
+    applyNewEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): void;
+    commandHandlerMap(): Map<string, CommandHandler>;
+    getHandlerForCommand<C extends AnyCommand>(command: C): CommandHandler<C, AnyEvent | AnyEvent[]>;
+    handleCommand<C extends AnyCommand>(command: C): AnyEvent[];
+    snap(): Snapshot<this>;
+}
+export type AnyEventSourcedAggregate = EventSourcedAggregateBase<Props>;
+export interface EventSourcedAggregateClass<T extends AnyEventSourcedAggregate = AnyEventSourcedAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EventSourcedAggregateBase<PropsOf<T>>> {
+}
+export interface EventSourcedAggregateClassWithTypedConstructor<T extends AnyEventSourcedAggregate = AnyEventSourcedAggregate> extends EventSourcedAggregateClass<T, ConstructorParameters<typeof EventSourcedAggregateBase<PropsOf<T>>>> {
+}
+export type EventApplier<T extends AnyEvent = AnyEvent> = (event: T) => void;
+export type CommandHandler<T extends AnyCommand = AnyCommand, U extends AnyEvent | AnyEvent[] = AnyEvent | AnyEvent[]> = (command: T) => U;

package/dist/core/aggregate/event-sourced-aggregate.js

@@ -0,0 +1,130 @@
+import { getCommandHandlerMap, getEventApplierMap } from "../../meta";
+import { toArray } from "../../utils";
+import { AggregateBase } from "./base";
+export class EventSourcedAggregateBase extends AggregateBase {
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._handledCommands = [];
+        this._events = [];
+        this._pastEvents = [];
+    }
+    static newStream(id) {
+        return new this({
+            id: this.id(id),
+            version: 0,
+        });
+    }
+    static fromStream(id, pastEvents = []) {
+        const instance = this.newStream(id);
+        instance.applyPastEvents(pastEvents);
+        return instance;
+    }
+    static fromSnapshot(snapshot, pastEventsAfterSnapshot = []) {
+        const { metadata, props } = snapshot;
+        const instance = new this(metadata, props);
+        instance.applyPastEvents(pastEventsAfterSnapshot);
+        return instance;
+    }
+    static eventApplierMap() {
+        return getEventApplierMap(this.prototype);
+    }
+    static commandHandlerMap() {
+        return getCommandHandlerMap(this.prototype);
+    }
+    getVersion() {
+        return this._version + this._pastEvents.length + this._events.length;
+    }
+    getPastEvents() {
+        return [...this._pastEvents];
+    }
+    getEvents() {
+        return [...this._events];
+    }
+    getHandledCommands() {
+        return [...this._handledCommands];
+    }
+    eventApplierMap() {
+        return this.constructor.eventApplierMap();
+    }
+    hasNewEvent() {
+        return Boolean(this._events.length);
+    }
+    getApplierForEvent(event) {
+        const eventName = event.modelName();
+        const applier = this.eventApplierMap().get(eventName);
+        if (!applier)
+            throw new Error("Event applier not found");
+        return applier;
+    }
+    validateEventBeforeApply(event) {
+        const eventSource = event.getSource();
+        if (eventSource.aggregate !== this.modelName())
+            throw new Error("Invalid source type");
+        if (!eventSource.id.equals(this._id))
+            throw new Error("Invalid source id");
+        if (eventSource.version !== this.getVersion())
+            throw new Error("Invalid source version");
+    }
+    _applyEvent(event) {
+        const applier = this.getApplierForEvent(event);
+        this.validateEventBeforeApply(event);
+        applier.call(this, event);
+    }
+    applyPastEvent(event) {
+        if (this.hasNewEvent())
+            throw new Error();
+        this._applyEvent(event);
+        this._pastEvents.push(event);
+    }
+    applyPastEvents(pastEvents) {
+        pastEvents.forEach((pastEvent) => {
+            this.applyPastEvent(pastEvent);
+        });
+    }
+    applyEvent(event) {
+        this._applyEvent(event);
+        this._events.push(event);
+    }
+    applyEvents(events) {
+        events.forEach((event) => {
+            this.applyEvent(event);
+        });
+    }
+    applyNewEvent(eventClass, props) {
+        this.applyEvent(this.newEvent(eventClass, props));
+    }
+    commandHandlerMap() {
+        return this.constructor.commandHandlerMap();
+    }
+    getHandlerForCommand(command) {
+        const commandName = command.modelName();
+        const handler = this.commandHandlerMap().get(commandName);
+        if (!handler)
+            throw new Error("Command handler not found");
+        return handler;
+    }
+    handleCommand(command) {
+        const handler = this.getHandlerForCommand(command);
+        const events = toArray(handler.call(this, command));
+        events.forEach((event) => {
+            event.setContext({
+                correlationId: command.getContext()?.correlationId,
+                causationId: command.id().value,
+            });
+        });
+        this.applyEvents(events);
+        this._handledCommands.push(command);
+        return events;
+    }
+    snap() {
+        if (!this._props)
+            throw new Error();
+        return {
+            metadata: {
+                id: this.id(),
+                version: this.getVersion(),
+            },
+            props: this.props(),
+        };
+    }
+}

package/dist/core/aggregate/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./state-aggregate";
+export * from "./event-sourced-aggregate";
+export * from "./types";

package/dist/core/aggregate/index.js

@@ -0,0 +1,3 @@
+export * from "./state-aggregate";
+export * from "./event-sourced-aggregate";
+export * from "./types";

package/dist/core/aggregate/state-aggregate.d.ts

@@ -0,0 +1,22 @@
+import { Class } from "type-fest";
+import { ClassStatic } from "../../types";
+import { Id } from "../id";
+import { AnyEvent, EventClass } from "../message";
+import { Props, PropsOf } from "../model";
+import { AggregateBase, AggregateMetadata } from "./base";
+export declare class StateAggregateBase<P extends Props> extends AggregateBase<P> {
+    private _events;
+    constructor(metadata: AggregateMetadata, props: P);
+    static newAggregate<T extends AnyStateAggregate>(this: StateAggregateClassWithTypedConstructor<T>, props: PropsOf<T>, id?: Id): T;
+    props(): P;
+    getVersion(): number;
+    getEvents(): AnyEvent[];
+    protected recordEvent<E extends AnyEvent>(event: E): void;
+    protected recordEvent<E extends AnyEvent>(eventClass: EventClass<E>, props: PropsOf<E>): void;
+    clearEvents(): void;
+}
+export type AnyStateAggregate = StateAggregateBase<Props>;
+export interface StateAggregateClass<T extends AnyStateAggregate = AnyStateAggregate, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof StateAggregateBase<PropsOf<T>>> {
+}
+export interface StateAggregateClassWithTypedConstructor<T extends AnyStateAggregate = AnyStateAggregate> extends StateAggregateClass<T, ConstructorParameters<typeof StateAggregateBase<PropsOf<T>>>> {
+}

package/dist/core/aggregate/state-aggregate.js

@@ -0,0 +1,35 @@
+import { AggregateBase } from "./base";
+export class StateAggregateBase extends AggregateBase {
+    constructor(metadata, props) {
+        super(metadata, props);
+        this._events = [];
+    }
+    static newAggregate(props, id) {
+        return new this({
+            id: this.id(id),
+            version: 0,
+        }, props);
+    }
+    props() {
+        return super.props();
+    }
+    getVersion() {
+        return this._version;
+    }
+    getEvents() {
+        return this._events;
+    }
+    recordEvent(param1, param2) {
+        let event;
+        if (typeof param1 === "function" && param2) {
+            event = this.newEvent(param1, param2);
+        }
+        else {
+            event = param1;
+        }
+        this._events.push(event);
+    }
+    clearEvents() {
+        this._events = [];
+    }
+}

package/dist/core/aggregate/types.d.ts

@@ -0,0 +1,4 @@
+import { AnyEventSourcedAggregate, EventSourcedAggregateClass } from "./event-sourced-aggregate";
+import { AnyStateAggregate, StateAggregateClass } from "./state-aggregate";
+export type AnyAggregate = AnyStateAggregate | AnyEventSourcedAggregate;
+export type AnyAggregateClass = StateAggregateClass | EventSourcedAggregateClass;

package/dist/core/aggregate/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/entity.d.ts

@@ -1,16 +1,19 @@
 import { Class } from "type-fest";
 import { Id } from "./id";
-import { ModelWithId, PropsOf } from "./model";
-import { ClassStatic } from "../types/index";
+import { ModelWithId, Props, PropsOf } from "./model";
+import { ClassStatic } from "../types";
 export interface EntityMetadata {
     readonly id: Id;
 }
-export declare abstract class EntityBase<Props extends object> extends ModelWithId<Props> {
-    constructor(metadata: EntityMetadata, props?: Props);
-    static isMutable(): boolean;
+export declare class EntityBase<P extends Props> extends ModelWithId<P> {
+    constructor(metadata: EntityMetadata, props?: P);
+    static mutable(): boolean;
     static newEntity<T extends AnyEntity>(this: EntityClassWithTypedConstructor<T>, props: PropsOf<T>, id?: Id): T;
 }
-export type AnyEntity = EntityBase<object>;
-export type EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> = Class<T, Arguments> & ClassStatic<typeof EntityBase<PropsOf<T>>>;
-export type EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> = EntityClass<T, ConstructorParameters<typeof EntityBase<PropsOf<T>>>>;
-export type EntityClassWithProps<P extends object> = EntityClass<EntityBase<P>>;
+export type AnyEntity = EntityBase<Props>;
+export interface EntityClass<T extends AnyEntity = AnyEntity, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EntityBase<PropsOf<T>>> {
+}
+export interface EntityClassWithTypedConstructor<T extends AnyEntity = AnyEntity> extends EntityClass<T, ConstructorParameters<typeof EntityBase<PropsOf<T>>>> {
+}
+export interface EntityClassWithProps<P extends Props> extends EntityClass<EntityBase<P>> {
+}

package/dist/core/entity.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityBase = void 0;
-const model_1 = require("./model");
-class EntityBase extends model_1.ModelWithId {
+import { ModelWithId } from "./model";
+export class EntityBase extends ModelWithId {
     constructor(metadata, props) {
         super(metadata.id);
         if (props)
             this.initializeProps(props);
     }
-    static isMutable() {
+    static mutable() {
         return true;
     }
     static newEntity(props, id) {
@@ -17,4 +14,3 @@ class EntityBase extends model_1.ModelWithId {
         }, props);
     }
 }
-exports.EntityBase = EntityBase;

package/dist/core/enum.d.ts

@@ -1,15 +1,17 @@
-import { ClassStatic } from "../types/index";
+import { ClassStatic } from "../types";
 import { Class } from "type-fest";
 import { ModelBase } from "./model";
 export type EnumValue = string | number;
-export interface EnumProps<V extends EnumValue> {
-    value: V;
+export interface EnumProps {
+    value: EnumValue;
 }
-export declare class EnumBase<V extends EnumValue = EnumValue> extends ModelBase<EnumProps<V>> {
-    static values<T extends EnumBase>(): void;
-    static parse<T extends EnumBase>(this: EnumClass<T>, value: EnumValue): void;
-    constructor(value: V);
-    value: V;
+export declare class EnumBase extends ModelBase<EnumProps> {
+    static values(): EnumBase[];
+    static parse<T extends EnumBase>(this: EnumClass<T>, providedValue: EnumValue): T | undefined;
+    constructor(value: EnumValue);
+    props(): EnumProps;
+    get value(): EnumValue;
+    equals<T extends EnumBase>(other: T): boolean;
+}
+export interface EnumClass<T extends EnumBase = EnumBase> extends Class<T>, ClassStatic<typeof EnumBase> {
 }
-export type ValueOf<T extends EnumBase> = T extends EnumBase<infer V extends EnumValue> ? V : never;
-export type EnumClass<T extends EnumBase = EnumBase> = Class<T> & ClassStatic<typeof EnumBase>;

package/dist/core/enum.js

@@ -1,27 +1,35 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumBase = void 0;
-const _decorators_1 = require("../decorators/index");
-const model_1 = require("./model");
-class EnumBase extends model_1.ModelBase {
-    static values() { }
-    static parse(value) { }
+import { ModelBase } from "./model";
+export class EnumBase extends ModelBase {
+    static values() {
+        return Array.from(this.ownStaticValues().values()).map((staticValue) => staticValue.value);
+    }
+    static parse(providedValue) {
+        let key;
+        this.ownStaticValues().forEach((staticValue, staticValueKey) => {
+            if (staticValue.value instanceof this) {
+                const staticEnum = staticValue.value;
+                if (staticEnum.value === providedValue && !key) {
+                    key = staticValueKey;
+                }
+            }
+        });
+        if (key)
+            return this.ownStaticValues().get(key)?.value;
+        return undefined;
+    }
     constructor(value) {
         super();
         this.initializeProps({ value });
     }
+    props() {
+        return super.props();
+    }
+    get value() {
+        return this._props.value;
+    }
+    equals(other) {
+        const equalType = other instanceof this.constructor;
+        const equalValue = other.value === this.value;
+        return equalType && equalValue;
+    }
 }
-exports.EnumBase = EnumBase;
-__decorate([
-    _decorators_1.Prop,
-    __metadata("design:type", Object)
-], EnumBase.prototype, "value", void 0);

package/dist/core/id/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./snowflake";
+export * from "./uuid4";

package/dist/core/id/common/index.js

@@ -0,0 +1,2 @@
+export * from "./snowflake";
+export * from "./uuid4";

package/dist/core/id/common/snowflake.d.ts

@@ -0,0 +1,9 @@
+import { SnowflakeOpts } from "nodejs-snowflake";
+import { IIdService } from "../interface";
+export declare class SnowflakeIdService implements IIdService<string> {
+    private _snowflake;
+    constructor(options?: SnowflakeOpts);
+    validateValue(value: string): void;
+    generateValue(): string;
+    compareValue(v1: string, v2: string): boolean;
+}

package/dist/core/id/common/snowflake.js

@@ -0,0 +1,13 @@
+import { Snowflake } from "nodejs-snowflake";
+export class SnowflakeIdService {
+    constructor(options) {
+        this._snowflake = new Snowflake(options);
+    }
+    validateValue(value) { }
+    generateValue() {
+        return this._snowflake.getUniqueID().toString(16);
+    }
+    compareValue(v1, v2) {
+        return v1 === v2;
+    }
+}

package/dist/core/id/common/uuid4.d.ts

@@ -0,0 +1,6 @@
+import { IIdService } from "../interface";
+export declare class Uuid4Service implements IIdService<string> {
+    validateValue(value: string): void;
+    generateValue(): string;
+    compareValue(v1: string, v2: string): boolean;
+}

package/dist/core/id/common/uuid4.js

@@ -0,0 +1,17 @@
+import { v4, validate, version } from "uuid";
+export class Uuid4Service {
+    validateValue(value) {
+        const isUuid = validate(value);
+        const isV4 = version(value) === 4;
+        if (!isUuid)
+            throw new Error("Id value is invalid for uuid type");
+        if (!isV4)
+            throw new Error("Version of uuid value must be 4");
+    }
+    generateValue() {
+        return v4();
+    }
+    compareValue(v1, v2) {
+        return v1 === v2;
+    }
+}

package/dist/core/id/id.d.ts

@@ -1,6 +1,8 @@
-export declare class Id {
-    private readonly _value;
-    constructor(value: string);
-    get value(): string;
-    equals(id: Id): boolean;
+import { IId, IIdService } from "./interface";
+export declare class Id<T = any> implements IId<T> {
+    private _service;
+    private _value;
+    constructor(service: IIdService<T>, idOrValue?: Id<T> | T);
+    get value(): T;
+    equals(id: Id<T>): boolean;
 }

package/dist/core/id/id.js

@@ -1,15 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Id = void 0;
-class Id {
-    constructor(value) {
-        this._value = value;
+export class Id {
+    constructor(service, idOrValue) {
+        this._service = service;
+        if (idOrValue) {
+            if (idOrValue instanceof Id)
+                this._value = idOrValue.value;
+            else
+                this._value = idOrValue;
+        }
+        else
+            this._value = this._service.generateValue();
+        this._service.validateValue(this._value);
     }
     get value() {
         return this._value;
     }
     equals(id) {
-        return this._value === id._value;
+        return this._service.compareValue(id._value, this._value);
     }
 }
-exports.Id = Id;

package/dist/core/id/index.d.ts

@@ -1,3 +1,3 @@
+export * from "./interface";
 export * from "./id";
-export * from "./id-generator";
-export * from "./built";
+export * from "./common";

package/dist/core/id/index.js

@@ -1,19 +1,3 @@
-"use strict";
-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 });
-__exportStar(require("./id"), exports);
-__exportStar(require("./id-generator"), exports);
-__exportStar(require("./built"), exports);
+export * from "./interface";
+export * from "./id";
+export * from "./common";

package/dist/core/id/interface.d.ts

@@ -0,0 +1,10 @@
+export interface IId<T = any> {
+    value: T;
+    equals(id: IId<T>): boolean;
+}
+export type IdValueOf<T extends IId> = T extends IId<infer V> ? V : never;
+export interface IIdService<T = any> {
+    validateValue(value: T): void;
+    generateValue(): T;
+    compareValue(v1: T, v2: T): boolean;
+}

package/dist/core/id/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/core/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./model";
 export * from "./id";
-export * from "./error";
 export * from "./aggregate";
 export * from "./entity";
 export * from "./enum";

package/dist/core/index.js

@@ -1,25 +1,8 @@
-"use strict";
-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 });
-__exportStar(require("./model"), exports);
-__exportStar(require("./id"), exports);
-__exportStar(require("./error"), exports);
-__exportStar(require("./aggregate"), exports);
-__exportStar(require("./entity"), exports);
-__exportStar(require("./enum"), exports);
-__exportStar(require("./message"), exports);
-__exportStar(require("./value-object"), exports);
-__exportStar(require("./repository"), exports);
+export * from "./model";
+export * from "./id";
+export * from "./aggregate";
+export * from "./entity";
+export * from "./enum";
+export * from "./message";
+export * from "./value-object";
+export * from "./repository";