ddd-node 9.1.0 → 12.1.0

package/dist/core/metadata/aggregate.metadata.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineCommandHandler = exports.getCommandHandlersMap = exports.CommandHandlersMetaKey = exports.defineEventApplier = exports.getEventAppliersMap = exports.EventAppliersMetaKey = void 0;
+require("reflect-metadata");
+exports.EventAppliersMetaKey = Symbol.for("EVENT_APPLIERS");
+const getEventAppliersMap = (target) => {
+    return (Reflect.getMetadata(exports.EventAppliersMetaKey, target) ||
+        new Map());
+};
+exports.getEventAppliersMap = getEventAppliersMap;
+const defineEventApplier = (target, eventName, applier) => {
+    const eventAppliersMap = (0, exports.getEventAppliersMap)(target);
+    eventAppliersMap.set(eventName, applier);
+    Reflect.defineMetadata(exports.EventAppliersMetaKey, eventAppliersMap, target);
+};
+exports.defineEventApplier = defineEventApplier;
+// Command handler map
+exports.CommandHandlersMetaKey = Symbol.for("COMMAND_HANDLERS");
+const getCommandHandlersMap = (target) => {
+    return (Reflect.getMetadata(exports.CommandHandlersMetaKey, target) ||
+        new Map());
+};
+exports.getCommandHandlersMap = getCommandHandlersMap;
+const defineCommandHandler = (target, commandName, handler) => {
+    const commandHandlersMap = (0, exports.getCommandHandlersMap)(target);
+    commandHandlersMap.set(commandName, handler);
+    Reflect.defineMetadata(exports.CommandHandlersMetaKey, commandHandlersMap, target);
+};
+exports.defineCommandHandler = defineCommandHandler;

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

@@ -0,0 +1,4 @@
+import { IdGeneratorBase } from "../id";
+export declare const IdGeneratorMetaKey: unique symbol;
+export declare const defineIdGenerator: (target: object, idGenerator: IdGeneratorBase) => void;
+export declare const getIdGenerator: (target: object) => any;

package/dist/core/metadata/id.metadata.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdGenerator = exports.defineIdGenerator = exports.IdGeneratorMetaKey = void 0;
+exports.IdGeneratorMetaKey = Symbol.for("ID_GENERATOR");
+const defineIdGenerator = (target, idGenerator) => {
+    Reflect.defineMetadata(exports.IdGeneratorMetaKey, idGenerator, target);
+};
+exports.defineIdGenerator = defineIdGenerator;
+const getIdGenerator = (target) => {
+    return Reflect.getMetadata(exports.IdGeneratorMetaKey, target);
+};
+exports.getIdGenerator = getIdGenerator;

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

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

package/dist/core/metadata/index.js

@@ -0,0 +1,19 @@
+"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.metadata"), exports);
+__exportStar(require("./id.metadata"), exports);
+__exportStar(require("./model.metadata"), exports);

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

@@ -0,0 +1,13 @@
+import { AnyModel, PropsOf } from "../model";
+export declare const getPropKeySet: (target: object | null) => Set<string | symbol>;
+export declare const setPropKey: (target: object, propKey: string) => void;
+export declare const setModelName: (target: object, name: string) => void;
+export declare const getModelName: (target: object) => string;
+export type PropsValidator<T extends AnyModel = AnyModel> = (props: PropsOf<T>) => void;
+export declare const setValidateProps: <T extends AnyModel>(target: object, validator: PropsValidator<T>) => void;
+export declare const getValidateProps: <T extends AnyModel>(target: object) => PropsValidator<T> | undefined;
+export type ModelMetadata<T extends AnyModel = AnyModel> = {
+    name: string;
+    validator?: PropsValidator<T>;
+};
+export declare const getModelMetadata: <T extends AnyModel = AnyModel>(target: object) => ModelMetadata<T>;

