ddd-node 17.3.0 → 20.0.0

package/dist/model/meta/model-static-values.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineStaticValueProperty = exports.getStaticValue = exports.setStaticValue = exports.getOwnStaticValues = exports.StaticValuesMap = exports.StaticValue = void 0;
+class StaticValue {
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        if (typeof this._value === "function") {
+            this._value = this._value();
+        }
+        return this._value;
+    }
+}
+exports.StaticValue = StaticValue;
+const OwnStaticValuesMetaKey = Symbol.for("OWN_STATIC_VALUES");
+class StaticValuesMap extends Map {
+}
+exports.StaticValuesMap = StaticValuesMap;
+const getOwnStaticValues = (target) => {
+    if (!Reflect.hasOwnMetadata(OwnStaticValuesMetaKey, target))
+        Reflect.defineMetadata(OwnStaticValuesMetaKey, new StaticValuesMap(), target);
+    return Reflect.getOwnMetadata(OwnStaticValuesMetaKey, target);
+};
+exports.getOwnStaticValues = getOwnStaticValues;
+const setStaticValue = (target, key, value) => {
+    const staticValues = (0, exports.getOwnStaticValues)(target);
+    staticValues.set(key, new StaticValue(value));
+};
+exports.setStaticValue = setStaticValue;
+const getStaticValue = (target, key) => {
+    let _target = target;
+    do {
+        const staticValues = (0, exports.getOwnStaticValues)(_target);
+        if (staticValues.has(key))
+            return staticValues.get(key)?.value;
+        _target = Reflect.getPrototypeOf(_target);
+    } while (_target !== null);
+    return undefined;
+};
+exports.getStaticValue = getStaticValue;
+const defineStaticValueProperty = (target, key) => {
+    Object.defineProperty(target, key, {
+        configurable: false,
+        enumerable: true,
+        get() {
+            return (0, exports.getStaticValue)(target, key);
+        },
+        set() {
+            throw new Error("Static value is readonly");
+        },
+    });
+};
+exports.defineStaticValueProperty = defineStaticValueProperty;

package/dist/model/meta/model-version.d.ts

@@ -0,0 +1,8 @@
+import { AnyModel, ModelClass } from "../core";
+export type ModelVersion = number;
+export declare class MVersion extends Number {
+    static validate(modelVersion: ModelVersion): void;
+    constructor(modelVersion: ModelVersion);
+}
+export declare const defineModelVersion: <T extends AnyModel>(target: ModelClass<T>, modelVersion: ModelVersion) => void;
+export declare const getModelVersion: <T extends AnyModel>(target: ModelClass<T>) => ModelVersion;

package/dist/model/meta/model-version.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelVersion = exports.defineModelVersion = exports.MVersion = void 0;
+class MVersion extends Number {
+    static validate(modelVersion) {
+        if (modelVersion < 0 && Number.isInteger(modelVersion))
+            throw new Error("Model version must be a non-negative integer number");
+    }
+    constructor(modelVersion) {
+        MVersion.validate(modelVersion);
+        super(modelVersion);
+    }
+}
+exports.MVersion = MVersion;
+const ModelVersionMetaKey = Symbol.for("MODEL_VERSION");
+const defineModelVersion = (target, modelVersion) => {
+    Reflect.defineMetadata(ModelVersionMetaKey, new MVersion(modelVersion), target);
+};
+exports.defineModelVersion = defineModelVersion;
+const getModelVersion = (target) => {
+    if (!Reflect.hasOwnMetadata(ModelVersionMetaKey, target))
+        (0, exports.defineModelVersion)(target, 0);
+    return Reflect.getOwnMetadata(ModelVersionMetaKey, target).valueOf();
+};
+exports.getModelVersion = getModelVersion;

package/dist/model/model-registry.d.ts

@@ -0,0 +1,17 @@
+import { AnyModel, ModelClass } from "./core";
+import { ModelId, ModelName, ModelVersion } from "./meta";
+export declare class ModelVersionMap<T extends AnyModel = AnyModel> extends Map<ModelVersion, ModelClass<T>> {
+    readonly modelName: ModelName;
+    constructor(modelName: ModelName);
+}
+export declare class ModelMap<T extends AnyModel = AnyModel> extends Map<ModelName, ModelVersionMap<T>> {
+}
+export declare class ModelRegistry {
+    private readonly modelMap;
+    getModelVersionMap<T extends AnyModel = AnyModel>(modelName: ModelName): ModelVersionMap<T>;
+    getModel<T extends AnyModel = AnyModel>(modelName: ModelName, modelVersion?: ModelVersion): ModelClass<T> | undefined;
+    getModelByModelId<T extends AnyModel = AnyModel>(modelId: ModelId): ModelClass<T> | undefined;
+    hasRegisteredModel(modelName: ModelName, modelVersion: ModelVersion): boolean;
+    hasRegisteredModel(model: ModelClass): boolean;
+    registerModel(modelClass: ModelClass): this;
+}

