ddd-node 21.0.2 → 22.0.0

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

@@ -1,7 +1,6 @@
 import { EntityBuilderBase } from "../../entity";
 import { AnyAggregate } from "./aggregate";
 export declare abstract class AggregateBuilderBase<T extends AnyAggregate> extends EntityBuilderBase<T> {
-    protected _version?: number;
-    getVersion(): number;
+    protected version: number;
     withVersion(version: number): this;
 }

package/dist/core/aggregate/aggregate-base/aggregate.builder.js

@@ -1,17 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AggregateBuilderBase = void 0;
-const lodash_1 = __importDefault(require("lodash"));
 const entity_1 = require("../../entity");
 class AggregateBuilderBase extends entity_1.EntityBuilderBase {
-    getVersion() {
-        return !lodash_1.default.isUndefined(this._version) ? this._version : 0;
+    constructor() {
+        super(...arguments);
+        this.version = 0;
     }
     withVersion(version) {
-        this._version = version;
+        this.version = version;
         return this;
     }
 }

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

@@ -1,15 +1,15 @@
-import { EntityBase, EntityMetadata } from "../../entity";
 import { Props, PropsOf } from "../../../model";
+import { EntityBase, EntityMetadata } from "../../entity";
 import { AnyEvent, EventClassWithTypedConstructor, EventSource } from "../../message";
 import { IEventDispatcher } from "../event-dispatcher.interface";
 export interface AggregateMetadata extends EntityMetadata {
-    aggregateType: string;
     version: number;
 }
 export declare abstract class AggregateBase<P extends Props> extends EntityBase<P> {
     protected readonly _version: number;
     constructor(metadata: AggregateMetadata, props?: P);
     abstract version(): number;
+    metadata(): AggregateMetadata;
     protected createEventSource(): EventSource;
     protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): E;
     abstract dispatchEvents(dispatcher: IEventDispatcher): void;

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

@@ -8,9 +8,14 @@ class AggregateBase extends entity_1.EntityBase {
         super(metadata, props);
         this._version = metadata.version;
     }
+    metadata() {
+        return {
+            ...super.metadata(),
+            version: this.version(),
+        };
+    }
     createEventSource() {
         return {
-            aggregateModelId: this.modelMetadata().modelId,
             aggregateId: this.id(),
             aggregateVersion: this.version(),
         };

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

@@ -0,0 +1,9 @@
+import { AnyEventSourcedAggregate } from ".";
+import { CommandHandlerMap, EventApplierMap } from "../../../meta";
+import { IModelMetadata } from "../../../model";
+export interface IEventSourcedAggregateModelMetadata<T extends AnyEventSourcedAggregate> extends IModelMetadata<T> {
+    ownEventApplierMap: EventApplierMap;
+    eventApplierMap: EventApplierMap;
+    ownCommandHandlerMap: CommandHandlerMap;
+    commandHandlerMap: CommandHandlerMap;
+}

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

@@ -1,10 +1,11 @@
 import { AnyEvent } from "../../message";
 import { AggregateBuilderBase } from "../aggregate-base";
-import { AnyEventSourcedAggregate, EventSourcedAggregateClassWithTypedConstructor, Snapshot } from "./event-sourced-aggregate";
+import { AnyEventSourcedAggregate, EventSourcedAggregateClassWithTypedConstructor } from "./event-sourced-aggregate";
+import { Snapshot } from "./snapshot";
 export declare class EventSourcedAggregateBuilder<T extends AnyEventSourcedAggregate> extends AggregateBuilderBase<T> {
     private aggregateClass;
-    private _pastEvents?;
-    private _snapshot?;
+    private pastEvents?;
+    private snapshot?;
     constructor(aggregateClass: EventSourcedAggregateClassWithTypedConstructor<T>);
     withPastEvents(pastEvents: AnyEvent[]): this;
     withSnapshot(snapshot: Snapshot<T>): this;

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

@@ -8,27 +8,25 @@ class EventSourcedAggregateBuilder extends aggregate_base_1.AggregateBuilderBase
         this.aggregateClass = aggregateClass;
     }
     withPastEvents(pastEvents) {
-        this._pastEvents = pastEvents;
+        this.pastEvents = pastEvents;
         return this;
     }
     withSnapshot(snapshot) {
-        this._snapshot = snapshot;
+        this.snapshot = snapshot;
         return this;
     }
     build() {
-        if (this._snapshot) {
-            const { id, version } = this._snapshot.metadata;
-            const { props } = this._snapshot;
+        if (this.snapshot) {
+            const { id, version } = this.snapshot.metadata;
+            const { props } = this.snapshot;
             this.withId(id).withVersion(version).withProps(props);
         }
         const instance = new this.aggregateClass({
-            id: this.getId(),
-            version: this.getVersion(),
-        }, this._props);
-        if (this._pastEvents) {
-            const pastEvents = this._pastEvents.filter((_pastEvent) => _pastEvent.source().aggregateVersion >= instance.version());
-            instance.applyPastEvents(pastEvents);
-        }
+            id: this.id,
+            version: this.version,
+        }, this.props);
+        if (this.pastEvents)
+            instance.applyPastEvents(this.pastEvents);
         return instance;
     }
 }

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