package/dist/core/metadata/model.metadata.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelMetadata = exports.getValidateProps = exports.setValidateProps = exports.getModelName = exports.setModelName = exports.setPropKey = exports.getPropKeySet = void 0;
+const PropMetaKey = Symbol.for("PROP");
+// export const getPropKeys = (
+//   target: object | null
+// ): Map<string | symbol, boolean> => {
+//   if (!target) return new Map();
+//   return (
+//     Reflect.getMetadata(PropMetaKey, target) ||
+//     new Map<string | symbol, boolean>()
+//   );
+// };
+const getPropKeySet = (target) => {
+    var _a;
+    if (!target)
+        return new Set();
+    return (_a = Reflect.getMetadata(PropMetaKey, target)) !== null && _a !== void 0 ? _a : new Set();
+};
+exports.getPropKeySet = getPropKeySet;
+const setPropKey = (target, propKey) => {
+    const propKeySet = (0, exports.getPropKeySet)(target);
+    propKeySet.add(propKey);
+    Reflect.defineMetadata(PropMetaKey, propKeySet, target);
+};
+exports.setPropKey = setPropKey;
+//
+const ModelNameMetaKey = Symbol.for("MODEL_NAME");
+const setModelName = (target, name) => {
+    Reflect.defineMetadata(ModelNameMetaKey, name, target);
+};
+exports.setModelName = setModelName;
+const getModelName = (target) => {
+    const modelName = Reflect.getMetadata(ModelNameMetaKey, target);
+    if (!modelName)
+        throw new Error();
+    return modelName;
+};
+exports.getModelName = getModelName;
+const ValidatePropsMetaKey = Symbol.for("VALIDATE_PROPS");
+const setValidateProps = (target, validator) => {
+    Reflect.defineMetadata(ValidatePropsMetaKey, validator, target);
+};
+exports.setValidateProps = setValidateProps;
+const getValidateProps = (target) => {
+    return Reflect.getMetadata(ValidatePropsMetaKey, target);
+};
+exports.getValidateProps = getValidateProps;
+const getModelMetadata = (target) => {
+    return {
+        name: (0, exports.getModelName)(target),
+        validator: (0, exports.getValidateProps)(target),
+    };
+};
+exports.getModelMetadata = getModelMetadata;

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

@@ -0,0 +1,2 @@
+export * from "./model";
+export * from "./model-with-id";

package/dist/core/model/index.js

@@ -0,0 +1,18 @@
+"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);

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelWithId = void 0;
+const id_1 = require("../id");
+const id_metadata_1 = require("../metadata/id.metadata");
+const model_1 = require("./model");
+class ModelWithId extends model_1.ModelBase {
+    constructor(id) {
+        super();
+        this._id = id;
+    }
+    static getIdGenerator() {
+        return (0, id_metadata_1.getIdGenerator)(this) || new id_1.Uuid4Generator();
+    }
+    static id(id) {
+        const generator = this.getIdGenerator();
+        return id ? generator.fromId(id) : generator.newId();
+    }
+    getId() {
+        return this._id;
+    }
+    hasId(id) {
+        return this._id.equals(id);
+    }
+    rawId() {
+        return this._id.value;
+    }
+}
+exports.ModelWithId = ModelWithId;

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

@@ -0,0 +1,25 @@
+import { ClassStatic } from "../../types/index";
+import { Class } from "type-fest";
+import { ModelMetadata } from "../metadata/model.metadata";
+export declare class ModelBase<Props extends object> {
+    static readonly EMPTY_PROPS: {};
+    private _metadata;
+    private _propKeys;
+    protected _props: Props;
+    static isMutable(): boolean;
+    static isModel(model: any): model is AnyModel;
+    constructor();
+    private redefineModel;
+    isMutable(): boolean;
+    getPropKeys(): Set<string | symbol>;
+    validateProps(props: Props): void;
+    validate(): void;
+    getModelMetadata(): ModelMetadata<this>;
+    modelName(): string;
+    props(): any;
+    protected initializeProps(props: Props): void;
+}
+export type AnyModel = ModelBase<object>;
+export type PropsOf<T extends AnyModel> = T extends ModelBase<infer P extends object> ? P : never;
+export type ModelClass<T extends AnyModel = AnyModel> = Class<T> & ClassStatic<typeof ModelBase<PropsOf<T>>>;
+export type EmptyProps = {};

package/dist/core/model/model.js