package/dist/model/model-registry.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelRegistry = exports.ModelMap = exports.ModelVersionMap = void 0;
+const meta_1 = require("./meta");
+class ModelVersionMap extends Map {
+    constructor(modelName) {
+        super();
+        this.modelName = modelName;
+    }
+}
+exports.ModelVersionMap = ModelVersionMap;
+class ModelMap extends Map {
+}
+exports.ModelMap = ModelMap;
+class ModelRegistry {
+    constructor() {
+        this.modelMap = new ModelMap();
+    }
+    getModelVersionMap(modelName) {
+        const modelVersionMap = () => this.modelMap.get(modelName);
+        if (!modelVersionMap())
+            this.modelMap.set(modelName, new ModelVersionMap(modelName));
+        return modelVersionMap();
+    }
+    getModel(modelName, modelVersion = 0) {
+        const modelVersionMap = this.getModelVersionMap(modelName);
+        return modelVersionMap.get(modelVersion);
+    }
+    getModelByModelId(modelId) {
+        const { modelName, modelVersion } = meta_1.MId.fromValue(modelId);
+        return this.getModel(modelName, modelVersion);
+    }
+    hasRegisteredModel(p1, p2) {
+        let modelName, modelVersion;
+        if (typeof p1 === "string") {
+            modelName = p1;
+            modelVersion = p2;
+        }
+        else {
+            modelName = p1.modelMetadata().modelName;
+            modelVersion = p1.modelMetadata().modelVersion;
+        }
+        return Boolean(this.getModel(modelName, modelVersion));
+    }
+    registerModel(modelClass) {
+        const modelName = modelClass.modelMetadata().modelName;
+        const modelVersion = modelClass.modelMetadata().modelVersion;
+        if (this.hasRegisteredModel(modelName, modelVersion))
+            throw new Error(`Model ${modelName} with version ${modelVersion} has been registered`);
+        const modelVersionMap = this.getModelVersionMap(modelName);
+        modelVersionMap.set(modelVersion, modelClass);
+        return this;
+    }
+}
+exports.ModelRegistry = ModelRegistry;

package/dist/package.json

@@ -1 +1 @@
-{"name":"ddd-node","version":"17.3.0","description":"Domain Driven Design base for NodeJs","type":"commonjs","main":"index.js","types":"index.d.ts","files":["dist"],"repository":{"type":"git","url":"https://github.com/nqd881/ddd-node"},"keywords":["ddd","ddd-node","ddd-base","ddd-ts","ddd-js"],"author":"Quoc Dai","license":"ISC","devDependencies":{"@types/chai":"^4.3.16","@types/lodash":"^4.14.200","@types/mocha":"^10.0.6","@types/uuid":"^9.0.6","chai":"^5.1.1","chai-deep-match":"^1.2.1","ddd-node":"file:dist","mocha":"^10.4.0","ts-node":"^10.9.1","tsconfig-paths":"^4.2.0","typescript":"^5.2.2"},"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"}}
+{"name":"ddd-node","version":"20.0.0","description":"Domain Driven Design base for NodeJs","type":"commonjs","main":"index.js","types":"index.d.ts","files":["dist"],"repository":{"type":"git","url":"https://github.com/nqd881/ddd-node"},"keywords":["ddd","ddd-node","ddd-base","ddd-ts","ddd-js"],"author":"Quoc Dai","license":"ISC","devDependencies":{"@types/chai":"^4.3.16","@types/lodash":"^4.14.200","@types/mocha":"^10.0.6","@types/uuid":"^9.0.6","chai":"^5.1.1","chai-deep-match":"^1.2.1","ddd-node":"file:dist","mocha":"^10.4.0","ts-node":"^10.9.1","tsconfig-paths":"^4.2.0","typescript":"^5.2.2"},"dependencies":{"lodash":"^4.17.21","nodejs-snowflake":"^2.0.1","reflect-metadata":"^0.1.13","tsc-alias":"^1.8.8","type-fest":"^4.20.1","uuid":"^9.0.1"}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-node",
-  "version": "17.3.0",
+  "version": "20.0.0",
   "description": "Domain Driven Design base for NodeJs",
   "type": "module",
   "main": "dist/index.js",
@@ -43,7 +43,7 @@
     "nodejs-snowflake": "^2.0.1",
     "reflect-metadata": "^0.1.13",
     "tsc-alias": "^1.8.8",
-    "type-fest": "^4.15.0",
+    "type-fest": "^4.20.1",
     "uuid": "^9.0.1"
   },
   "mocha": {

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

@@ -1,12 +0,0 @@
-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 version(): number;
-    protected newEvent<E extends AnyEvent>(eventClass: EventClassWithTypedConstructor<E>, props: PropsOf<E>): E;
-}

