@rws-framework/db 3.5.0 → 3.6.0

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

@@ -15,7 +15,10 @@ declare class RWSModel<T> implements IModel {
     static _BANNED_KEYS: string[];
     static allModels: OpModelType<any>[];
     static _CUT_KEYS: string[];
+    private postLoadExecuted;
     constructor(data?: any);
+    isPostLoadExecuted(): boolean;
+    setPostLoadExecuted(): void;
     checkForInclusionWithThrow(): void;
     static checkForInclusionWithThrow(this: OpModelType<any>, checkModelType: string): void;
     checkForInclusion(): boolean;
@@ -27,7 +30,7 @@ declare class RWSModel<T> implements IModel {
             id: string | number;
         };
     };
-    _asyncFill(data: any, fullDataMode?: boolean, allowRelations?: boolean): Promise<T>;
+    _asyncFill(data: any, fullDataMode?: boolean, allowRelations?: boolean, postLoadExecute?: boolean): Promise<T>;
     private getModelScalarFields;
     private getRelationOneMeta;
     static getRelationOneMeta(model: any, classFields: string[]): Promise<import("..").RelOneMetaType<import("../..").IRWSModel>>;
@@ -42,10 +45,11 @@ declare class RWSModel<T> implements IModel {
         annotationType: string;
         metadata: any;
     }>>;
-    preUpdate(): void;
-    postUpdate(): void;
-    preCreate(): void;
-    postCreate(): void;
+    preUpdate(): Promise<void>;
+    postLoad(): Promise<void>;
+    postUpdate(): Promise<void>;
+    preCreate(): Promise<void>;
+    postCreate(): Promise<void>;
     static isSubclass<T extends RWSModel<T>, C extends new () => T>(constructor: C, baseClass: new () => T): boolean;
     hasTimeSeries(): boolean;
     static checkTimeSeries(constructor: any): boolean;
@@ -68,6 +72,6 @@ declare class RWSModel<T> implements IModel {
         [k: string]: any;
     }): Promise<number>;
     static getDb(): DBService;
-    reload(): Promise<T | null>;
+    reload(): Promise<RWSModel<T> | null>;
 }
 export { RWSModel };

package/dist/models/core/RWSModel.js