@@ -0,0 +1,89 @@
+"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 lodash_1 = __importDefault(require("lodash"));
+const model_metadata_1 = require("../metadata/model.metadata");
+class ModelBase {
+    static isMutable() {
+        return false;
+    }
+    static isModel(model) {
+        return model instanceof ModelBase;
+    }
+    constructor() {
+        this._props = ModelBase.EMPTY_PROPS;
+        this.redefineModel();
+    }
+    redefineModel() {
+        this.getPropKeys().forEach((propKey) => {
+            Object.defineProperty(this, propKey, {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    var _a;
+                    return (_a = this._props) === null || _a === void 0 ? void 0 : _a[propKey];
+                },
+                set() {
+                    throw new Error(`Prop "${propKey.toString()}" cannot be set directly`);
+                },
+            });
+        });
+    }
+    isMutable() {
+        return this.constructor.isMutable();
+    }
+    getPropKeys() {
+        if (!this._propKeys) {
+            this._propKeys = (0, model_metadata_1.getPropKeySet)(Reflect.getPrototypeOf(this));
+        }
+        return this._propKeys;
+    }
+    validateProps(props) {
+        const { validator } = this.getModelMetadata();
+        if (validator)
+            validator(props);
+    }
+    validate() {
+        this.validateProps(this._props);
+    }
+    getModelMetadata() {
+        if (!this._metadata) {
+            this._metadata = (0, model_metadata_1.getModelMetadata)(this.constructor);
+        }
+        return this._metadata;
+    }
+    modelName() {
+        return this.getModelMetadata().name;
+    }
+    props() {
+        return lodash_1.default.cloneDeepWith(this._props, (value) => {
+            if (ModelBase.isModel(value)) {
+                value.redefineModel();
+                return value;
+            }
+        });
+    }
+    initializeProps(props) {
+        if (this._props !== ModelBase.EMPTY_PROPS)
+            throw new Error("Props is initialized");
+        if (!this.isMutable()) {
+            this._props = props;
+            Object.freeze(this._props);
+        }
+        else {
+            this._props = new Proxy(props, {
+                set: (target, propKey, value) => {
+                    let result = Reflect.set(target, propKey, value);
+                    this.validate();
+                    return result;
+                },
+            });
+        }
+        this.validate();
+    }
+}
+exports.ModelBase = ModelBase;
+ModelBase.EMPTY_PROPS = {};

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

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

package/dist/core/value-object.js

@@ -3,12 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueObject = void 0;
+exports.ValueObjectBase = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const model_1 = require("./model");
-class ValueObject extends model_1.Model {
+class ValueObjectBase extends model_1.ModelBase {
     constructor(props) {
-        super(props);
+        super();
+        this.initializeProps(props);
     }
     equals(vo) {
         const equalsType = vo instanceof this.constructor;
@@ -20,4 +21,4 @@ class ValueObject extends model_1.Model {
         return new this.constructor(newProps);
     }
 }
-exports.ValueObject = ValueObject;
+exports.ValueObjectBase = ValueObjectBase;

package/dist/decorators/aggregate.d.ts

@@ -1,6 +1,3 @@
-import { AggregateClass, AggregateESClass, CommandHandler, EventApplier } from "../core/aggregate";
-import { AnyCommand, CommandClass } from "../core/command";
-import { AnyEvent, EventClass } from "../core/event";
-export declare const aggregate: (name?: string) => <T extends AggregateClass | AggregateESClass>(target: T) => void;
-export declare const applyEvent: <T extends AnyEvent>(eventClass: EventClass<T>) => <U extends EventApplier<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
-export declare const handleCommand: <T extends AnyCommand>(commandClass: CommandClass<T>) => <U extends CommandHandler<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
+import { AnyCommand, AnyEvent, CommandClass, CommandHandler, EventApplier, EventClass } from "../core/index";
+export declare const ApplyEvent: <T extends AnyEvent>(eventClass: EventClass<T>) => <U extends EventApplier<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;
+export declare const HandleCommand: <T extends AnyCommand>(commandClass: CommandClass<T>) => <U extends CommandHandler<T>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<U>) => void;

package/dist/decorators/aggregate.js

@@ -1,29 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleCommand = exports.applyEvent = exports.aggregate = void 0;
-const metadata_1 = require("../core/metadata");
-const model_type_1 = require("../core/model-type");
-const model_1 = require("./model");
-const aggregate = (name) => (target) => {
-    const aggregateType = new model_type_1.AggregateType(name !== null && name !== void 0 ? name : target.name);
-    (0, model_1.model)(aggregateType.value)(target);
-};
-exports.aggregate = aggregate;
-const applyEvent = (eventClass) => {
+exports.HandleCommand = exports.ApplyEvent = void 0;
+const _core_1 = require("../core/index");
+const ApplyEvent = (eventClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const type = (0, metadata_1.getModelType)(eventClass.prototype);
-            (0, metadata_1.defineEventApplier)(target, type, descriptor.value);
+            const eventName = (0, _core_1.getModelName)(eventClass);
+            (0, _core_1.defineEventApplier)(target, eventName, descriptor.value);
         }
     };
 };
