ddd-node 12.1.0 → 12.2.0

package/dist/core/enum.d.ts

@@ -0,0 +1,13 @@
+import { Class } from "type-fest";
+import { ValueObjectBase } from "./value-object";
+import { ClassStatic } from "../types/index";
+export type EnumValue = string | number;
+export interface EnumProps<V extends EnumValue> {
+    value: V;
+}
+export declare class EnumBase<V extends EnumValue = EnumValue> extends ValueObjectBase<EnumProps<V>> {
+    constructor(value: V);
+    value: V;
+}
+export type ValueOf<T extends EnumBase> = T extends EnumBase<infer V extends EnumValue> ? V : never;
+export type EnumClass<T extends EnumBase = EnumBase> = Class<T> & ClassStatic<typeof EnumBase>;

package/dist/core/enum.js

@@ -0,0 +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.EnumBase = void 0;
+const _decorators_1 = require("../decorators/index");
+const value_object_1 = require("./value-object");
+class EnumBase extends value_object_1.ValueObjectBase {
+    constructor(value) {
+        super({ value });
+    }
+}
+exports.EnumBase = EnumBase;
+__decorate([
+    _decorators_1.Prop,
+    __metadata("design:type", Object)
+], EnumBase.prototype, "value", void 0);

package/dist/core/index.d.ts

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

package/dist/core/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aggregate"), exports);
 __exportStar(require("./entity"), exports);
+__exportStar(require("./enum"), exports);
 __exportStar(require("./error"), exports);
 __exportStar(require("./id"), exports);
 __exportStar(require("./message"), exports);

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

@@ -2,15 +2,6 @@
 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)

package/dist/decorators/model.d.ts

@@ -10,3 +10,4 @@ export type ModelOptions<T extends AnyModel> = {
 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>;
+export declare const Static: <T extends ModelClass, I extends InstanceType<T> = InstanceType<T>>(builder: () => I) => (target: T, key: Extract<keyof T, string>) => void;

package/dist/decorators/model.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = exports.Validate = exports.Name = exports.Prop = void 0;
+exports.Static = 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);
@@ -41,3 +41,33 @@ function Model(p1, p2) {
     };
 }
 exports.Model = Model;
+// Lazy builder for static value (value of static prop is an instance of that model)
+const Static = (builder) => {
+    return (target, key) => {
+        const type = Reflect.getMetadata("design:type", target, key);
+        const STATIC_VALUES_KEY = "_staticValues";
+        const typedTarget = target;
+        if (!typedTarget[STATIC_VALUES_KEY])
+            Object.defineProperty(target, STATIC_VALUES_KEY, {
+                configurable: false,
+                enumerable: false,
+                writable: false,
+                value: new Map(),
+            });
+        Object.defineProperty(target, key, {
+            configurable: false,
+            enumerable: true,
+            get() {
+                const staticValues = typedTarget[STATIC_VALUES_KEY];
+                if (!staticValues.has(key)) {
+                    const value = builder();
+                    if (!(value instanceof type))
+                        throw new Error(`Invalid return type. The return of builder must be an instance of model ${type.modelName()} (class ${type.name})`);
+                    staticValues.set(key, value);
+                }
+                return staticValues.get(key);
+            },
+        });
+    };
+};
+exports.Static = Static;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "12.1.0",
+  "version": "12.2.0",
   "description": "Domain Driven Design base for NodeJs",
   "main": "dist/index.js",
   "scripts": {