@@ -27,6 +27,7 @@ class RWSModel {
     static _BANNED_KEYS = ['_collection'];
     static allModels = [];
     static _CUT_KEYS = [];
+    postLoadExecuted = false;
     constructor(data = null) {
         if (!this.getCollection()) {
             throw new Error('Model must have a collection defined');
@@ -43,6 +44,12 @@ class RWSModel {
             throw new Error('Time Series not supported in synchronous constructor. Use `await Model.create(data)` static method to instantiate this model.');
         }
     }
+    isPostLoadExecuted() {
+        return this.postLoadExecuted;
+    }
+    setPostLoadExecuted() {
+        this.postLoadExecuted = true;
+    }
     checkForInclusionWithThrow() {
         const constructor = this.constructor;
         if (!constructor.checkForInclusion(constructor.name)) {
@@ -85,7 +92,7 @@ class RWSModel {
     bindRelation(key, relatedModel) {
         return RelationUtils_1.RelationUtils.bindRelation(relatedModel);
     }
-    async _asyncFill(data, fullDataMode = false, allowRelations = true) {
+    async _asyncFill(data, fullDataMode = false, allowRelations = true, postLoadExecute = true) {
         const collections_to_models = {};
         const classFields = FieldsHelper_1.FieldsHelper.getAllClassFields(this.constructor);
         // Get both relation metadata types asynchronously
@@ -102,6 +109,10 @@ class RWSModel {
         }
         // Process regular fields and time series
         await HydrateUtils_1.HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
+        if (!this.isPostLoadExecuted() && postLoadExecute) {
+            await this.postLoad();
+            this.setPostLoadExecuted();
+        }
         return this;
     }
     getModelScalarFields(model) {
@@ -159,34 +170,37 @@ class RWSModel {
         let updatedModelData = data;
         const entryExists = await ModelUtils_1.ModelUtils.entryExists(this);
         if (entryExists) {
-            this.preUpdate();
+            await this.preUpdate();
             const pk = ModelUtils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
             updatedModelData = await this.dbService.update(data, this.getCollection(), pk);
             await this._asyncFill(updatedModelData);
-            this.postUpdate();
+            await this.postUpdate();
         }
         else {
-            this.preCreate();
+            await this.preCreate();
             const isTimeSeries = false; //this instanceof timeSeriesModel;
             updatedModelData = await this.dbService.insert(data, this.getCollection(), isTimeSeries);
             await this._asyncFill(updatedModelData);
-            this.postCreate();
+            await this.postCreate();
         }
         return this;
     }
     static async getModelAnnotations(constructor) {
         return ModelUtils_1.ModelUtils.getModelAnnotations(constructor);
     }
-    preUpdate() {
+    async preUpdate() {
+        return;
+    }
+    async postLoad() {
         return;
     }
-    postUpdate() {
+    async postUpdate() {
         return;
     }
-    preCreate() {
+    async preCreate() {
         return;
     }
-    postCreate() {
+    async postCreate() {
         return;
     }
     static isSubclass(constructor, baseClass) {

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

@@ -1,11 +1,21 @@
 import { IDbConfigHandler } from '../../types/DbConfigHandler';
 import { DBService } from '../../services/DBService';
+import { RWSModel } from '..';
 export interface IModel {
     [key: string]: any;
     id: string | number | null;
-    save: () => void;
-    getDb: () => DBService;
-    getCollection: () => string | null;
     configService?: IDbConfigHandler;
     dbService?: DBService;
+    save: () => Promise<this>;
+    getDb: () => DBService;
+    getCollection: () => string | null;
+    reload: () => Promise<RWSModel<any>>;
+    delete: () => Promise<void>;
+    hasTimeSeries: () => boolean;
+    _asyncFill: (data: any, fullDataMode?: boolean, allowRelations?: boolean) => Promise<any>;
+    preUpdate: () => Promise<void>;
+    postUpdate: () => Promise<void>;
+    preCreate: () => Promise<void>;
+    postCreate: () => Promise<void>;
+    postLoad: () => Promise<void>;
 }

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

@@ -28,7 +28,18 @@ export interface OpModelType<T> {
     create<T extends RWSModel<T>>(this: new () => T, data: any): Promise<T>;
     getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
     getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
-    getCollection(): string;
+    getCollection(): string | null;
     getDb(): DBService;
     setServices(services: IRWSModelServices): void;
+    watchCollection<T extends RWSModel<T>>(this: OpModelType<T>, preRun: () => void): Promise<any>;
+    count(where?: {
+        [k: string]: any;
+    }): Promise<number>;
+    isSubclass<T extends RWSModel<T>, C extends new () => T>(constructor: C, baseClass: new () => T): boolean;
+    getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {
+        annotationType: string;
+        metadata: any;
+    }>>;
+    checkTimeSeries(constructor: any): boolean;
+    checkDbVariable(constructor: any, variable: string): Promise<boolean>;
 }

package/dist/models/utils/FindUtils.js

@@ -13,7 +13,8 @@ class FindUtils {
         const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
         if (dbData) {
             const inst = new opModel();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
+            const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams.cancelPostLoad ? false : true);
+            return loaded;
         }
         return null;
     }
@@ -27,7 +28,8 @@ class FindUtils {
         const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering);
         if (dbData) {
             const inst = new opModel();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
+            const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams.cancelPostLoad ? false : true);
+            return loaded;
         }
         return null;
     }
@@ -46,7 +48,7 @@ class FindUtils {
                 const instanced = [];
                 for (const data of dbData) {
                     const inst = new opModel();
-                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams.cancelPostLoad ? false : true)));
                 }
                 return instanced;
             }
@@ -71,7 +73,7 @@ class FindUtils {
                 const instanced = [];
                 for (const data of dbData) {
                     const inst = new opModel();
-                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)));
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams.cancelPostLoad ? false : true)));
                 }
                 return instanced;
             }

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