-exports.applyEvent = applyEvent;
-const handleCommand = (commandClass) => {
+exports.ApplyEvent = ApplyEvent;
+const HandleCommand = (commandClass) => {
     return (target, propertyKey, descriptor) => {
         if (typeof descriptor.value === "function") {
-            const type = (0, metadata_1.getModelType)(commandClass.prototype);
-            (0, metadata_1.defineCommandHandler)(target, type, descriptor.value);
+            const commandName = (0, _core_1.getModelName)(commandClass);
+            (0, _core_1.defineCommandHandler)(target, commandName, descriptor.value);
         }
     };
 };
-exports.handleCommand = handleCommand;
+exports.HandleCommand = HandleCommand;

package/dist/decorators/id.d.ts

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

package/dist/decorators/id.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.id = void 0;
-const metadata_1 = require("../core/metadata");
-const id = (idGenerator) => {
+exports.UseId = void 0;
+const _core_1 = require("../core/index");
+const UseId = (idGenerator) => {
     return (target) => {
-        console.log("Target", target);
-        (0, metadata_1.defineIdGenerator)(target, idGenerator);
+        (0, _core_1.defineIdGenerator)(target, idGenerator);
     };
 };
-exports.id = id;
+exports.UseId = UseId;

package/dist/decorators/index.d.ts

@@ -1,7 +1,3 @@
 export * from "./aggregate";
-export * from "./command";
-export * from "./entity";
-export * from "./event";
 export * from "./id";
 export * from "./model";
-export * from "./value-object";

package/dist/decorators/index.js

@@ -15,9 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
-__exportStar(require("./command"), exports);
-__exportStar(require("./entity"), exports);
-__exportStar(require("./event"), exports);
 __exportStar(require("./id"), exports);
 __exportStar(require("./model"), exports);
-__exportStar(require("./value-object"), exports);

package/dist/decorators/model.d.ts

@@ -1,3 +1,12 @@
-import { ModelClass } from "../core/model";
-import { ModelTypePattern } from "../core/model-type";
-export declare const model: (type: ModelTypePattern) => <T extends ModelClass>(target: T) => void;
+import { AnyModel, ModelClass, PropsValidator } from "../core/index";
+import { TypedClassDecorator } from "./type";
+export declare const Prop: (target: object, propKey: string) => void;
+export declare const Name: (name?: string) => <T extends AnyModel>(target: ModelClass<T>) => void;
+export declare const Validate: <T extends AnyModel>(validator?: PropsValidator<T> | undefined) => (target: ModelClass<T>) => void;
+export type ModelOptions<T extends AnyModel> = {
+    name?: string;
+    validator?: PropsValidator<T>;
+};
+export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(options?: ModelOptions<I>): TypedClassDecorator<T>;
+export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name?: string, validator?: PropsValidator<I>): TypedClassDecorator<T>;
+export declare function Model<T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(name?: string, options?: Omit<ModelOptions<I>, "name">): TypedClassDecorator<T>;

package/dist/decorators/model.js

@@ -1,12 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.model = void 0;
-const metadata_1 = require("../core/metadata");
-const registry_1 = require("../core/registry");
-const model = (type) => {
+exports.Model = exports.Validate = exports.Name = exports.Prop = void 0;
+const _core_1 = require("../core/index");
+const Prop = (target, propKey) => {
+    (0, _core_1.setPropKey)(target, propKey);
+};
+exports.Prop = Prop;
+const Name = (name) => {
+    return (target) => {
+        (0, _core_1.setModelName)(target, name !== null && name !== void 0 ? name : target.name);
+    };
+};
+exports.Name = Name;
+const Validate = (validator) => {
     return (target) => {
-        registry_1.ModelRegistry.instance().registerModel(type, target);
-        (0, metadata_1.defineModelType)(target.prototype, type);
+        if (validator)
+            (0, _core_1.setValidateProps)(target, validator);
     };
 };
-exports.model = model;
+exports.Validate = Validate;
+function Model(p1, p2) {
+    return (target) => {
+        let options = {};
+        if (p1 && !p2) {
+            if (typeof p1 === "string")
+                options = { name: p1 };
+            else
+                options = p1;
+        }
+        else if (p1 && p2) {
+            p1 = p1;
+            if (typeof p2 === "function")
+                options = { name: p1, validator: p2 };
+            else
+                options = Object.assign({ name: p1 }, p2);
+        }
+        const { name, validator } = options;
+        (0, exports.Name)(name)(target);
+        (0, exports.Validate)(validator)(target);
+    };
+}
+exports.Model = Model;

package/dist/decorators/type.d.ts

@@ -0,0 +1,2 @@
+import { Class } from "type-fest";
+export type TypedClassDecorator<T extends Class<any> = Class<any>> = (target: T) => T | void;

package/dist/decorators/type.js

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

package/dist/types/class-static.d.ts

@@ -1,2 +1,2 @@
-import { Class } from "./class";
-export type ClassStatic<T extends Class<any>> = Omit<T, "constructor" | "prototype">;
+import { AnyClass } from "./class";
+export type ClassStatic<T extends AnyClass<any>> = Omit<T, "constructor" | "prototype">;

package/dist/types/class.d.ts

@@ -1,4 +1,2 @@
-export type Constructor<T, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
-export type Class<T, Arguments extends unknown[] = any[]> = Constructor<T, Arguments> & {
-    prototype: T;
-};
+import { AbstractClass, Class } from "type-fest";
+export type AnyClass<T = any> = Class<T> | AbstractClass<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "9.1.0",
+  "version": "12.1.0",
   "description": "Domain Driven Design base for NodeJs",
   "main": "dist/index.js",
   "scripts": {
@@ -29,8 +29,10 @@
   },
   "dependencies": {
     "lodash": "^4.17.21",
+    "nodejs-snowflake": "^2.0.1",
     "reflect-metadata": "^0.1.13",
     "tsc-alias": "^1.8.8",
+    "type-fest": "^4.15.0",
     "uuid": "^9.0.1"
   }
 }

package/tsconfig.json

@@ -30,10 +30,10 @@
     // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
     "baseUrl": "./" /* Specify the base directory to resolve non-relative module names. */,
     "paths": {
-      "#core/*": ["src/core/*"],
-      "#decorators/*": ["src/decorator/*"],
-      "#utils/*": ["src/utils/*"],
-      "#types/*": ["src/types/*"]
+      "#core": ["src/core/index"],
+      "#decorators": ["src/decorators/index"],
+      "#utils": ["src/utils/index"],
+      "#types": ["src/types/index"]
     } /* Specify a set of entries that re-map imports to additional lookup locations. */,
     // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
     // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */

package/dist/core/id.d.ts

@@ -1,17 +0,0 @@
-export declare class Id {
-    private _value;
-    constructor(value: string);
-    get value(): string;
-    equals(id: Id): boolean;
-}
-export declare abstract class IdGenerator {
-    abstract generateValue(): string;
-    abstract validateValue(value: string): void;
-    fromValue(value: string): Id;
-    fromId(id: Id): Id;
-    newId(): Id;
-}
-export declare class Uuid4Generator extends IdGenerator {
-    generateValue(): string;
-    validateValue(value: string): boolean;
-}