ddd-node 13.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.js → aggregate/event-sourced-aggregate.js}

@@ -1,57 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AggregateESBase = exports.AggregateBase = exports.AggregateCore = void 0;
-const _utils_1 = require("../utils/index");
-const entity_1 = require("./entity");
-const _meta_1 = require("../meta/index");
-class AggregateCore extends entity_1.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);
-    }
-}
-exports.AggregateCore = AggregateCore;
-class AggregateBase extends AggregateCore {
-    constructor(metadata, props) {
-        super(metadata, props);
-        this._events = [];
-    }
-    static newAggregate(props, id) {
-        return new this({
-            id: this.id(id),
-            version: 0,
-        }, 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 = [];
-    }
-}
-exports.AggregateBase = AggregateBase;
-class AggregateESBase extends AggregateCore {
+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 = [];
@@ -64,44 +14,44 @@ class AggregateESBase extends AggregateCore {
             version: 0,
         });
     }
-    static fromStream(id, events = []) {
+    static fromStream(id, pastEvents = []) {
         const instance = this.newStream(id);
-        instance.applyPastEvents(events);
+        instance.applyPastEvents(pastEvents);
         return instance;
     }
-    static fromSnapshot(snapshot, events = []) {
+    static fromSnapshot(snapshot, pastEventsAfterSnapshot = []) {
         const { metadata, props } = snapshot;
         const instance = new this(metadata, props);
-        instance.applyPastEvents(events);
+        instance.applyPastEvents(pastEventsAfterSnapshot);
         return instance;
     }
-    static eventAppliersMap() {
-        return (0, _meta_1.getEventAppliersMap)(this.prototype);
+    static eventApplierMap() {
+        return getEventApplierMap(this.prototype);
     }
-    static commandHandlersMap() {
-        return (0, _meta_1.getCommandHandlersMap)(this.prototype);
+    static commandHandlerMap() {
+        return getCommandHandlerMap(this.prototype);
     }
     getVersion() {
         return this._version + this._pastEvents.length + this._events.length;
     }
     getPastEvents() {
-        return this._pastEvents;
+        return [...this._pastEvents];
     }
     getEvents() {
-        return this._events;
+        return [...this._events];
     }
     getHandledCommands() {
-        return this._handledCommands;
+        return [...this._handledCommands];
     }
-    eventAppliersMap() {
-        return this.constructor.eventAppliersMap();
+    eventApplierMap() {
+        return this.constructor.eventApplierMap();
     }
-    hasEvent() {
+    hasNewEvent() {
         return Boolean(this._events.length);
     }
     getApplierForEvent(event) {
         const eventName = event.modelName();
-        const applier = this.eventAppliersMap().get(eventName);
+        const applier = this.eventApplierMap().get(eventName);
         if (!applier)
             throw new Error("Event applier not found");
         return applier;
@@ -121,7 +71,7 @@ class AggregateESBase extends AggregateCore {
         applier.call(this, event);
     }
     applyPastEvent(event) {
-        if (this.hasEvent())
+        if (this.hasNewEvent())
             throw new Error();
         this._applyEvent(event);
         this._pastEvents.push(event);
@@ -140,23 +90,25 @@ class AggregateESBase extends AggregateCore {
             this.applyEvent(event);
         });
     }
-    commandHandlersMap() {
-        return this.constructor.commandHandlersMap();
+    applyNewEvent(eventClass, props) {
+        this.applyEvent(this.newEvent(eventClass, props));
+    }
+    commandHandlerMap() {
+        return this.constructor.commandHandlerMap();
     }
     getHandlerForCommand(command) {
         const commandName = command.modelName();
-        const handler = this.commandHandlersMap().get(commandName);
+        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 = (0, _utils_1.toArray)(handler.call(this, command));
+        const events = toArray(handler.call(this, command));
         events.forEach((event) => {
-            var _a;
             event.setContext({
-                correlationId: (_a = command.getContext()) === null || _a === void 0 ? void 0 : _a.correlationId,
+                correlationId: command.getContext()?.correlationId,
                 causationId: command.id().value,
             });
         });
@@ -176,4 +128,3 @@ class AggregateESBase extends AggregateCore {
         };
     }
 }
-exports.AggregateESBase = AggregateESBase;

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,19 +1,19 @@
 import { Class } from "type-fest";
 import { Id } from "./id";
 import { ModelWithId, Props, PropsOf } from "./model";
-import { ClassStatic } from "../types/index";
+import { ClassStatic } from "../types";
 export interface EntityMetadata {
     readonly id: Id;
 }
-export declare abstract class EntityBase<P extends Props> extends ModelWithId<P> {
+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 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 object> extends EntityClass<EntityBase<P>> {
+export interface EntityClassWithProps<P extends Props> extends EntityClass<EntityBase<P>> {
 }

package/dist/core/entity.js

@@ -1,8 +1,5 @@
-"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)
@@ -17,4 +14,3 @@ class EntityBase extends model_1.ModelWithId {
         }, props);
     }
 }
-exports.EntityBase = EntityBase;

package/dist/core/enum.d.ts

@@ -1,4 +1,4 @@
-import { ClassStatic } from "../types/index";
+import { ClassStatic } from "../types";
 import { Class } from "type-fest";
 import { ModelBase } from "./model";
 export type EnumValue = string | number;
@@ -9,7 +9,8 @@ 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);
-    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> {

package/dist/core/enum.js

@@ -1,23 +1,9 @@
-"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 {
+import { ModelBase } from "./model";
+export class EnumBase extends ModelBase {
     static values() {
         return Array.from(this.ownStaticValues().values()).map((staticValue) => staticValue.value);
     }
     static parse(providedValue) {
-        var _a;
         let key;
         this.ownStaticValues().forEach((staticValue, staticValueKey) => {
             if (staticValue.value instanceof this) {
@@ -28,21 +14,22 @@ class EnumBase extends model_1.ModelBase {
             }
         });
         if (key)
-            return (_a = this.ownStaticValues().get(key)) === null || _a === void 0 ? void 0 : _a.value;
+            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([
-    (0, _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";