@@ -4,22 +4,20 @@ import { ClassStatic } from "../../../types";
 import { AnyCommand, AnyEvent, EventClassWithTypedConstructor } from "../../message";
 import { AggregateBase, AggregateMetadata } from "../aggregate-base";
 import { IEventDispatcher } from "../event-dispatcher.interface";
-import { ESAModelMetadata } from "./event-sourced-aggregate.model-metadata";
-export type EventSourceAggregateMetadata = Omit<AggregateMetadata, "aggregateType">;
-export interface SnapshotMetadata extends EventSourceAggregateMetadata {
-}
-export interface Snapshot<T extends AnyEventSourcedAggregate> {
-    metadata: SnapshotMetadata;
-    props: PropsOf<T>;
+import { IEventSourcedAggregateModelMetadata } from "./event-sourced-aggregate-model-metadata";
+import { Snapshot, SnapshotMetadata } from "./snapshot";
+export interface EventSourceAggregateMetadata extends AggregateMetadata {
 }
 export declare class EventSourcedAggregateBase<P extends Props> extends AggregateBase<P> {
-    static readonly AGGREGATE_TYPE = "event_sourced";
     private _handledCommands;
     private _pastEvents;
     private _events;
     constructor(metadata: EventSourceAggregateMetadata, props?: P);
-    static esaModelMetadata<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): ESAModelMetadata<T>;
-    esaModelMetadata(): ESAModelMetadata<this>;
+    static ownEventApplierMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../../meta").EventApplierMap;
+    static eventApplierMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../../meta").EventApplierMap;
+    static ownCommandHandlerMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../../meta").CommandHandlerMap;
+    static commandHandlerMap<T extends AnyEventSourcedAggregate>(this: EventSourcedAggregateClass<T>): import("../../../meta").CommandHandlerMap;
+    modelMetadata(): IEventSourcedAggregateModelMetadata<typeof this>;
     version(): number;
     pastEvents(): AnyEvent[];
     events(): AnyEvent[];

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

@@ -1,21 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventSourcedAggregateBase = void 0;
+const meta_1 = require("../../../meta");
 const utils_1 = require("../../../utils");
 const aggregate_base_1 = require("../aggregate-base");
-const event_sourced_aggregate_model_metadata_1 = require("./event-sourced-aggregate.model-metadata");
 class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
     constructor(metadata, props) {
-        super({ ...metadata, aggregateType: EventSourcedAggregateBase.AGGREGATE_TYPE }, props);
+        super(metadata, props);
         this._handledCommands = [];
         this._events = [];
         this._pastEvents = [];
     }
-    static esaModelMetadata() {
-        return new event_sourced_aggregate_model_metadata_1.ESAModelMetadata(this);
+    static ownEventApplierMap() {
+        return (0, meta_1.getOwnEventApplierMap)(this.prototype);
     }
-    esaModelMetadata() {
-        return this.constructor.esaModelMetadata();
+    static eventApplierMap() {
+        return (0, meta_1.getEventApplierMap)(this.prototype);
+    }
+    static ownCommandHandlerMap() {
+        return (0, meta_1.getOwnCommandHandlerMap)(this.prototype);
+    }
+    static commandHandlerMap() {
+        return (0, meta_1.getCommandHandlerMap)(this.prototype);
+    }
+    modelMetadata() {
+        const aggregateClass = this.constructor;
+        return {
+            ...super.modelMetadata(),
+            ownEventApplierMap: aggregateClass.ownEventApplierMap(),
+            eventApplierMap: aggregateClass.eventApplierMap(),
+            ownCommandHandlerMap: aggregateClass.ownCommandHandlerMap(),
+            commandHandlerMap: aggregateClass.commandHandlerMap(),
+        };
     }
     version() {
         return this._version + this._pastEvents.length + this._events.length;
@@ -33,21 +49,19 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
         return Boolean(this._events.length);
     }
     getApplierForEvent(event) {
-        const { eventType } = event.eventModelMetadata();
-        const { eventApplierMap } = this.esaModelMetadata();
+        const { eventType } = event.modelMetadata();
+        const { eventApplierMap } = this.modelMetadata();
         const applier = eventApplierMap.get(eventType);
         if (!applier)
             throw new Error("Event applier not found");
         return applier;
     }
     validateEventBeforeApply(event) {
-        const eventSource = event.source();
-        if (eventSource.aggregateModelId !== this.modelMetadata().modelId)
-            throw new Error("Invalid source type");
-        if (!eventSource.aggregateId.equals(this._id))
-            throw new Error("Invalid source id");
-        if (eventSource.aggregateVersion !== this.version())
-            throw new Error("Invalid source version");
+        const { aggregateId, aggregateVersion } = event.source();
+        if (!aggregateId.equals(this._id))
+            throw new Error("Invalid aggregate id");
+        if (aggregateVersion !== this.version())
+            throw new Error("Invalid aggregate version");
     }
     _applyEvent(event) {
         const applier = this.getApplierForEvent(event);
@@ -78,8 +92,8 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
         this.applyEvent(this.newEvent(eventClass, props));
     }
     getHandlerForCommand(command) {
-        const { commandType } = command.commandModelMetadata();
-        const { commandHandlerMap } = this.esaModelMetadata();
+        const { commandType } = command.modelMetadata();
+        const { commandHandlerMap } = this.modelMetadata();
         const handler = commandHandlerMap.get(commandType);
         if (!handler)
             throw new Error("Command handler not found");
@@ -125,4 +139,3 @@ class EventSourcedAggregateBase extends aggregate_base_1.AggregateBase {
     }
 }
 exports.EventSourcedAggregateBase = EventSourcedAggregateBase;
-EventSourcedAggregateBase.AGGREGATE_TYPE = "event_sourced";

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

@@ -1,3 +1,2 @@
 export * from "./event-sourced-aggregate";
 export * from "./event-sourced-aggregate.builder";
-export * from "./event-sourced-aggregate.model-metadata";

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

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./event-sourced-aggregate"), exports);
 __exportStar(require("./event-sourced-aggregate.builder"), exports);
-__exportStar(require("./event-sourced-aggregate.model-metadata"), exports);

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

@@ -0,0 +1,8 @@
+import { PropsOf } from "../../../model";
+import { AnyEventSourcedAggregate, EventSourceAggregateMetadata } from "./event-sourced-aggregate";
+export interface SnapshotMetadata extends EventSourceAggregateMetadata {
+}
+export interface Snapshot<T extends AnyEventSourcedAggregate> {
+    metadata: SnapshotMetadata;
+    props: PropsOf<T>;
+}

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

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

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

@@ -8,12 +8,12 @@ class StateAggregateBuilder extends aggregate_base_1.AggregateBuilderBase {
         this.aggregateClass = aggregateClass;
     }
     build() {
-        if (!this._props)
+        if (!this.props)
             throw new Error("The props must be set before build");
         return new this.aggregateClass({
-            id: this.getId(),
-            version: this.getVersion(),
-        }, this._props);
+            id: this.id,
+            version: this.version,
+        }, this.props);
     }
 }
 exports.StateAggregateBuilder = StateAggregateBuilder;

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