package/dist/core/domain.d.ts

@@ -1,17 +0,0 @@
-import { ModelName, ModelVersion } from "../meta";
-import { AnyModel, ModelClass } from "./model";
-export declare class ModelVersionRegistry<T extends AnyModel = AnyModel> extends Map<ModelVersion, ModelClass<T>> {
-}
-export declare class ModelRegistry<T extends AnyModel = AnyModel> extends Map<ModelName, ModelVersionRegistry<T>> {
-}
-export type DomainName = string;
-export declare class Domain {
-    readonly name: DomainName;
-    private readonly modelRegistry;
-    constructor(name: DomainName);
-    getModelVersionRegistry(modelName: ModelName): ModelVersionRegistry<AnyModel>;
-    getModel(modelName: ModelName, modelVersion?: ModelVersion): ModelClass<AnyModel> | undefined;
-    hasRegisteredModel(modelName: ModelName, modelVersion: ModelVersion): boolean;
-    hasRegisteredModel(model: ModelClass): boolean;
-    registerModel(modelClass: ModelClass): this;
-}

package/dist/core/domain.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Domain = exports.ModelRegistry = exports.ModelVersionRegistry = void 0;
-class ModelVersionRegistry extends Map {
-}
-exports.ModelVersionRegistry = ModelVersionRegistry;
-class ModelRegistry extends Map {
-}
-exports.ModelRegistry = ModelRegistry;
-class Domain {
-    constructor(name) {
-        this.modelRegistry = new ModelRegistry();
-        this.name = name;
-    }
-    getModelVersionRegistry(modelName) {
-        const modelVersionRegistry = () => this.modelRegistry.get(modelName);
-        if (!modelVersionRegistry())
-            this.modelRegistry.set(modelName, new ModelVersionRegistry());
-        return modelVersionRegistry();
-    }
-    getModel(modelName, modelVersion = 0) {
-        const modelVersionRegistry = this.getModelVersionRegistry(modelName);
-        return modelVersionRegistry.get(modelVersion);
-    }
-    hasRegisteredModel(p1, p2) {
-        let modelName, modelVersion;
-        if (typeof p1 === "string") {
-            modelName = p1;
-            modelVersion = p2;
-        }
-        else {
-            modelName = p1.modelName();
-            modelVersion = p1.modelVersion();
-        }
-        return Boolean(this.getModel(modelName, modelVersion));
-    }
-    registerModel(modelClass) {
-        const modelName = modelClass.modelName();
-        const modelVersion = modelClass.modelVersion();
-        if (this.hasRegisteredModel(modelName, modelVersion))
-            throw new Error(`Model ${modelName} with version ${modelVersion} has been registered`);
-        const modelVersionRegistry = this.getModelVersionRegistry(modelName);
-        modelVersionRegistry.set(modelVersion, modelClass);
-        return this;
-    }
-}
-exports.Domain = Domain;

package/dist/core/entity.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityBase = void 0;
-const model_1 = require("./model");
-class EntityBase extends model_1.ModelWithId {
-    constructor(metadata, props) {
-        super(metadata.id);
-        if (props)
-            this.initializeProps(props);
-    }
-    static mutable() {
-        return true;
-    }
-    static newEntity(props, id) {
-        return new this({
-            id: this.id(id),
-        }, props);
-    }
-}
-exports.EntityBase = EntityBase;

package/dist/core/enum.d.ts