@@ -9,5 +9,5 @@ export declare class HydrateUtils {
     }): Promise<void>;
     static hydrateRelations(model: RWSModel<any>, relManyData: RelManyMetaType<IRWSModel>, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {
         [key: string]: any;
-    }): Promise<void>;
+    }, postLoadExecute?: boolean): Promise<void>;
 }

package/dist/models/utils/HydrateUtils.js

@@ -38,7 +38,7 @@ class HydrateUtils {
             }
         }
     }
-    static async hydrateRelations(model, relManyData, relOneData, seriesHydrationfields, fullDataMode, data) {
+    static async hydrateRelations(model, relManyData, relOneData, seriesHydrationfields, fullDataMode, data, postLoadExecute = false) {
         // Handle many-to-many relations
         for (const key in relManyData) {
             if (!fullDataMode && model.constructor._CUT_KEYS.includes(key)) {
@@ -53,7 +53,8 @@ class HydrateUtils {
                         conditions: {
                             [relMeta.foreignKey]: data[pk]
                         },
-                        allowRelations: false
+                        allowRelations: false,
+                        cancelPostLoad: !postLoadExecute
                     });
                 }
                 else {
@@ -61,7 +62,8 @@ class HydrateUtils {
                         conditions: {
                             [relMeta.foreignKey]: data[pk]
                         },
-                        allowRelations: false
+                        allowRelations: false,
+                        cancelPostLoad: !postLoadExecute
                     });
                 }
             }

package/dist/services/DBService.js

@@ -207,7 +207,7 @@ class DBService {
         return this;
     }
     async count(opModel, where = {}) {
-        return await this.getCollectionHandler(opModel._collection).count(where);
+        return await this.getCollectionHandler(opModel._collection).count({ where });
     }
 }
 exports.DBService = DBService;

package/dist/types/FindParams.d.ts