@@ -4,9 +4,9 @@ import { ClassStatic } from "../../../types";
 import { AnyEvent, EventClassWithTypedConstructor } from "../../message";
 import { AggregateBase, AggregateMetadata } from "../aggregate-base";
 import { IEventDispatcher } from "../event-dispatcher.interface";
-export type StateAggregateMetadata = Omit<AggregateMetadata, "aggregateType">;
+export interface StateAggregateMetadata extends AggregateMetadata {
+}
 export declare class StateAggregateBase<P extends Props> extends AggregateBase<P> {
-    static readonly AGGREGATE_TYPE = "state";
     private _events;
     constructor(metadata: StateAggregateMetadata, props: P);
     props(): P;

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

@@ -4,7 +4,7 @@ exports.StateAggregateBase = void 0;
 const aggregate_base_1 = require("../aggregate-base");
 class StateAggregateBase extends aggregate_base_1.AggregateBase {
     constructor(metadata, props) {
-        super({ ...metadata, aggregateType: StateAggregateBase.AGGREGATE_TYPE }, props);
+        super(metadata, props);
         this._events = [];
     }
     props() {
@@ -37,4 +37,3 @@ class StateAggregateBase extends aggregate_base_1.AggregateBase {
     }
 }
 exports.StateAggregateBase = StateAggregateBase;
-StateAggregateBase.AGGREGATE_TYPE = "state";

package/dist/core/entity/entity.builder.d.ts

@@ -1,6 +1,6 @@
-import { ModelWithIdBuilder } from "..";
+import { IdentifiableModelBuilder } from "..";
 import { AnyEntity, EntityClassWithTypedConstructor } from "./entity";
-export declare abstract class EntityBuilderBase<T extends AnyEntity> extends ModelWithIdBuilder<T> {
+export declare abstract class EntityBuilderBase<T extends AnyEntity> extends IdentifiableModelBuilder<T> {
 }
 export declare class EntityBuilder<T extends AnyEntity> extends EntityBuilderBase<T> {
     private entityClass;

package/dist/core/entity/entity.builder.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityBuilder = exports.EntityBuilderBase = void 0;
 const __1 = require("..");
-class EntityBuilderBase extends __1.ModelWithIdBuilder {
+class EntityBuilderBase extends __1.IdentifiableModelBuilder {
 }
 exports.EntityBuilderBase = EntityBuilderBase;
 class EntityBuilder extends EntityBuilderBase {
@@ -11,7 +11,7 @@ class EntityBuilder extends EntityBuilderBase {
         this.entityClass = entityClass;
     }
     build() {
-        return new this.entityClass({ id: this.getId() }, this._props);
+        return new this.entityClass({ id: this.id }, this.props);
     }
 }
 exports.EntityBuilder = EntityBuilder;

package/dist/core/entity/entity.d.ts

@@ -1,12 +1,10 @@
 import { Class } from "type-fest";
 import { Props, PropsOf } from "../../model";
 import { ClassStatic } from "../../types";
-import { Id } from "../id";
-import { ModelWithId } from "../model-with-id";
-export interface EntityMetadata {
-    readonly id: Id;
+import { IdentifiableModel, IdentifiableModelMetadata } from "../identifiable-model";
+export interface EntityMetadata extends IdentifiableModelMetadata {
 }
-export declare class EntityBase<P extends Props> extends ModelWithId<P> {
+export declare class EntityBase<P extends Props> extends IdentifiableModel<P> {
     constructor(metadata: EntityMetadata, props?: P);
 }
 export type AnyEntity = EntityBase<Props>;

package/dist/core/entity/entity.js

@@ -11,10 +11,10 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityBase = void 0;
 const model_1 = require("../../model");
-const model_with_id_1 = require("../model-with-id");
-let EntityBase = class EntityBase extends model_with_id_1.ModelWithId {
+const identifiable_model_1 = require("../identifiable-model");
+let EntityBase = class EntityBase extends identifiable_model_1.IdentifiableModel {
     constructor(metadata, props) {
-        super(metadata.id);
+        super(metadata);
         if (props)
             this.initializeProps(props);
     }

package/dist/core/enum/enum.d.ts

@@ -1,18 +1,16 @@
 import { Class } from "type-fest";
-import { ModelBase } from "../../model";
+import { ValueObjectBase } from "..";
 import { ClassStatic } from "../../types";
 export type EnumValue = string | number;
 export interface EnumProps {
     value: EnumValue;
 }
-export declare class EnumBase extends ModelBase<EnumProps> {
+export declare class EnumBase extends ValueObjectBase<EnumProps> {
     static values(): EnumBase[];
     static parse<T extends AnyEnum>(this: EnumClass<T>, providedValue: EnumValue): T;
     static parseSafe<T extends AnyEnum>(this: EnumClass<T>, providedValue: EnumValue): T | null;
     constructor(value: EnumValue);
-    props(): EnumProps;
-    get value(): EnumValue;
-    equals<T extends AnyEnum>(other: T): boolean;
+    value: EnumValue;
 }
 export type AnyEnum = EnumBase;
 export interface EnumClass<T extends AnyEnum = AnyEnum, Arguments extends unknown[] = any[]> extends Class<T, Arguments>, ClassStatic<typeof EnumBase> {

package/dist/core/enum/enum.js

@@ -10,14 +10,15 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnumBase = void 0;
+const __1 = require("..");
 const model_1 = require("../../model");
-let EnumBase = class EnumBase extends model_1.ModelBase {
+let EnumBase = class EnumBase extends __1.ValueObjectBase {
     static values() {
-        return Array.from(this.modelMetadata().ownStaticValues.values()).map((staticValue) => staticValue.value);
+        return Array.from(this.ownStaticValues().values()).map((staticValue) => staticValue.value);
     }
     static parse(providedValue) {
         let result = undefined;
-        this.modelMetadata().ownStaticValues.forEach((staticValue) => {
+        this.ownStaticValues().forEach((staticValue) => {
             if (staticValue.value instanceof this) {
                 const staticEnum = staticValue.value;
                 if (staticEnum.value === providedValue && !result) {
@@ -26,7 +27,7 @@ let EnumBase = class EnumBase extends model_1.ModelBase {
             }
         });
         if (!result)
-            throw new Error(`Invalid provided value for enum ${this.modelMetadata().modelName}`);
+            throw new Error(`Invalid provided value for enum ${this.modelName()}`);
         return result;
     }
     static parseSafe(providedValue) {
@@ -38,22 +39,14 @@ let EnumBase = class EnumBase extends model_1.ModelBase {
         }
     }
     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;
+        super({ value });
     }
 };
 exports.EnumBase = EnumBase;
+__decorate([
+    (0, model_1.Prop)(),
+    __metadata("design:type", Object)
+], EnumBase.prototype, "value", void 0);
 exports.EnumBase = EnumBase = __decorate([
     (0, model_1.Mutable)(false),
     __metadata("design:paramtypes", [Object])

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

@@ -1,2 +1 @@
 export * from "./enum";
-export * from "./enum.builder";

package/dist/core/enum/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./enum"), exports);
-__exportStar(require("./enum.builder"), exports);

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

@@ -1,6 +1,8 @@
-export declare class Id {
-    private _value;
+import { ValueObjectBase } from "../value-object";
+export interface IdProps {
+    value: string;
+}
+export declare class Id extends ValueObjectBase<IdProps> {
     constructor(idOrValue: Id | string);
-    get value(): string;
-    equals(id: Id): boolean;
+    value: string;
 }

package/dist/core/id/id.js

@@ -1,15 +1,24 @@
 "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.Id = void 0;
-class Id {
+const model_1 = require("../../model");
+const value_object_1 = require("../value-object");
+class Id extends value_object_1.ValueObjectBase {
     constructor(idOrValue) {
-        this._value = idOrValue instanceof Id ? idOrValue.value : idOrValue;
-    }
-    get value() {
-        return this._value;
-    }
-    equals(id) {
-        return id._value === this._value;
+        super({ value: idOrValue instanceof Id ? idOrValue.value : idOrValue });
     }
 }
 exports.Id = Id;
+__decorate([
+    (0, model_1.Prop)(),
+    __metadata("design:type", String)
+], Id.prototype, "value", void 0);

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

@@ -1,3 +1 @@
-export * from "./interface";
 export * from "./id";
-export * from "./services";

package/dist/core/id/index.js

@@ -14,6 +14,4 @@ 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("./interface"), exports);
 __exportStar(require("./id"), exports);
-__exportStar(require("./services"), exports);

package/dist/core/identifiable-model/identifiable-model.builder.d.ts

@@ -0,0 +1,9 @@
+import { ModelBuilder } from "../../model";
+import { Id } from "../id";
+import { AnyIdentifiableModel } from "./identifiable-model";
+export declare abstract class IdentifiableModelBuilder<T extends AnyIdentifiableModel> extends ModelBuilder<T> {
+    protected id: Id;
+    newId(): Id;
+    withId(id: Id): this;
+    withNewId(): this;
+}

package/dist/core/identifiable-model/identifiable-model.builder.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifiableModelBuilder = void 0;
+const uuid_1 = require("uuid");
+const model_1 = require("../../model");
+const id_1 = require("../id");
+class IdentifiableModelBuilder extends model_1.ModelBuilder {
+    constructor() {
+        super(...arguments);
+        this.id = this.newId();
+    }
+    newId() {
+        return new id_1.Id((0, uuid_1.v4)());
+    }
+    withId(id) {
+        this.id = id;
+        return this;
+    }
+    withNewId() {
+        return this.withId(this.newId());
+    }
+}
+exports.IdentifiableModelBuilder = IdentifiableModelBuilder;

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

@@ -0,0 +1,13 @@
+import { ModelBase, Props } from "../../model";
+import { Id } from "../id";
+export interface IdentifiableModelMetadata {
+    id: Id;
+}
+export declare class IdentifiableModel<P extends Props> extends ModelBase<P> {
+    protected readonly _id: Id;
+    constructor(metadata: IdentifiableModelMetadata);
+    metadata(): IdentifiableModelMetadata;
+    id(): Id;
+    hasId(id: Id): boolean;
+}
+export type AnyIdentifiableModel = IdentifiableModel<Props>;

package/dist/core/identifiable-model/identifiable-model.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifiableModel = void 0;
+const model_1 = require("../../model");
+class IdentifiableModel extends model_1.ModelBase {
+    constructor(metadata) {
+        super();
+        this._id = metadata.id;
+    }
+    metadata() {
+        return {
+            ...super.metadata(),
+            id: this._id,
+        };
+    }
+    id() {
+        return this._id;
+    }
+    hasId(id) {
+        return this._id.equals(id);
+    }
+}
+exports.IdentifiableModel = IdentifiableModel;

package/dist/core/identifiable-model/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./identifiable-model";
+export * from "./identifiable-model.builder";

package/dist/core/{id/services → identifiable-model}/index.js

@@ -14,5 +14,5 @@ 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("./snowflake"), exports);
-__exportStar(require("./uuid4"), exports);
+__exportStar(require("./identifiable-model"), exports);
+__exportStar(require("./identifiable-model.builder"), exports);

package/dist/core/index.d.ts

@@ -1,9 +1,9 @@
+export * from "./value-object";
+export * from "./enum";
 export * from "./id";
-export * from "./model-with-id";
+export * from "./identifiable-model";
 export * from "./entity";
 export * from "./aggregate";
 export * from "./message";
-export * from "./enum";
-export * from "./value-object";
 export * from "./repository";
 export * from "./event-pubsub";