@@ -1,18 +0,0 @@
-import { ClassStatic } from "../types";
-import { Class } from "type-fest";
-import { ModelBase } from "./model";
-export type EnumValue = string | number;
-export interface EnumProps {
-    value: EnumValue;
-}
-export declare class EnumBase extends ModelBase<EnumProps> {
-    static values(): EnumBase[];
-    static parseSafe<T extends EnumBase>(this: EnumClass<T>, providedValue: EnumValue): T | undefined;
-    static parse<T extends EnumBase>(this: EnumClass<T>, providedValue: EnumValue): T;
-    constructor(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,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumBase = void 0;
-const model_1 = require("./model");
-class EnumBase extends model_1.ModelBase {
-    static values() {
-        return Array.from(this.ownStaticValues().values()).map((staticValue) => staticValue.value);
-    }
-    static parseSafe(providedValue) {
-        let key = undefined;
-        this.ownStaticValues().forEach((staticValue, staticValueKey) => {
-            if (staticValue.value instanceof this) {
-                const staticEnum = staticValue.value;
-                if (staticEnum.value === providedValue && !key) {
-                    key = staticValueKey;
-                }
-            }
-        });
-        if (key)
-            return this.ownStaticValues().get(key)?.value;
-        return undefined;
-    }
-    static parse(providedValue) {
-        const parsedEnum = this.parseSafe(providedValue);
-        if (!parsedEnum)
-            throw new Error(`Invalid provided value for enum ${this.modelName()}`);
-        return parsedEnum;
-    }
-    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;

package/dist/core/message/command.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandBase = void 0;
-const message_1 = require("./message");
-const meta_1 = require("../../meta");
-class CommandBase extends message_1.MessageBase {
-    constructor(metadata, props) {
-        super({ ...metadata, messageType: CommandBase.COMMAND_MESSAGE_TYPE }, props);
-    }
-    static commandType() {
-        return (0, meta_1.getCommandType)(this) || this.modelName();
-    }
-    static newCommand(props, context, timestamp) {
-        return new this({
-            id: this.id(),
-            context,
-            timestamp,
-        }, props);
-    }
-    commandType() {
-        return this.constructor.commandType();
-    }
-}
-exports.CommandBase = CommandBase;
-CommandBase.COMMAND_MESSAGE_TYPE = "command";

package/dist/core/message/event.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventBase = void 0;
-const message_1 = require("./message");
-const meta_1 = require("../../meta");
-class EventBase extends message_1.MessageBase {
-    constructor(metadata, props) {
-        super({ ...metadata, messageType: EventBase.EVENT_MESSAGE_TYPE }, props);
-        this._source = metadata.source;
-    }
-    static eventType() {
-        return (0, meta_1.getEventType)(this) || this.modelName();
-    }
-    static newEvent(source, props, context, timestamp) {
-        return new this({
-            id: this.id(),
-            source,
-            context,
-            timestamp,
-        }, props);
-    }
-    source() {
-        return this._source;
-    }
-    eventType() {
-        return this.constructor.eventType();
-    }
-}
-exports.EventBase = EventBase;
-EventBase.EVENT_MESSAGE_TYPE = "event";

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

@@ -1,23 +0,0 @@
-import { Id } from "../id";
-import { ModelWithId, Props } from "../model";
-export interface MessageContext {
-    correlationId?: string;
-    causationId?: string;
-}
-export interface MessageMetadata {
-    readonly id: Id;
-    readonly messageType: string;
-    readonly timestamp?: number;
-    context?: MessageContext;
-}
-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;
-    messageType(): string;
-    timestamp(): number;
-    context(): MessageContext | undefined;
-    setContext(context: Partial<MessageContext>): void;
-}

package/dist/core/message/message.js

@@ -1,33 +0,0 @@
-"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 {
-    constructor(metadata, props) {
-        super(metadata.id);
-        this._messageType = metadata.messageType;
-        this._context = metadata?.context ?? {};
-        this._timestamp = metadata.timestamp ?? Date.now();
-        this.initializeProps(props);
-    }
-    props() {
-        return super.props();
-    }
-    messageType() {
-        return this._messageType;
-    }
-    timestamp() {
-        return this._timestamp;
-    }
-    context() {
-        return this._context;
-    }
-    setContext(context) {
-        this._context = lodash_1.default.merge(this._context, context);
-    }
-}
-exports.MessageBase = MessageBase;

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

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

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

@@ -1,47 +0,0 @@
-import { Class } from "type-fest";
-import { ModelId } from "../../meta";
-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: EmptyProps;
-    protected _props: P;
-    static isModel(model: any): model is AnyModel;
-    static mutable(): boolean;
-    static modelName<T extends AnyModel>(this: ModelClass<T>): string;
-    static modelVersion<T extends AnyModel>(this: ModelClass<T>): number;
-    static modelId<T extends AnyModel>(this: ModelClass<T>): `${string}|${number}`;
-    static hasModelId<T extends AnyModel>(this: ModelClass<T>, modelId: ModelId): boolean;
-    static ownPropsValidator<T extends AnyModel>(this: ModelClass<T>): import("../../meta").PropsValidator<T> | undefined;
-    static propsValidators<T extends AnyModel>(this: ModelClass<T>): import("../../meta").PropsValidator<AnyModel>[];
-    static ownStaticValues<T extends AnyModel>(this: ModelClass<T>): Map<PropertyKey, import("../../meta").StaticValue<T>>;
-    static ownPropsMap(): import("../../meta").PropsMap<ModelBase<any>>;
-    static propsMap(): import("../../meta").PropsMap<ModelBase<any>>;
-    constructor();
-    protected redefineModel(): void;
-    protected redefineProp(key: keyof this, propTargetKey: keyof P): void;
-    protected get _modelClass(): ModelClass<typeof this>;
-    isMutable(): boolean;
-    modelName(): string;
-    modelVersion(): number;
-    modelId(): `${string}|${number}`;
-    hasModelId(modelId: ModelId): boolean;
-    ownPropsValidator(): import("../../meta").PropsValidator<this> | undefined;
-    propsValidators(): import("../../meta").PropsValidator<AnyModel>[];
-    ownPropsMap(): import("../../meta").PropsMap<ModelBase<any>>;
-    propsMap(): import("../../meta").PropsMap<any>;
-    validateProps(props: P): void;
-    validate(): void;
-    propsIsEmpty(): boolean;
-    props(): P | null;
-    protected initializeProps(props: P): void;
-}
-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>>> {
-}