@@ -7,6 +7,7 @@ export type FindByType = {
     allowRelations?: boolean;
     fullData?: boolean;
     pagination?: IPaginationParams;
+    cancelPostLoad?: boolean;
 };
 export interface IPaginationParams {
     page: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/models/core/RWSModel.ts

@@ -28,6 +28,8 @@ class RWSModel<T> implements IModel {
     static allModels: OpModelType<any>[] = [];
     static _CUT_KEYS: string[] = [];
 
+    private postLoadExecuted: boolean = false;
+
     constructor(data: any = null) {    
         if(!this.getCollection()){
             throw new Error('Model must have a collection defined');
@@ -45,7 +47,16 @@ class RWSModel<T> implements IModel {
         }else{
             throw new Error('Time Series not supported in synchronous constructor. Use `await Model.create(data)` static method to instantiate this model.');
         }
-    }    
+    } 
+    
+    isPostLoadExecuted(): boolean
+    {
+        return this.postLoadExecuted;
+    }
+
+    setPostLoadExecuted(){
+        this.postLoadExecuted = true;
+    }
     
     checkForInclusionWithThrow(): void {
         const constructor = this.constructor as OpModelType<any>;
@@ -98,7 +109,7 @@ class RWSModel<T> implements IModel {
         return RelationUtils.bindRelation(relatedModel);
     }
 
-    public async _asyncFill(data: any, fullDataMode = false, allowRelations = true): Promise<T> {
+    public async _asyncFill(data: any, fullDataMode = false, allowRelations = true, postLoadExecute = true): Promise<T> {        
         const collections_to_models: {[key: string]: any} = {};               
         const classFields = FieldsHelper.getAllClassFields(this.constructor);        
     
@@ -120,8 +131,13 @@ class RWSModel<T> implements IModel {
         }
     
         // Process regular fields and time series
-         await HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
+        await HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
     
+        if(!this.isPostLoadExecuted() && postLoadExecute){
+            await this.postLoad();
+            this.setPostLoadExecuted();
+        }        
+
         return this as any as T;
     }   
 
@@ -205,16 +221,16 @@ class RWSModel<T> implements IModel {
         const entryExists = await ModelUtils.entryExists(this);        
 
         if (entryExists) {
-            this.preUpdate();
+            await this.preUpdate();
 
             const pk = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<any>);
 
             updatedModelData = await this.dbService.update(data, this.getCollection(), pk);
 
             await this._asyncFill(updatedModelData);
-            this.postUpdate();
+            await this.postUpdate();
         } else {
-            this.preCreate();      
+            await this.preCreate();      
       
             const isTimeSeries = false;//this instanceof timeSeriesModel;
 
@@ -222,7 +238,7 @@ class RWSModel<T> implements IModel {
 
             await this._asyncFill(updatedModelData);   
 
-            this.postCreate();
+            await this.postCreate();
         }
   
         return this;
@@ -232,19 +248,23 @@ class RWSModel<T> implements IModel {
         return ModelUtils.getModelAnnotations(constructor);
     }
 
-    public preUpdate(): void {
+    public async preUpdate(): Promise<void> {
+        return;
+    }
+
+    public async postLoad(): Promise<void> {
         return;
     }
 
-    public postUpdate(): void {
+    public async postUpdate(): Promise<void> {
         return;
     }
 
-    public preCreate(): void {
+    public async preCreate(): Promise<void> {
         return;
     }
 
-    public postCreate(): void {
+    public async postCreate(): Promise<void> {
         return;
     }
 
@@ -370,9 +390,9 @@ class RWSModel<T> implements IModel {
         return this.services.dbService;
     }
 
-    public async reload(): Promise<T | null>
+    public async reload(): Promise<RWSModel<T> | null>
     {
-        const pk = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<any>);
+        const pk = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<T>);
         const where: any = {};
                     
         if(Array.isArray(pk)){            

package/src/models/interfaces/IModel.ts

@@ -1,12 +1,25 @@
 import { IDbConfigHandler } from '../../types/DbConfigHandler';
 import { DBService } from '../../services/DBService';
+import { RWSModel } from '..';
 
 export interface IModel {
     [key: string]: any;
-    id: string |number | null;
-    save: () => void;
-    getDb: () => DBService;
-    getCollection: () => string | null;
+    id: string | number | null;
     configService?: IDbConfigHandler;
     dbService?: DBService;
+    // Core methods
+    save: () => Promise<this>;
+    getDb: () => DBService;
+    getCollection: () => string | null;
+    reload: () => Promise<RWSModel<any>>;
+    delete: () => Promise<void>;
+    hasTimeSeries: () => boolean;    
+    
+    _asyncFill: (data: any, fullDataMode?: boolean, allowRelations?: boolean) => Promise<any>;
+    // Lifecycle hooks
+    preUpdate: () => Promise<void>;
+    postUpdate: () => Promise<void>;
+    preCreate: () => Promise<void>;
+    postCreate: () => Promise<void>;
+    postLoad: () => Promise<void>;        
 }

package/src/models/interfaces/OpModelType.ts

@@ -3,21 +3,21 @@ import { FindByType, IPaginationParams } from '../../types/FindParams';
 import { IRWSModelServices } from './IRWSModelServices';
 import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
 import { DBService } from '../../services/DBService';
-
-// Reference to the RWSModel class to avoid circular dependency
 import type { RWSModel } from '../core/RWSModel';
 import { ISuperTagData } from '../../decorators/RWSCollection';
 
 export interface OpModelType<T> {
     new(data?: any | null): T;
+    // Static properties
     services: IRWSModelServices;
     name: string;
     _collection: string;
     _NO_ID: boolean;
     _SUPER_TAGS: ISuperTagData[];
-    _RELATIONS: {[key: string]: boolean};
+    _RELATIONS: { [key: string]: boolean };
     _CUT_KEYS: string[];
     allModels: OpModelType<any>[];
+    // Static methods
     loadModels: () => OpModelType<any>[];
     checkForInclusionWithThrow: (className: string) => void;
     checkForInclusion: (className: string) => boolean;
@@ -27,15 +27,15 @@ export interface OpModelType<T> {
     ): Promise<T | null>;
     find<T extends RWSModel<T>>(
         this: OpModelType<T>,
-        id: string | number,        
+        id: string | number,
         findParams?: Omit<FindByType, 'conditions'>
     ): Promise<T | null>;
     findBy<T extends RWSModel<T>>(
-        this: OpModelType<T>,    
+        this: OpModelType<T>,
         findParams?: FindByType
     ): Promise<T[]>;
     paginate<T extends RWSModel<T>>(
-        this: OpModelType<T>,    
+        this: OpModelType<T>,
         paginateParams?: IPaginationParams,
         findParams?: FindByType
     ): Promise<T[]>;
@@ -43,10 +43,33 @@ export interface OpModelType<T> {
         this: OpModelType<T>,
         conditions: any
     ): Promise<void>;
-    create<T extends RWSModel<T>>(this: new () => T, data: any): Promise<T>;
-    getRelationOneMeta(model: any, classFields: string[]): Promise<RelOneMetaType<IRWSModel>>;
-    getRelationManyMeta(model: any, classFields: string[]): Promise<RelManyMetaType<IRWSModel>>;
-    getCollection(): string;
+    create<T extends RWSModel<T>>(
+        this: new () => T,
+        data: any
+    ): Promise<T>;
+    getRelationOneMeta(
+        model: any,
+        classFields: string[]
+    ): Promise<RelOneMetaType<IRWSModel>>;
+    getRelationManyMeta(
+        model: any,
+        classFields: string[]
+    ): Promise<RelManyMetaType<IRWSModel>>;
+    getCollection(): string | null;
     getDb(): DBService;
     setServices(services: IRWSModelServices): void;
+    watchCollection<T extends RWSModel<T>>(
+        this: OpModelType<T>,
+        preRun: () => void
+    ): Promise<any>;
+    count(where?: { [k: string]: any }): Promise<number>;
+    isSubclass<T extends RWSModel<T>, C extends new () => T>(
+        constructor: C,
+        baseClass: new () => T
+    ): boolean;
+    getModelAnnotations<T extends unknown>(
+        constructor: new () => T
+    ): Promise<Record<string, { annotationType: string; metadata: any }>>;
+    checkTimeSeries(constructor: any): boolean;
+    checkDbVariable(constructor: any, variable: string): Promise<boolean>;
 }

package/src/models/utils/FindUtils.ts

@@ -27,7 +27,8 @@ export class FindUtils {
 
         if (dbData) {
             const inst: T = new (opModel as { new(): T })();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
+            const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams.cancelPostLoad ? false : true);        
+            return loaded as T;
         }
 
         return null;
@@ -50,7 +51,8 @@ export class FindUtils {
 
         if (dbData) {
             const inst: T = new (opModel as { new(): T })();
-            return await inst._asyncFill(dbData, fullData, allowRelations);
+            const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams.cancelPostLoad ? false : true);
+            return loaded as T;
         }
 
         return null;
@@ -78,7 +80,7 @@ export class FindUtils {
                 for (const data of dbData) {
                     const inst: T = new (opModel as { new(): T })();
 
-                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)) as T);
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams.cancelPostLoad ? false : true)) as T);
                 }
 
                 return instanced;
@@ -112,7 +114,7 @@ export class FindUtils {
 
                 for (const data of dbData) {
                     const inst: T = new (opModel as { new(): T })();
-                    instanced.push((await inst._asyncFill(data, fullData, allowRelations)) as T);
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams.cancelPostLoad ? false : true)) as T);
                 }
 
                 return instanced;

package/src/models/utils/HydrateUtils.ts

@@ -8,119 +8,120 @@ import { ModelUtils } from "./ModelUtils";
 import chalk from 'chalk';
 
 export class HydrateUtils {
-    static async hydrateDataFields(model: RWSModel<any>, collections_to_models: {[key: string]: any}, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {[key: string] : any}){
+    static async hydrateDataFields(model: RWSModel<any>, collections_to_models: { [key: string]: any }, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: { [key: string]: any }) {
         const timeSeriesIds = TimeSeriesUtils.getTimeSeriesModelFields(model);
-        for (const key in data) {         
-                    if (data.hasOwnProperty(key)) {                   
-                        if(!fullDataMode && ((model).constructor as OpModelType<any>)._CUT_KEYS.includes(key)){
-                            continue;
-                        }
-        
-                        if (Object.keys(relOneData).includes(key)) {               
-                            continue;
-                        }                
-            
-                        if (seriesHydrationfields.includes(key)) {
-                            continue;
-                        }                   
-                      
-            
-                        const timeSeriesMetaData = timeSeriesIds[key];  
-                  
-                        if (timeSeriesMetaData) {
-                            model[key] = data[key];
-                            const seriesModel = collections_to_models[timeSeriesMetaData.collection];
-                    
-                            const dataModels = await seriesModel.findBy({
-                                id: { in: data[key] }
-                            });                        
-            
-                            seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
-                    
-                            model[timeSeriesMetaData.hydrationField] = dataModels;
-                        } else {
-                            model[key] = data[key];            
-                        }        
-                    }       
-                }    
-     }
-
-     static async hydrateRelations(model: RWSModel<any>, relManyData: RelManyMetaType<IRWSModel>, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {[key: string] : any})
-         {
-             // Handle many-to-many relations
-             for (const key in relManyData) { 
-                 if(!fullDataMode && (model as any).constructor._CUT_KEYS.includes(key)){
-                     continue;
-                 }
-     
-                 const relMeta = relManyData[key];  
-         
-                 const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
-
-                       
-
-                 if (relationEnabled) {         
-                    const pk = ModelUtils.findPrimaryKeyFields(model.constructor as OpModelType<any>) as string;
-                    
-                    if(relMeta.singular){
-                        model[relMeta.key] = await relMeta.inversionModel.findOneBy({
-                            conditions: {
-                                [relMeta.foreignKey]: data[pk]
-                            },
-                            allowRelations: false
-                       });
-                    } else {
-                        model[relMeta.key] = await relMeta.inversionModel.findBy({
-                            conditions: {
-                                [relMeta.foreignKey]: data[pk]
-                            },
-                            allowRelations: false
-                       });
-                    }                              
-                 }                                
-             }
-             
-             // Handle one-to-one relations
-             for (const key in relOneData) {      
-                 if(!fullDataMode && ((model as any).constructor as OpModelType<any>)._CUT_KEYS.includes(key)){
-                     continue;
-                 }
-     
-                 const relMeta = relOneData[key];          
-                 const relationEnabled = !RelationUtils.checkRelDisabled(model, 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]) {    
-                    const pk = ModelUtils.findPrimaryKeyFields(relMeta.model);
-
-                    const where: any = {};
-                    
-                    if(Array.isArray(pk)){
-                        console.log(chalk.yellowBright(`Hydration field "${relMeta.hydrationField}" on model "${model.constructor.name}" leads to compound key. Ignoring.`));
-                        continue;
-                    }else{
-                        where[pk as string] = data[relMeta.hydrationField]
-                    }            
-                                    
-                    model[relMeta.key] = await relMeta.model.findOneBy({conditions: where}, { allowRelations: false });    
-                 }                                
-                 else if(relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]){                    
-                     const newRelModel: RWSModel<any> = await relMeta.model.create(data[relMeta.key]);                    
-                     model[relMeta.key] = await newRelModel.save();
-                 }
-     
-                 const cutKeys = ((model.constructor as OpModelType<any>)._CUT_KEYS as string[]);
-     
-                 const trackedField = Object.keys((await ModelUtils.getModelAnnotations(model.constructor as OpModelType<any>))).includes(relMeta.hydrationField);
-                 
-                 if(!cutKeys.includes(relMeta.hydrationField) && !trackedField){
-                     cutKeys.push(relMeta.hydrationField)
-                 }
-     
-                 // seriesHydrationfields.push(relMeta.hydrationField);
-             }
-         }
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                if (!fullDataMode && ((model).constructor as OpModelType<any>)._CUT_KEYS.includes(key)) {
+                    continue;
+                }
+
+                if (Object.keys(relOneData).includes(key)) {
+                    continue;
+                }
+
+                if (seriesHydrationfields.includes(key)) {
+                    continue;
+                }
+
+
+                const timeSeriesMetaData = timeSeriesIds[key];
+
+                if (timeSeriesMetaData) {
+                    model[key] = data[key];
+                    const seriesModel = collections_to_models[timeSeriesMetaData.collection];
+
+                    const dataModels = await seriesModel.findBy({
+                        id: { in: data[key] }
+                    });
+
+                    seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
+
+                    model[timeSeriesMetaData.hydrationField] = dataModels;
+                } else {
+                    model[key] = data[key];
+                }
+            }
+        }       
+    }
+
+    static async hydrateRelations(model: RWSModel<any>, relManyData: RelManyMetaType<IRWSModel>, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: { [key: string]: any }, postLoadExecute = false) {
+        // Handle many-to-many relations
+        for (const key in relManyData) {
+            if (!fullDataMode && (model as any).constructor._CUT_KEYS.includes(key)) {
+                continue;
+            }
+
+            const relMeta = relManyData[key];
+
+            const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
+
+
+
+            if (relationEnabled) {
+                const pk = ModelUtils.findPrimaryKeyFields(model.constructor as OpModelType<any>) as string;
+
+                if (relMeta.singular) {
+                    model[relMeta.key] = await relMeta.inversionModel.findOneBy({
+                        conditions: {
+                            [relMeta.foreignKey]: data[pk]
+                        },
+                        allowRelations: false,
+                        cancelPostLoad: !postLoadExecute
+                    });
+                } else {
+                    model[relMeta.key] = await relMeta.inversionModel.findBy({
+                        conditions: {
+                            [relMeta.foreignKey]: data[pk]
+                        },
+                        allowRelations: false,
+                        cancelPostLoad: !postLoadExecute
+                    });
+                }
+            }
+        }
+
+        // Handle one-to-one relations
+        for (const key in relOneData) {
+            if (!fullDataMode && ((model as any).constructor as OpModelType<any>)._CUT_KEYS.includes(key)) {
+                continue;
+            }
+
+            const relMeta = relOneData[key];
+            const relationEnabled = !RelationUtils.checkRelDisabled(model, 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]) {
+                const pk = ModelUtils.findPrimaryKeyFields(relMeta.model);
+
+                const where: any = {};
+
+                if (Array.isArray(pk)) {
+                    console.log(chalk.yellowBright(`Hydration field "${relMeta.hydrationField}" on model "${model.constructor.name}" leads to compound key. Ignoring.`));
+                    continue;
+                } else {
+                    where[pk as string] = data[relMeta.hydrationField]
+                }
+
+                model[relMeta.key] = await relMeta.model.findOneBy({ conditions: where }, { allowRelations: false });
+            }
+            else if (relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]) {
+                const newRelModel: RWSModel<any> = await relMeta.model.create(data[relMeta.key]);
+                model[relMeta.key] = await newRelModel.save();
+            }
+
+            const cutKeys = ((model.constructor as OpModelType<any>)._CUT_KEYS as string[]);
+
+            const trackedField = Object.keys((await ModelUtils.getModelAnnotations(model.constructor as OpModelType<any>))).includes(relMeta.hydrationField);
+
+            if (!cutKeys.includes(relMeta.hydrationField) && !trackedField) {
+                cutKeys.push(relMeta.hydrationField)
+            }
+
+            // seriesHydrationfields.push(relMeta.hydrationField);
+        }
+    }
 }

package/src/services/DBService.ts

@@ -290,7 +290,7 @@ class DBService {
     }
 
     public async count<T = any>(opModel: OpModelType<T>, where: {[k: string]: any} = {}): Promise<number>{
-        return await this.getCollectionHandler(opModel._collection).count(where);
+        return await this.getCollectionHandler(opModel._collection).count({where});
     }
 }
 

package/src/types/FindParams.ts

@@ -5,6 +5,7 @@ export type FindByType = {
     allowRelations?: boolean
     fullData?: boolean
     pagination?: IPaginationParams
+    cancelPostLoad?: boolean
 }
 
 export interface IPaginationParams {