ddd-node 13.0.0 → 14.0.0

package/dist/core/message/command.d.ts

@@ -1,14 +1,17 @@
-import { ClassStatic } from "../../types/index";
+import { ClassStatic } from "../../types";
 import { Class } from "type-fest";
 import { Props, PropsOf } from "../model";
 import { MessageBase, MessageContext, MessageMetadata } from "./message";
-export interface CommandMetadata extends MessageMetadata {
+export interface CommandMetadata extends Omit<MessageMetadata, "messageType"> {
 }
-export declare abstract class CommandBase<P extends Props> extends MessageBase<P> {
+export declare class CommandBase<P extends Props> extends MessageBase<P> {
+    static readonly COMMAND_MESSAGE_TYPE = "command";
+    private _commandType;
     constructor(metadata: CommandMetadata, props: P);
-    static newCommand<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: PropsOf<T>, context?: MessageContext): T;
+    static newCommand<T extends AnyCommand>(this: CommandClassWithTypedConstructor<T>, props: PropsOf<T>, context?: MessageContext, timestamp?: number): T;
+    getCommandType(): void;
 }
-export type AnyCommand = CommandBase<any>;
+export type AnyCommand = CommandBase<Props>;
 export interface CommandClass<T extends AnyCommand = AnyCommand, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof CommandBase<PropsOf<T>>> {
 }
 export interface CommandClassWithTypedConstructor<T extends AnyCommand = AnyCommand> extends CommandClass<T, ConstructorParameters<typeof CommandBase<PropsOf<T>>>> {

package/dist/core/message/command.js

@@ -1,17 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandBase = void 0;
-const message_1 = require("./message");
-class CommandBase extends message_1.MessageBase {
+import { MessageBase } from "./message";
+export class CommandBase extends MessageBase {
     constructor(metadata, props) {
-        super(metadata, props);
+        super({ ...metadata, messageType: CommandBase.COMMAND_MESSAGE_TYPE }, props);
+        this._commandType = this.modelName();
     }
-    static newCommand(props, context) {
+    static newCommand(props, context, timestamp) {
         return new this({
             id: this.id(),
-            timestamp: Date.now(),
             context,
+            timestamp,
         }, props);
     }
+    getCommandType() {
+        this._commandType;
+    }
 }
-exports.CommandBase = CommandBase;
+CommandBase.COMMAND_MESSAGE_TYPE = "command";

package/dist/core/message/event.d.ts

@@ -1,4 +1,4 @@
-import { ClassStatic } from "../../types/index";
+import { ClassStatic } from "../../types";
 import { Class } from "type-fest";
 import { Id } from "../id";
 import { Props, PropsOf } from "../model";
@@ -8,21 +8,23 @@ export type EventSource = Readonly<{
     id: Id;
     version: number;
 }>;
-export interface EventMetadata extends MessageMetadata {
+export interface EventMetadata extends Omit<MessageMetadata, "messageType"> {
     source: EventSource;
 }
-export declare abstract class EventBase<P extends Props, R = any> extends MessageBase<P> {
+export declare class EventBase<P extends Props> extends MessageBase<P> {
+    static readonly EVENT_MESSAGE_TYPE = "event";
     private readonly _source;
+    private readonly _eventType;
     constructor(metadata: EventMetadata, props: P);
-    static newEvent<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, source: EventSource, props: PropsOf<T>, context?: MessageContext): T;
+    static newEvent<T extends AnyEvent>(this: EventClassWithTypedConstructor<T>, source: EventSource, props: PropsOf<T>, context?: MessageContext, timestamp?: number): T;
     getSource(): Readonly<{
         aggregate: string;
-        id: Id;
+        id: Id<any>;
         version: number;
     }>;
-    getRaw(): R | null;
+    getEventType(): string;
 }
-export type AnyEvent = EventBase<any>;
+export type AnyEvent = EventBase<Props>;
 export interface EventClass<T extends AnyEvent = AnyEvent, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EventBase<PropsOf<T>>> {
 }
 export interface EventClassWithTypedConstructor<T extends AnyEvent = AnyEvent> extends EventClass<T, ConstructorParameters<typeof EventBase<PropsOf<T>>>> {

package/dist/core/message/event.js

@@ -1,25 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventBase = void 0;
-const message_1 = require("./message");
-class EventBase extends message_1.MessageBase {
+import { MessageBase } from "./message";
+export class EventBase extends MessageBase {
     constructor(metadata, props) {
-        super(metadata, props);
+        super({ ...metadata, messageType: EventBase.EVENT_MESSAGE_TYPE }, props);
         this._source = metadata.source;
+        this._eventType = this.modelName();
     }
-    static newEvent(source, props, context) {
+    static newEvent(source, props, context, timestamp) {
         return new this({
             id: this.id(),
-            timestamp: Date.now(),
             source,
             context,
+            timestamp,
         }, props);
     }
     getSource() {
         return this._source;
     }
-    getRaw() {
-        return null;
+    getEventType() {
+        return this._eventType;
     }
 }
-exports.EventBase = EventBase;
+EventBase.EVENT_MESSAGE_TYPE = "event";

package/dist/core/message/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("./message"), exports);
-__exportStar(require("./command"), exports);
-__exportStar(require("./event"), exports);
+export * from "./message";
+export * from "./command";
+export * from "./event";

package/dist/core/message/message.d.ts

@@ -6,13 +6,17 @@ export interface MessageContext {
 }
 export interface MessageMetadata {
     readonly id: Id;
-    readonly timestamp: number;
+    readonly messageType: string;
+    readonly timestamp?: number;
     context?: MessageContext;
 }
-export declare abstract class MessageBase<P extends Props> extends ModelWithId<P> {
+export declare class MessageBase<P extends Props> extends ModelWithId<P> {
+    private readonly _messageType;
     private readonly _timestamp;
     private _context?;
     protected constructor(metadata: MessageMetadata, props: P);
+    props(): P;
+    getMessageType(): string;
     getTimestamp(): number;
     getContext(): MessageContext | undefined;
     setContext(context: Partial<MessageContext>): void;

package/dist/core/message/message.js

@@ -1,19 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageBase = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const model_1 = require("../model");
-class MessageBase extends model_1.ModelWithId {
+import _ from "lodash";
+import { ModelWithId } from "../model";
+export class MessageBase extends ModelWithId {
     constructor(metadata, props) {
-        var _a;
         super(metadata.id);
-        this._timestamp = metadata.timestamp;
-        this._context = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.context) !== null && _a !== void 0 ? _a : {};
+        this._messageType = metadata.messageType;
+        this._context = metadata?.context ?? {};
+        this._timestamp = metadata.timestamp ?? Date.now();
         this.initializeProps(props);
     }
+    props() {
+        return super.props();
+    }
+    getMessageType() {
+        return this._messageType;
+    }
     getTimestamp() {
         return this._timestamp;
     }
@@ -21,7 +21,6 @@ class MessageBase extends model_1.ModelWithId {
         return this._context;
     }
     setContext(context) {
-        this._context = lodash_1.default.merge(this._context, context);
+        this._context = _.merge(this._context, context);
     }
 }
-exports.MessageBase = MessageBase;

package/dist/core/model/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class PropsInitializedError extends Error {
+    constructor();
+}

package/dist/core/model/errors.js

@@ -0,0 +1,5 @@
+export class PropsInitializedError extends Error {
+    constructor() {
+        super("Props is initialized");
+    }
+}

package/dist/core/model/index.js

@@ -1,18 +1,2 @@
-"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("./model-with-id"), exports);
+export * from "./model";
+export * from "./model-with-id";

package/dist/core/model/model-with-id.d.ts

@@ -1,12 +1,12 @@
-import { Id, IdGeneratorBase } from "../id";
+import { Id } from "../id";
 import { ModelBase, Props } from "./model";
-export declare abstract class ModelWithId<P extends Props> extends ModelBase<P> {
+export declare class ModelWithId<P extends Props> extends ModelBase<P> {
     protected readonly _id: Id;
     constructor(id: Id);
-    static idGenerator(this: any): IdGeneratorBase;
-    static id(id?: Id): Id;
-    id(): Id;
+    static idService(): import("../id").IIdService<any>;
+    static id(id?: Id): Id<any>;
+    id(): Id<any>;
     hasId(id: Id): boolean;
-    rawId(): string;
+    rawId(): any;
 }
-export type AnyModelWithId = ModelWithId<any>;
+export type AnyModelWithId = ModelWithId<Props>;

package/dist/core/model/model-with-id.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelWithId = void 0;
-const _meta_1 = require("../../meta/index");
-const id_1 = require("../id");
-const model_1 = require("./model");
-class ModelWithId extends model_1.ModelBase {
+import { getIdService } from "../../meta";
+import { Id } from "../id";
+import { ModelBase } from "./model";
+export class ModelWithId extends ModelBase {
     constructor(id) {
         super();
         this._id = id;
     }
-    static idGenerator() {
-        return (0, _meta_1.getIdGenerator)(this) || new id_1.Uuid4Generator();
+    static idService() {
+        return getIdService(this);
     }
     static id(id) {
-        const generator = this.idGenerator();
-        return id ? generator.fromId(id) : generator.newId();
+        const idService = this.idService();
+        return new Id(idService, id);
     }
     id() {
         return this._id;
@@ -26,4 +23,3 @@ class ModelWithId extends model_1.ModelBase {
         return this._id.value;
     }
 }
-exports.ModelWithId = ModelWithId;

package/dist/core/model/model.d.ts

@@ -1,35 +1,37 @@
-import { ClassStatic } from "../../types/index";
 import { Class } from "type-fest";
+import { ClassStatic } from "../../types";
 export type PropKey = string | symbol;
 export interface Props {
     [key: PropKey]: any;
 }
+export type EmptyProps = {
+    [key: PropKey]: never;
+};
 export declare class ModelBase<P extends Props> {
-    static readonly EMPTY_PROPS: {};
+    static readonly EMPTY_PROPS: EmptyProps;
     protected _props: P;
     static isModel(model: any): model is AnyModel;
     static mutable(): boolean;
     static modelName<T extends AnyModel>(this: ModelClass<T>): string;
-    static propsValidator<T extends AnyModel>(this: ModelClass<T>): import("../../meta/index").PropsValidator<T> | undefined;
-    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): Map<string | symbol, import("../../meta/index").StaticValue<T>>;
-    static ownPropsMap(): import("../../meta/index").PropsMap<ModelBase<any>>;
-    static propsMap(): import("../../meta/index").PropsMap<ModelBase<any>>;
+    static propsValidator<T extends AnyModel>(this: ModelClass<T>): import("../../meta").PropsValidator<T> | undefined;
+    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): Map<string | symbol, import("../../meta").StaticValue<T>>;
+    static ownPropsMap(): import("../../meta").PropsMap<ModelBase<any>>;
+    static propsMap(): import("../../meta").PropsMap<ModelBase<any>>;
     constructor();
     private redefineModel;
-    protected get _prototype(): object;
-    protected get _type(): ModelClass<this>;
+    protected get currentModelType(): ModelClass<this>;
     isMutable(): boolean;
     modelName(): string;
-    propsValidator(): import("../../meta/index").PropsValidator<this> | undefined;
-    ownPropsMap(): import("../../meta/index").PropsMap<ModelBase<any>>;
-    propsMap(): import("../../meta/index").PropsMap<ModelBase<any>>;
+    propsValidator(): import("../../meta").PropsValidator<this> | undefined;
+    ownPropsMap(): import("../../meta").PropsMap<ModelBase<any>>;
+    propsMap(): import("../../meta").PropsMap<any>;
     validateProps(props: P): void;
     validate(): void;
-    props(): any;
+    propsIsEmpty(): boolean;
+    props(): P | null;
     protected initializeProps(props: P): void;
 }
-export type AnyModel = ModelBase<object>;
+export type AnyModel = ModelBase<Props>;
 export type PropsOf<T extends AnyModel> = T extends ModelBase<infer P extends Props> ? P : never;
 export interface ModelClass<T extends AnyModel = AnyModel> extends Class<T>, ClassStatic<typeof ModelBase<PropsOf<T>>> {
 }
-export type EmptyProps = {};

package/dist/core/model/model.js

@@ -1,12 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelBase = void 0;
-const _meta_1 = require("../../meta/index");
-const lodash_1 = __importDefault(require("lodash"));
-class ModelBase {
+import _ from "lodash";
+import { getModelName, getOwnPropsMap, getOwnStaticValues, getPropsMap, getPropsValidator, } from "../../meta";
+import { PropsInitializedError } from "./errors";
+export class ModelBase {
     static isModel(model) {
         return model instanceof ModelBase;
     }
@@ -14,19 +9,19 @@ class ModelBase {
         return false;
     }
     static modelName() {
-        return (0, _meta_1.getModelName)(this);
+        return getModelName(this);
     }
     static propsValidator() {
-        return (0, _meta_1.getPropsValidator)(this);
+        return getPropsValidator(this);
     }
     static ownStaticValues() {
-        return (0, _meta_1.getOwnStaticValues)(this);
+        return getOwnStaticValues(this);
     }
     static ownPropsMap() {
-        return (0, _meta_1.getOwnPropsMap)(this.prototype);
+        return getOwnPropsMap(this.prototype);
     }
     static propsMap() {
-        return (0, _meta_1.getPropsMap)(this.prototype);
+        return getPropsMap(this.prototype);
     }
     constructor() {
         this._props = ModelBase.EMPTY_PROPS;
@@ -38,35 +33,28 @@ class ModelBase {
                 configurable: true,
                 enumerable: true,
                 get() {
-                    var _a;
-                    return (_a = this._props) === null || _a === void 0 ? void 0 : _a[propKeyTarget];
-                },
-                set() {
-                    throw new Error(`Cannot set "${key.toString()}"`);
+                    return this._props?.[propKeyTarget];
                 },
             });
         });
     }
-    get _prototype() {
-        return Reflect.getPrototypeOf(this);
-    }
-    get _type() {
+    get currentModelType() {
         return this.constructor;
     }
     isMutable() {
-        return this._type.mutable();
+        return this.currentModelType.mutable();
     }
     modelName() {
-        return this._type.modelName();
+        return this.currentModelType.modelName();
     }
     propsValidator() {
-        return this._type.propsValidator();
+        return this.currentModelType.propsValidator();
     }
     ownPropsMap() {
-        return this._type.ownPropsMap();
+        return this.currentModelType.ownPropsMap();
     }
     propsMap() {
-        return this._type.propsMap();
+        return getPropsMap(Reflect.getPrototypeOf(this));
     }
     validateProps(props) {
         const propsValidator = this.propsValidator();
@@ -76,18 +64,22 @@ class ModelBase {
     validate() {
         this.validateProps(this._props);
     }
+    propsIsEmpty() {
+        return this._props === ModelBase.EMPTY_PROPS;
+    }
     props() {
-        return lodash_1.default.cloneDeepWith(this._props, (value) => {
+        if (this.propsIsEmpty())
+            return null;
+        return _.cloneDeepWith(this._props, (value) => {
             if (ModelBase.isModel(value)) {
                 value.redefineModel();
                 return value;
             }
         });
     }
-    // initializeProps must be call in leaf class, it cannot be call in a extendable model class
     initializeProps(props) {
-        if (this._props !== ModelBase.EMPTY_PROPS)
-            throw new Error("Props is initialized");
+        if (!this.propsIsEmpty())
+            throw new PropsInitializedError();
         if (!this.isMutable()) {
             this._props = props;
             Object.freeze(this._props);
@@ -104,5 +96,4 @@ class ModelBase {
         this.validate();
     }
 }
-exports.ModelBase = ModelBase;
 ModelBase.EMPTY_PROPS = {};

package/dist/core/repository.d.ts

@@ -1,6 +1,6 @@
-import { AnyAggregate, AnyAggregateES } from "./aggregate";
+import { AnyAggregate } from "./aggregate";
 import { Id } from "./id";
-export interface IRepository<T extends AnyAggregate | AnyAggregateES> {
+export interface IRepository<T extends AnyAggregate> {
     findById(id: Id): Promise<T | null>;
     save(instance: T): Promise<any>;
 }

package/dist/core/repository.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/core/value-object.d.ts

@@ -1,12 +1,13 @@
 import { Class } from "type-fest";
 import { ModelBase, Props, PropsOf } from "./model";
-import { ClassStatic } from "../types/index";
-export declare abstract class ValueObjectBase<P extends Props> extends ModelBase<P> {
+import { ClassStatic } from "../types";
+export declare class ValueObjectBase<P extends Props> extends ModelBase<P> {
     constructor(props: P);
+    props(): P;
     equals<V extends AnyValueObject>(vo: V): boolean;
     with(props: Partial<P>): this;
 }
-export type AnyValueObject = ValueObjectBase<any>;
+export type AnyValueObject = ValueObjectBase<Props>;
 export interface ValueObjectClass<T extends AnyValueObject = AnyValueObject> extends Class<T>, ClassStatic<typeof ValueObjectBase<PropsOf<T>>> {
 }
 export interface ValueObjectClassWithTypedConstructor<T extends AnyValueObject = AnyValueObject> extends Class<T, ConstructorParameters<typeof ValueObjectBase<PropsOf<T>>>> {

package/dist/core/value-object.js

@@ -1,24 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueObjectBase = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const model_1 = require("./model");
-class ValueObjectBase extends model_1.ModelBase {
+import _ from "lodash";
+import { ModelBase } from "./model";
+export class ValueObjectBase extends ModelBase {
     constructor(props) {
         super();
         this.initializeProps(props);
     }
+    props() {
+        return super.props();
+    }
     equals(vo) {
         const equalsType = vo instanceof this.constructor;
-        const equalsValue = JSON.stringify(vo) === JSON.stringify(this);
+        const equalsValue = JSON.stringify(vo.props()) === JSON.stringify(this.props());
         return equalsType && equalsValue;
     }
     with(props) {
-        const newProps = lodash_1.default.merge(this.props(), props);
+        const newProps = _.merge(this.props(), props);
         return new this.constructor(newProps);
     }
 }
-exports.ValueObjectBase = ValueObjectBase;

package/dist/decorators/{aggregate → aggregate-es}/handle.d.ts

@@ -1,2 +1,2 @@
-import { AnyCommand, CommandClass, CommandHandler } from "../../core/index";
+import { AnyCommand, CommandClass, CommandHandler } from "../../core";
 export declare const Handle: <T extends AnyCommand>(commandClass: CommandClass<T, any[]>) => <U extends CommandHandler<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;

package/dist/decorators/aggregate-es/handle.js

@@ -0,0 +1,9 @@
+import { defineCommandHandler, getModelName } from "../../meta";
+export const Handle = (commandClass) => {
+    return (target, propertyKey, descriptor) => {
+        if (typeof descriptor.value === "function") {
+            const commandName = getModelName(commandClass);
+            defineCommandHandler(target, commandName, descriptor.value);
+        }
+    };
+};

package/dist/decorators/aggregate-es/index.js

@@ -0,0 +1,2 @@
+export * from "./handle";
+export * from "./when";

package/dist/decorators/{aggregate → aggregate-es}/when.d.ts

@@ -1,2 +1,2 @@
-import { AnyEvent, EventApplier, EventClass } from "../../core/index";
+import { AnyEvent, EventApplier, EventClass } from "../../core";
 export declare const When: <T extends AnyEvent>(eventClass: EventClass<T, any[]>) => <U extends EventApplier<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;

package/dist/decorators/aggregate-es/when.js

@@ -0,0 +1,9 @@
+import { defineEventApplier, getModelName } from "../../meta";
+export const When = (eventClass) => {
+    return (target, propertyKey, descriptor) => {
+        if (typeof descriptor.value === "function") {
+            const eventName = getModelName(eventClass);
+            defineEventApplier(target, eventName, descriptor.value);
+        }
+    };
+};

package/dist/decorators/id.d.ts

@@ -1,2 +1,2 @@
-import { AnyModelWithId, IdGeneratorBase, ModelClass } from "../core/index";
-export declare const UseId: (generator: IdGeneratorBase) => <T extends AnyModelWithId>(target: ModelClass<T>) => void;
+import { AnyModelWithId, IIdService, ModelClass } from "../core";
+export declare const UseIdService: (idService: IIdService) => <T extends AnyModelWithId>(target: ModelClass<T>) => void;

package/dist/decorators/id.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UseId = void 0;
-const _meta_1 = require("../meta/index");
-const UseId = (generator) => {
+import { defineIdService } from "../meta";
+export const UseIdService = (idService) => {
     return (target) => {
-        (0, _meta_1.defineIdGenerator)(target, generator);
+        defineIdService(target, idService);
     };
 };
-exports.UseId = UseId;

package/dist/decorators/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./aggregate";
+export * from "./aggregate-es";
 export * from "./id";
 export * from "./model";

package/dist/decorators/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("./aggregate"), exports);
-__exportStar(require("./id"), exports);
-__exportStar(require("./model"), exports);
+export * from "./aggregate-es";
+export * from "./id";
+export * from "./model";

package/dist/decorators/model/enum.d.ts

@@ -1,2 +1,2 @@
-import { EnumClass, EnumValue } from "../../core/index";
-export declare const Enum: (value: EnumValue) => <T extends EnumClass<import("../../core/index").EnumBase>>(target: T, key: string) => void;
+import { EnumClass, EnumValue } from "../../core";
+export declare const Enum: (value: EnumValue) => <T extends EnumClass<import("../../core").EnumBase>>(target: T, key: string) => void;