@rws-framework/db 2.1.11 → 2.2.1

package/dist/models/core/RWSModel.js

@@ -0,0 +1,375 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RWSModel = void 0;
+const decorators_1 = require("../../decorators");
+const FieldsHelper_1 = require("../../helper/FieldsHelper");
+const RelationUtils_1 = require("../utils/RelationUtils");
+const PaginationUtils_1 = require("../utils/PaginationUtils");
+const TimeSeriesUtils_1 = require("../utils/TimeSeriesUtils");
+const ModelUtils_1 = require("../utils/ModelUtils");
+const TimeSeriesModel_1 = __importDefault(require("./TimeSeriesModel"));
+class RWSModel {
+    constructor(data) {
+        if (!this.getCollection()) {
+            throw new Error('Model must have a collection defined');
+        }
+        this.dbService = RWSModel.services.dbService;
+        this.configService = RWSModel.services.configService;
+        if (!data) {
+            return;
+        }
+        if (!this.hasTimeSeries()) {
+            this._fill(data);
+        }
+        else {
+            throw new Error('Time Series not supported in synchronous constructor. Use `await Model.create(data)` static method to instantiate this model.');
+        }
+    }
+    checkForInclusionWithThrow() {
+        this.checkForInclusionWithThrow();
+    }
+    static checkForInclusionWithThrow(checkModelType) {
+        if (!this.checkForInclusion(this.name)) {
+            throw new Error('Model undefined: ' + this.name);
+        }
+    }
+    checkForInclusion() {
+        return this.checkForInclusion();
+    }
+    static checkForInclusion(checkModelType) {
+        return this.loadModels().find((definedModel) => {
+            return definedModel.name === checkModelType;
+        }) !== undefined;
+    }
+    _fill(data) {
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                const meta = Reflect.getMetadata(`InverseTimeSeries:${key}`, this.constructor.prototype);
+                if (meta) {
+                    data[key] = {
+                        create: data[key]
+                    };
+                }
+                else {
+                    this[key] = data[key];
+                }
+            }
+        }
+        return this;
+    }
+    hasRelation(key) {
+        return RelationUtils_1.RelationUtils.hasRelation(this, key);
+    }
+    bindRelation(key, relatedModel) {
+        return RelationUtils_1.RelationUtils.bindRelation(relatedModel);
+    }
+    async _asyncFill(data, fullDataMode = false, allowRelations = true) {
+        const collections_to_models = {};
+        const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(this);
+        const classFields = FieldsHelper_1.FieldsHelper.getAllClassFields(this.constructor);
+        // Get both relation metadata types asynchronously
+        const [relOneData, relManyData] = await Promise.all([
+            this.getRelationOneMeta(classFields),
+            this.getRelationManyMeta(classFields)
+        ]);
+        this.loadModels().forEach((model) => {
+            collections_to_models[model.getCollection()] = model;
+        });
+        const seriesHydrationfields = [];
+        if (allowRelations) {
+            // Handle many-to-many relations
+            for (const key in relManyData) {
+                if (!fullDataMode && this.constructor._CUT_KEYS.includes(key)) {
+                    continue;
+                }
+                const relMeta = relManyData[key];
+                const relationEnabled = RelationUtils_1.RelationUtils.checkRelEnabled(this, relMeta.key);
+                if (relationEnabled) {
+                    this[relMeta.key] = await relMeta.inversionModel.findBy({
+                        conditions: {
+                            [relMeta.foreignKey]: data.id
+                        },
+                        allowRelations: false
+                    });
+                }
+            }
+            // Handle one-to-one relations
+            for (const key in relOneData) {
+                if (!fullDataMode && this.constructor._CUT_KEYS.includes(key)) {
+                    continue;
+                }
+                const relMeta = relOneData[key];
+                const relationEnabled = RelationUtils_1.RelationUtils.checkRelEnabled(this, relMeta.key);
+                if (!data[relMeta.hydrationField] && relMeta.required) {
+                    throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`);
+                }
+                if (relationEnabled && data[relMeta.hydrationField]) {
+                    this[relMeta.key] = await relMeta.model.find(data[relMeta.hydrationField], { allowRelations: false });
+                }
+                else if (relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]) {
+                    const newRelModel = await relMeta.model.create(data[relMeta.key]);
+                    this[relMeta.key] = await newRelModel.save();
+                }
+                const cutKeys = this.constructor._CUT_KEYS;
+                if (!cutKeys.includes(relMeta.hydrationField)) {
+                    cutKeys.push(relMeta.hydrationField);
+                }
+            }
+        }
+        // Process regular fields and time series
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                if (!fullDataMode && this.constructor._CUT_KEYS.includes(key)) {
+                    continue;
+                }
+                if (Object.keys(relOneData).includes(key)) {
+                    continue;
+                }
+                if (seriesHydrationfields.includes(key)) {
+                    continue;
+                }
+                const timeSeriesMetaData = timeSeriesIds[key];
+                if (timeSeriesMetaData) {
+                    this[key] = data[key];
+                    const seriesModel = collections_to_models[timeSeriesMetaData.collection];
+                    const dataModels = await seriesModel.findBy({
+                        id: { in: data[key] }
+                    });
+                    seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
+                    this[timeSeriesMetaData.hydrationField] = dataModels;
+                }
+                else {
+                    this[key] = data[key];
+                }
+            }
+        }
+        return this;
+    }
+    getModelScalarFields(model) {
+        return ModelUtils_1.ModelUtils.getModelScalarFields(model);
+    }
+    async getRelationOneMeta(classFields) {
+        return RelationUtils_1.RelationUtils.getRelationOneMeta(this, classFields);
+    }
+    static async getRelationOneMeta(model, classFields) {
+        return RelationUtils_1.RelationUtils.getRelationOneMeta(model, classFields);
+    }
+    async getRelationManyMeta(classFields) {
+        return RelationUtils_1.RelationUtils.getRelationManyMeta(this, classFields);
+    }
+    static async getRelationManyMeta(model, classFields) {
+        return RelationUtils_1.RelationUtils.getRelationManyMeta(model, classFields);
+    }
+    static paginate(pageParams, findParams) {
+        return PaginationUtils_1.PaginationUtils.paginate.bind(this)(pageParams, findParams);
+    }
+    async toMongo() {
+        const data = {};
+        const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(this);
+        const timeSeriesHydrationFields = [];
+        for (const key in this) {
+            if (this.hasRelation(key)) {
+                data[key] = this.bindRelation(key, this[key]);
+                continue;
+            }
+            if (!(await this.isDbVariable(key))) {
+                continue;
+            }
+            const passedFieldCondition = this.hasOwnProperty(key) &&
+                !(this.constructor._BANNED_KEYS
+                    || RWSModel._BANNED_KEYS).includes(key) &&
+                !timeSeriesHydrationFields.includes(key);
+            if (passedFieldCondition) {
+                data[key] = this[key];
+            }
+            if (timeSeriesIds[key]) {
+                data[key] = this[key];
+                timeSeriesHydrationFields.push(timeSeriesIds[key].hydrationField);
+            }
+        }
+        return data;
+    }
+    getCollection() {
+        return this.constructor._collection || this._collection;
+    }
+    static getCollection() {
+        return this.constructor._collection || this._collection;
+    }
+    async save() {
+        const data = await this.toMongo();
+        let updatedModelData = data;
+        if (this.id) {
+            this.preUpdate();
+            updatedModelData = await this.dbService.update(data, this.getCollection());
+            await this._asyncFill(updatedModelData);
+            this.postUpdate();
+        }
+        else {
+            this.preCreate();
+            const isTimeSeries = this instanceof TimeSeriesModel_1.default;
+            updatedModelData = await this.dbService.insert(data, this.getCollection(), isTimeSeries);
+            await this._asyncFill(updatedModelData);
+            this.postCreate();
+        }
+        return this;
+    }
+    static async getModelAnnotations(constructor) {
+        return ModelUtils_1.ModelUtils.getModelAnnotations(constructor);
+    }
+    preUpdate() {
+        return;
+    }
+    postUpdate() {
+        return;
+    }
+    preCreate() {
+        return;
+    }
+    postCreate() {
+        return;
+    }
+    static isSubclass(constructor, baseClass) {
+        return ModelUtils_1.ModelUtils.isSubclass(constructor, baseClass);
+    }
+    hasTimeSeries() {
+        return TimeSeriesUtils_1.TimeSeriesUtils.checkTimeSeries(this.constructor);
+    }
+    static checkTimeSeries(constructor) {
+        return TimeSeriesUtils_1.TimeSeriesUtils.checkTimeSeries(constructor);
+    }
+    async isDbVariable(variable) {
+        return ModelUtils_1.ModelUtils.checkDbVariable(this.constructor, variable);
+    }
+    static async checkDbVariable(constructor, variable) {
+        return ModelUtils_1.ModelUtils.checkDbVariable(constructor, variable);
+    }
+    sanitizeDBData(data) {
+        const dataKeys = Object.keys(data);
+        const sanitizedData = {};
+        for (const key of dataKeys) {
+            if (this.isDbVariable(key)) {
+                sanitizedData[key] = data[key];
+            }
+        }
+        return sanitizedData;
+    }
+    static async watchCollection(preRun) {
+        const collection = Reflect.get(this, '_collection');
+        this.checkForInclusionWithThrow(this.name);
+        return await this.services.dbService.watchCollection(collection, preRun);
+    }
+    static async findOneBy(findParams) {
+        var _a, _b, _c, _d, _e;
+        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
+        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
+        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
+        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
+        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        this.checkForInclusionWithThrow('');
+        const collection = Reflect.get(this, '_collection');
+        const dbData = await this.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
+        if (dbData) {
+            const inst = new this();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+        return null;
+    }
+    static async find(id, findParams = null) {
+        var _a, _b, _c, _d;
+        const ordering = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _a !== void 0 ? _a : null;
+        const fields = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _b !== void 0 ? _b : null;
+        const allowRelations = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _c !== void 0 ? _c : true;
+        const fullData = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _d !== void 0 ? _d : false;
+        const collection = Reflect.get(this, '_collection');
+        this.checkForInclusionWithThrow(this.name);
+        const dbData = await this.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
+        if (dbData) {
+            const inst = new this();
+            return await inst._asyncFill(dbData, fullData, allowRelations);
+        }
+        return null;
+    }
+    static async findBy(findParams) {
+        var _a, _b, _c, _d, _e;
+        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
+        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
+        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
+        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
+        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const collection = Reflect.get(this, '_collection');
+        this.checkForInclusionWithThrow(this.name);
+        try {
+            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering);
+            if (dbData.length) {
+                const instanced = [];
+                for (const data of dbData) {
+                    const inst = new this();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                }
+                return instanced;
+            }
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
+    }
+    static async delete(conditions) {
+        const collection = Reflect.get(this, '_collection');
+        this.checkForInclusionWithThrow(this.name);
+        return await this.services.dbService.delete(collection, conditions);
+    }
+    async delete() {
+        const collection = Reflect.get(this, '_collection');
+        this.checkForInclusionWithThrow();
+        return await this.dbService.delete(collection, {
+            id: this.id
+        });
+    }
+    static async create(data) {
+        const newModel = new this();
+        const sanitizedData = newModel.sanitizeDBData(data);
+        await newModel._asyncFill(sanitizedData);
+        return newModel;
+    }
+    static loadModels() {
+        return this.allModels || [];
+    }
+    loadModels() {
+        return RWSModel.loadModels();
+    }
+    checkRelEnabled(key) {
+        return RelationUtils_1.RelationUtils.checkRelEnabled(this, key);
+    }
+    static setServices(services) {
+        this.allModels = services.configService.get('db_models');
+        this.services = services;
+    }
+    getDb() {
+        return this.services.dbService;
+    }
+}
+exports.RWSModel = RWSModel;
+RWSModel.services = {};
+RWSModel._collection = null;
+RWSModel._RELATIONS = {};
+RWSModel._BANNED_KEYS = ['_collection'];
+RWSModel.allModels = [];
+RWSModel._CUT_KEYS = [];
+__decorate([
+    (0, decorators_1.TrackType)(String),
+    __metadata("design:type", String)
+], RWSModel.prototype, "id", void 0);

package/dist/models/core/TimeSeriesModel.d.ts

@@ -0,0 +1,7 @@
+import { RWSModel } from './RWSModel';
+export default class TimeSeriesModel<ChildClass> extends RWSModel<TimeSeriesModel<ChildClass>> {
+    value: number;
+    timestamp: Date;
+    params: any;
+    constructor(data?: any);
+}

package/dist/models/core/TimeSeriesModel.js

@@ -0,0 +1,34 @@
+"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 });
+const RWSModel_1 = require("./RWSModel");
+const decorators_1 = require("../../decorators");
+class TimeSeriesModel extends RWSModel_1.RWSModel {
+    constructor(data) {
+        super(data);
+        if (!this.timestamp) {
+            this.timestamp = new Date();
+        }
+    }
+}
+exports.default = TimeSeriesModel;
+__decorate([
+    (0, decorators_1.TrackType)(Number),
+    __metadata("design:type", Number)
+], TimeSeriesModel.prototype, "value", void 0);
+__decorate([
+    (0, decorators_1.TrackType)(Date),
+    __metadata("design:type", Date)
+], TimeSeriesModel.prototype, "timestamp", void 0);
+__decorate([
+    (0, decorators_1.TrackType)(Object),
+    __metadata("design:type", Object)
+], TimeSeriesModel.prototype, "params", void 0);

package/dist/models/index.d.ts

@@ -0,0 +1,8 @@
+import { IModel } from './interfaces/IModel';
+import { IRWSModelServices } from './interfaces/IRWSModelServices';
+import { OpModelType } from './interfaces/OpModelType';
+import { RelationBindType, RelOneMetaType, RelManyMetaType } from './types/RelationTypes';
+import { RWSModel } from './core/RWSModel';
+import TimeSeriesModel from './core/TimeSeriesModel';
+import { TrackType, IMetaOpts } from '../decorators';
+export { IModel, IRWSModelServices, OpModelType, RelationBindType, RelOneMetaType, RelManyMetaType, RWSModel, TimeSeriesModel, TrackType, IMetaOpts };

package/dist/models/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackType = exports.TimeSeriesModel = exports.RWSModel = void 0;
+const RWSModel_1 = require("./core/RWSModel");
+Object.defineProperty(exports, "RWSModel", { enumerable: true, get: function () { return RWSModel_1.RWSModel; } });
+const TimeSeriesModel_1 = __importDefault(require("./core/TimeSeriesModel"));
+exports.TimeSeriesModel = TimeSeriesModel_1.default;
+const decorators_1 = require("../decorators");
+Object.defineProperty(exports, "TrackType", { enumerable: true, get: function () { return decorators_1.TrackType; } });

package/dist/models/interfaces/IModel.d.ts

@@ -0,0 +1,10 @@
+import { IDbConfigHandler } from '../../types/DbConfigHandler';
+import { DBService } from '../../services/DBService';
+export interface IModel {
+    [key: string]: any;
+    id: string | null;
+    save: () => void;
+    getCollection: () => string | null;
+    configService?: IDbConfigHandler;
+    dbService?: DBService;
+}

package/dist/models/interfaces/IModel.js

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

package/dist/models/interfaces/IRWSModelServices.d.ts

@@ -0,0 +1,6 @@
+import { IDbConfigHandler } from '../../types/DbConfigHandler';
+import { DBService } from '../../services/DBService';
+export interface IRWSModelServices {
+    configService?: IDbConfigHandler;
+    dbService?: DBService;
+}

package/dist/models/interfaces/IRWSModelServices.js

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

package/dist/models/interfaces/OpModelType.d.ts

@@ -0,0 +1,32 @@
+import { IRWSModel } from '../../types/IRWSModel';
+import { FindByType, IPaginationParams } from '../../types/FindParams';
+import { IRWSModelServices } from './IRWSModelServices';
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { DBService } from '../../services/DBService';
+type RWSModel<T> = any;
+export interface OpModelType<ChildClass> {
+    new (data?: any | null): ChildClass;
+    services: IRWSModelServices;
+    name: string;
+    _collection: string;
+    _RELATIONS: {
+        [key: string]: boolean;
+    };
+    _CUT_KEYS: string[];
+    allModels: OpModelType<any>[];
+    loadModels: () => OpModelType<any>[];
+    checkForInclusionWithThrow: (className: string) => void;
+    checkForInclusion: (className: string) => boolean;
+    findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams: FindByType): Promise<T | null>;
+    find<T extends RWSModel<T>>(this: OpModelType<T>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
+    findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams: FindByType): Promise<T[]>;
+    paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginateParams?: IPaginationParams, findParams?: FindByType): Promise<T[]>;
+    delete<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, conditions: any): Promise<void>;
+    create<T extends RWSModel<T>>(this: OpModelType<T>, data: T): Promise<T>;
+    getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
+    getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
+    getCollection(): string;
+    getDb(): DBService;
+    setServices(services: IRWSModelServices): void;
+}
+export {};

package/dist/models/interfaces/OpModelType.js

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

package/dist/models/types/RelationTypes.d.ts

@@ -0,0 +1,24 @@
+import { IRWSModel } from '../../types/IRWSModel';
+type OpModelType<T> = any;
+export type RelationBindType = {
+    connect: {
+        id: string;
+    };
+};
+export type RelOneMetaType<T extends IRWSModel> = {
+    [key: string]: {
+        required: boolean;
+        key?: string;
+        model: OpModelType<T>;
+        hydrationField: string;
+        foreignKey: string;
+    };
+};
+export type RelManyMetaType<T extends IRWSModel> = {
+    [key: string]: {
+        key: string;
+        inversionModel: OpModelType<T>;
+        foreignKey: string;
+    };
+};
+export {};

package/dist/models/types/RelationTypes.js

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

package/dist/models/utils/ModelUtils.d.ts

@@ -0,0 +1,10 @@
+import { RWSModel } from "../core/RWSModel";
+export declare class ModelUtils {
+    static getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {
+        annotationType: string;
+        metadata: any;
+    }>>;
+    static checkDbVariable(constructor: any, variable: string): Promise<boolean>;
+    static isSubclass<T, C extends new () => T>(constructor: C, baseClass: new () => T): boolean;
+    static getModelScalarFields(model: RWSModel<any>): string[];
+}

package/dist/models/utils/ModelUtils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelUtils = void 0;
+const FieldsHelper_1 = require("../../helper/FieldsHelper");
+class ModelUtils {
+    static async getModelAnnotations(constructor) {
+        const annotationsData = {};
+        const metadataKeys = Reflect.getMetadataKeys(constructor.prototype);
+        // Process all metadata keys and collect promises
+        const metadataPromises = metadataKeys.map(async (fullKey) => {
+            const [annotationType, propertyKey] = fullKey.split(':');
+            const metadata = Reflect.getMetadata(fullKey, constructor.prototype);
+            if (metadata) {
+                // If this is a relation metadata with a promise
+                if (metadata.promise && (annotationType === 'Relation' || annotationType === 'InverseRelation')) {
+                    const resolvedMetadata = await metadata.promise;
+                    annotationsData[propertyKey] = {
+                        annotationType,
+                        metadata: resolvedMetadata
+                    };
+                }
+                else {
+                    // Handle non-relation metadata as before
+                    const key = metadata.key || propertyKey;
+                    annotationsData[key] = {
+                        annotationType,
+                        metadata
+                    };
+                }
+            }
+        });
+        // Wait for all metadata to be processed
+        await Promise.all(metadataPromises);
+        return annotationsData;
+    }
+    static async checkDbVariable(constructor, variable) {
+        if (variable === 'id') {
+            return true;
+        }
+        const dbAnnotations = await ModelUtils.getModelAnnotations(constructor);
+        const dbProperties = Object.keys(dbAnnotations)
+            .map((key) => { return { ...dbAnnotations[key], key }; })
+            .filter((element) => element.annotationType === 'TrackType')
+            .map((element) => element.key);
+        return dbProperties.includes(variable);
+    }
+    static isSubclass(constructor, baseClass) {
+        return baseClass.prototype.isPrototypeOf(constructor.prototype);
+    }
+    static getModelScalarFields(model) {
+        return FieldsHelper_1.FieldsHelper.getAllClassFields(model)
+            .filter((item) => item.indexOf('TrackType') === 0)
+            .map((item) => item.split(':').at(-1));
+    }
+}
+exports.ModelUtils = ModelUtils;

package/dist/models/utils/PaginationUtils.d.ts

@@ -0,0 +1,5 @@
+import { OpModelType, RWSModel } from '../_model';
+import { FindByType, IPaginationParams } from '../../types/FindParams';
+export declare class PaginationUtils {
+    static paginate<ChildClass extends RWSModel<ChildClass>>(this: OpModelType<ChildClass>, paginationParams?: IPaginationParams, findParams?: FindByType): Promise<ChildClass[]>;
+}

package/dist/models/utils/PaginationUtils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginationUtils = void 0;
+class PaginationUtils {
+    static async paginate(paginationParams = { page: 0, per_page: 50 }, findParams = {}) {
+        var _a, _b, _c, _d, _e;
+        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
+        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
+        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
+        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
+        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const collection = Reflect.get(this, '_collection');
+        this.checkForInclusionWithThrow(this.name);
+        try {
+            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginationParams);
+            if (dbData.length) {
+                const instanced = [];
+                for (const data of dbData) {
+                    const inst = new this();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                }
+                return instanced;
+            }
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
+    }
+}
+exports.PaginationUtils = PaginationUtils;

package/dist/models/utils/RelationUtils.d.ts

@@ -0,0 +1,14 @@
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+import { RWSModel } from '../_model';
+export declare class RelationUtils {
+    static getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
+    static getRelationManyMeta(model: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
+    static bindRelation(relatedModel: RWSModel<any>): {
+        connect: {
+            id: string;
+        };
+    };
+    static hasRelation(model: RWSModel<any>, key: string): boolean;
+    static checkRelEnabled(model: RWSModel<any>, key: string): boolean;
+}