package/dist/core/value-object.js

@@ -1,27 +0,0 @@
-"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 {
-    constructor(props) {
-        super();
-        this.initializeProps(props);
-    }
-    props() {
-        return super.props();
-    }
-    equals(vo) {
-        const equalsType = vo instanceof this.constructor;
-        const equalsValue = JSON.stringify(vo.props()) === JSON.stringify(this.props());
-        return equalsType && equalsValue;
-    }
-    with(props) {
-        const newProps = lodash_1.default.merge(this.props(), props);
-        return new this.constructor(newProps);
-    }
-}
-exports.ValueObjectBase = ValueObjectBase;

package/dist/decorators/id.d.ts

@@ -1,2 +0,0 @@
-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 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UseIdService = void 0;
-const meta_1 = require("../meta");
-const UseIdService = (idService) => {
-    return (target) => {
-        (0, meta_1.defineIdService)(target, idService);
-    };
-};
-exports.UseIdService = UseIdService;

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

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

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

@@ -1,6 +0,0 @@
-export * from "./prop";
-export * from "./model";
-export * from "./version";
-export * from "./validator";
-export * from "./static";
-export * from "./enum";

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

@@ -1,2 +0,0 @@
-import { ModelClass } from "../../core";
-export declare const Model: (name: string) => <T extends ModelClass<import("../../core").AnyModel>>(target: T) => void;

package/dist/decorators/model/model.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
-const meta_1 = require("../../meta");
-const Model = (name) => {
-    return (target) => {
-        (0, meta_1.setModelName)(target, name);
-    };
-};
-exports.Model = Model;

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

@@ -1,2 +0,0 @@
-import { AnyModel, PropKey, PropsOf } from "../../core";
-export declare const Prop: <T extends AnyModel>(propTargetKey?: keyof PropsOf<T> | undefined) => (target: T, key: PropKey) => void;

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

@@ -1,3 +0,0 @@
-import { ModelClass } from "../../core";
-import { StaticValueBuilder } from "../../meta";
-export declare const Static: <T extends ModelClass<import("../../core").AnyModel>, I extends InstanceType<T> = InstanceType<T>>(builder: StaticValueBuilder<I>) => (target: T, key: string) => void;

package/dist/decorators/model/static.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Static = void 0;
-const meta_1 = require("../../meta");
-const Static = (builder) => {
-    return (target, key) => {
-        (0, meta_1.setStaticValue)(target, key, builder);
-        Object.defineProperty(target, key, {
-            configurable: false,
-            enumerable: true,
-            get() {
-                return (0, meta_1.getStaticValue)(target, key);
-            },
-            set() {
-                throw new Error("Static value is readonly");
-            },
-        });
-    };
-};
-exports.Static = Static;

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

@@ -1,3 +0,0 @@
-import { ModelClass } from "../../core";
-import { PropsValidator } from "../../meta";
-export declare const Validator: <T extends ModelClass<import("../../core").AnyModel>, I extends InstanceType<T> = InstanceType<T>>(validator?: PropsValidator<I> | undefined) => (target: T) => void;

package/dist/decorators/model/validator.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = void 0;
-const meta_1 = require("../../meta");
-const Validator = (validator) => {
-    return (target) => {
-        if (validator)
-            (0, meta_1.setPropsValidator)(target, validator);
-    };
-};
-exports.Validator = Validator;

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

@@ -1,2 +0,0 @@
-import { ModelClass } from "../../core";
-export declare const Version: (version: number) => <T extends ModelClass<import("../../core").AnyModel>>(target: T) => void;