@rws-framework/db 3.9.0 → 3.9.3

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

@@ -73,6 +73,6 @@ declare class RWSModel<T> implements IModel {
         [k: string]: any;
     }): Promise<number>;
     static getDb(): DBService;
-    reload(inPostLoad?: boolean): Promise<RWSModel<T> | null>;
+    reload(): Promise<RWSModel<T> | null>;
 }
 export { RWSModel };

package/dist/models/core/RWSModel.js

@@ -12,7 +12,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RWSModel = void 0;
 const decorators_1 = require("../../decorators");
 const FieldsHelper_1 = require("../../helper/FieldsHelper");
-const utils_1 = require("../utils");
+const RelationUtils_1 = require("../utils/RelationUtils");
+const TimeSeriesUtils_1 = require("../utils/TimeSeriesUtils");
+const ModelUtils_1 = require("../utils/ModelUtils");
+const HydrateUtils_1 = require("../utils/HydrateUtils");
+const FindUtils_1 = require("../utils/FindUtils");
 class RWSModel {
     static services = {};
     id;
@@ -83,13 +87,13 @@ class RWSModel {
         return this;
     }
     async hasRelation(key) {
-        return utils_1.RelationUtils.hasRelation(this.constructor, key);
+        return RelationUtils_1.RelationUtils.hasRelation(this.constructor, key);
     }
     async getRelationKey(key) {
-        return utils_1.RelationUtils.getRelationKey(this.constructor, key);
+        return RelationUtils_1.RelationUtils.getRelationKey(this.constructor, key);
     }
     bindRelation(key, relatedModel) {
-        return utils_1.RelationUtils.bindRelation(relatedModel);
+        return RelationUtils_1.RelationUtils.bindRelation(relatedModel);
     }
     async _asyncFill(data, fullDataMode = false, allowRelations = true, postLoadExecute = true) {
         const collections_to_models = {};
@@ -104,36 +108,37 @@ class RWSModel {
         });
         const seriesHydrationfields = [];
         if (allowRelations) {
-            await utils_1.HydrateUtils.hydrateRelations(this, relManyData, relOneData, seriesHydrationfields, fullDataMode, data);
+            await HydrateUtils_1.HydrateUtils.hydrateRelations(this, relManyData, relOneData, seriesHydrationfields, fullDataMode, data);
         }
         // Process regular fields and time series
-        await utils_1.HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
+        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) {
-        return utils_1.ModelUtils.getModelScalarFields(model);
+        return ModelUtils_1.ModelUtils.getModelScalarFields(model);
     }
     async getRelationOneMeta(classFields) {
-        return utils_1.RelationUtils.getRelationOneMeta(this, classFields);
+        return RelationUtils_1.RelationUtils.getRelationOneMeta(this, classFields);
     }
     static async getRelationOneMeta(model, classFields) {
-        return utils_1.RelationUtils.getRelationOneMeta(model, classFields);
+        return RelationUtils_1.RelationUtils.getRelationOneMeta(model, classFields);
     }
     async getRelationManyMeta(classFields) {
-        return utils_1.RelationUtils.getRelationManyMeta(this, classFields);
+        return RelationUtils_1.RelationUtils.getRelationManyMeta(this, classFields);
     }
     static async getRelationManyMeta(model, classFields) {
-        return utils_1.RelationUtils.getRelationManyMeta(model, classFields);
+        return RelationUtils_1.RelationUtils.getRelationManyMeta(model, classFields);
     }
     static async paginate(paginateParams, findParams) {
-        return await utils_1.FindUtils.paginate(this, paginateParams, findParams);
+        return await FindUtils_1.FindUtils.paginate(this, paginateParams, findParams);
     }
     async toMongo() {
         const data = {};
-        const timeSeriesIds = utils_1.TimeSeriesUtils.getTimeSeriesModelFields(this);
+        const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(this);
         const timeSeriesHydrationFields = [];
         for (const key in this) {
             if (await this.hasRelation(key)) {
@@ -175,10 +180,10 @@ class RWSModel {
     async save() {
         const data = await this.toMongo();
         let updatedModelData = data;
-        const entryExists = await utils_1.ModelUtils.entryExists(this);
+        const entryExists = await ModelUtils_1.ModelUtils.entryExists(this);
         if (entryExists) {
             await this.preUpdate();
-            const pk = utils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
+            const pk = ModelUtils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
             updatedModelData = await this.dbService.update(data, this.getCollection(), pk);
             await this._asyncFill(updatedModelData);
             await this.postUpdate();
@@ -193,13 +198,12 @@ class RWSModel {
         return this;
     }
     static async getModelAnnotations(constructor) {
-        return utils_1.ModelUtils.getModelAnnotations(constructor);
+        return ModelUtils_1.ModelUtils.getModelAnnotations(constructor);
     }
     async preUpdate() {
         return;
     }
     async postLoad() {
-        this.setPostLoadExecuted();
         return;
     }
     async postUpdate() {
@@ -212,19 +216,19 @@ class RWSModel {
         return;
     }
     static isSubclass(constructor, baseClass) {
-        return utils_1.ModelUtils.isSubclass(constructor, baseClass);
+        return ModelUtils_1.ModelUtils.isSubclass(constructor, baseClass);
     }
     hasTimeSeries() {
-        return utils_1.TimeSeriesUtils.checkTimeSeries(this.constructor);
+        return TimeSeriesUtils_1.TimeSeriesUtils.checkTimeSeries(this.constructor);
     }
     static checkTimeSeries(constructor) {
-        return utils_1.TimeSeriesUtils.checkTimeSeries(constructor);
+        return TimeSeriesUtils_1.TimeSeriesUtils.checkTimeSeries(constructor);
     }
     async isDbVariable(variable) {
-        return utils_1.ModelUtils.checkDbVariable(this.constructor, variable);
+        return ModelUtils_1.ModelUtils.checkDbVariable(this.constructor, variable);
     }
     static async checkDbVariable(constructor, variable) {
-        return utils_1.ModelUtils.checkDbVariable(constructor, variable);
+        return ModelUtils_1.ModelUtils.checkDbVariable(constructor, variable);
     }
     sanitizeDBData(data) {
         const dataKeys = Object.keys(data);
@@ -242,13 +246,13 @@ class RWSModel {
         return await this.services.dbService.watchCollection(collection, preRun);
     }
     static async findOneBy(findParams) {
-        return await utils_1.FindUtils.findOneBy(this, findParams);
+        return await FindUtils_1.FindUtils.findOneBy(this, findParams);
     }
     static async find(id, findParams = null) {
-        return await utils_1.FindUtils.find(this, id, findParams);
+        return await FindUtils_1.FindUtils.find(this, id, findParams);
     }
     static async findBy(findParams) {
-        return await utils_1.FindUtils.findBy(this, findParams);
+        return await FindUtils_1.FindUtils.findBy(this, findParams);
     }
     static async delete(conditions) {
         const collection = Reflect.get(this, '_collection');
@@ -275,7 +279,7 @@ class RWSModel {
         return RWSModel.loadModels();
     }
     checkRelDisabled(key) {
-        return utils_1.RelationUtils.checkRelDisabled(this, key);
+        return RelationUtils_1.RelationUtils.checkRelDisabled(this, key);
     }
     static setServices(services) {
         this.allModels = services.configService.get('db_models');
@@ -290,8 +294,8 @@ class RWSModel {
     static getDb() {
         return this.services.dbService;
     }
-    async reload(inPostLoad = false) {
-        const pk = utils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
+    async reload() {
+        const pk = ModelUtils_1.ModelUtils.findPrimaryKeyFields(this.constructor);
         const where = {};
         if (Array.isArray(pk)) {
             for (const pkElem of pk) {
@@ -301,7 +305,7 @@ class RWSModel {
         else {
             where[pk] = this[pk];
         }
-        return await utils_1.FindUtils.findOneBy(this.constructor, { conditions: where, cancelPostLoad: inPostLoad });
+        return await FindUtils_1.FindUtils.findOneBy(this.constructor, { conditions: where });
     }
 }
 exports.RWSModel = RWSModel;

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

@@ -9,7 +9,7 @@ export interface IModel {
     save: () => Promise<this>;
     getDb: () => DBService;
     getCollection: () => string | null;
-    reload: (inPostLoad: boolean) => Promise<RWSModel<any>>;
+    reload: () => Promise<RWSModel<any>>;
     delete: () => Promise<void>;
     hasTimeSeries: () => boolean;
     _asyncFill: (data: any, fullDataMode?: boolean, allowRelations?: boolean) => Promise<any>;

package/dist/models/utils/FindUtils.js

@@ -1,149 +1,88 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FindUtils = void 0;
-const LoadingContext_1 = require("./LoadingContext");
-const chalk_1 = __importDefault(require("chalk"));
-function circularReferenceWarning(modelType, id) {
-    console.warn(chalk_1.default.yellow(`Circular reference detected: ${modelType}:${id} is already being loaded. Breaking cycle.`));
-}
 class FindUtils {
     static async findOneBy(opModel, findParams) {
-        // Wrap in new execution context to ensure clean loading stack per operation
-        return LoadingContext_1.LoadingContext.withNewExecutionContext(async () => {
-            const conditions = findParams?.conditions ?? {};
-            const ordering = findParams?.ordering ?? null;
-            const fields = findParams?.fields ?? null;
-            const allowRelations = findParams?.allowRelations ?? true;
-            const fullData = findParams?.fullData ?? false;
-            opModel.checkForInclusionWithThrow('');
-            const collection = Reflect.get(opModel, '_collection');
-            const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
-            if (dbData) {
-                const modelType = opModel.name;
-                const id = dbData.id;
-                // Check if this model is already being loaded to prevent circular references
-                if (LoadingContext_1.LoadingContext.isLoading(modelType, id)) {
-                    circularReferenceWarning(modelType, id);
-                    return null;
-                }
-                return await LoadingContext_1.LoadingContext.withLoadingContext(modelType, id, async () => {
-                    const inst = new opModel();
-                    const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
-                    return loaded;
-                });
-            }
-            return null;
-        });
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+        opModel.checkForInclusionWithThrow('');
+        const collection = Reflect.get(opModel, '_collection');
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
+        if (dbData) {
+            const inst = new opModel();
+            const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
+            return loaded;
+        }
+        return null;
     }
     static async find(opModel, id, findParams = null) {
-        // Wrap in new execution context to ensure clean loading stack per operation
-        return LoadingContext_1.LoadingContext.withNewExecutionContext(async () => {
-            const ordering = findParams?.ordering ?? null;
-            const fields = findParams?.fields ?? null;
-            const allowRelations = findParams?.allowRelations ?? true;
-            const fullData = findParams?.fullData ?? false;
-            const collection = Reflect.get(opModel, '_collection');
-            opModel.checkForInclusionWithThrow(opModel.name);
-            const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering);
-            if (dbData) {
-                const modelType = opModel.name;
-                // Check if this model is already being loaded to prevent circular references
-                if (LoadingContext_1.LoadingContext.isLoading(modelType, id)) {
-                    circularReferenceWarning(modelType, id);
-                    return null;
-                }
-                return await LoadingContext_1.LoadingContext.withLoadingContext(modelType, id, async () => {
-                    const inst = new opModel();
-                    const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
-                    return loaded;
-                });
-            }
-            return null;
-        });
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+        const collection = Reflect.get(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering);
+        if (dbData) {
+            const inst = new opModel();
+            const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
+            return loaded;
+        }
+        return null;
     }
     static async findBy(opModel, findParams) {
-        // Wrap in new execution context to ensure clean loading stack per operation
-        return LoadingContext_1.LoadingContext.withNewExecutionContext(async () => {
-            const conditions = findParams?.conditions ?? {};
-            const ordering = findParams?.ordering ?? null;
-            const fields = findParams?.fields ?? null;
-            const allowRelations = findParams?.allowRelations ?? true;
-            const fullData = findParams?.fullData ?? false;
-            const collection = Reflect.get(opModel, '_collection');
-            opModel.checkForInclusionWithThrow(opModel.name);
-            try {
-                const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
-                const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
-                if (dbData.length) {
-                    const instanced = [];
-                    for (const data of dbData) {
-                        const modelType = opModel.name;
-                        const id = data.id;
-                        // Check if this model is already being loaded to prevent circular references
-                        if (LoadingContext_1.LoadingContext.isLoading(modelType, id)) {
-                            circularReferenceWarning(modelType, id);
-                            continue;
-                        }
-                        const loaded = await LoadingContext_1.LoadingContext.withLoadingContext(modelType, id, async () => {
-                            const inst = new opModel();
-                            return await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
-                        });
-                        if (loaded) {
-                            instanced.push(loaded);
-                        }
-                    }
-                    return instanced;
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+        const collection = Reflect.get(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            if (dbData.length) {
+                const instanced = [];
+                for (const data of dbData) {
+                    const inst = new opModel();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true)));
                 }
-                return [];
-            }
-            catch (rwsError) {
-                console.error(rwsError);
-                throw rwsError;
+                return instanced;
             }
-        });
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
     }
     static async paginate(opModel, paginateParams, findParams) {
-        // Wrap in new execution context to ensure clean loading stack per operation
-        return LoadingContext_1.LoadingContext.withNewExecutionContext(async () => {
-            const conditions = findParams?.conditions ?? {};
-            const ordering = findParams?.ordering ?? null;
-            const fields = findParams?.fields ?? null;
-            const allowRelations = findParams?.allowRelations ?? true;
-            const fullData = findParams?.fullData ?? false;
-            const collection = Reflect.get(opModel, '_collection');
-            opModel.checkForInclusionWithThrow(opModel.name);
-            try {
-                const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
-                if (dbData.length) {
-                    const instanced = [];
-                    for (const data of dbData) {
-                        const modelType = opModel.name;
-                        const id = data.id;
-                        // Check if this model is already being loaded to prevent circular references
-                        if (LoadingContext_1.LoadingContext.isLoading(modelType, id)) {
-                            circularReferenceWarning(modelType, id);
-                            continue;
-                        }
-                        const loaded = await LoadingContext_1.LoadingContext.withLoadingContext(modelType, id, async () => {
-                            const inst = new opModel();
-                            return await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
-                        });
-                        if (loaded) {
-                            instanced.push(loaded);
-                        }
-                    }
-                    return instanced;
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
+        const collection = Reflect.get(opModel, '_collection');
+        opModel.checkForInclusionWithThrow(opModel.name);
+        try {
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            if (dbData.length) {
+                const instanced = [];
+                for (const data of dbData) {
+                    const inst = new opModel();
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true)));
                 }
-                return [];
-            }
-            catch (rwsError) {
-                console.error(rwsError);
-                throw rwsError;
+                return instanced;
             }
-        });
+            return [];
+        }
+        catch (rwsError) {
+            console.error(rwsError);
+            throw rwsError;
+        }
     }
 }
 exports.FindUtils = FindUtils;

package/package.json

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

package/src/models/core/RWSModel.ts

@@ -4,16 +4,15 @@ import { OpModelType } from '../interfaces/OpModelType';
 import { TrackType } from '../../decorators';
 import { FieldsHelper } from '../../helper/FieldsHelper';
 import { FindByType, IPaginationParams } from '../../types/FindParams';
+import { RelationUtils } from '../utils/RelationUtils';
+
+import { TimeSeriesUtils } from '../utils/TimeSeriesUtils';
+import { ModelUtils } from '../utils/ModelUtils';
+// import timeSeriesModel from './TimeSeriesModel';      
 import { DBService } from '../../services/DBService';
 import { ISuperTagData } from '../../decorators/RWSCollection';
-import { 
-    RelationUtils, 
-    TimeSeriesUtils, 
-    ModelUtils, 
-    HydrateUtils, 
-    FindUtils, 
-    LoadingContext 
-} from '../utils';
+import { HydrateUtils } from '../utils/HydrateUtils';
+import { FindUtils } from '../utils/FindUtils';
 
 class RWSModel<T> implements IModel {
     static services: IRWSModelServices = {};
@@ -138,9 +137,9 @@ class RWSModel<T> implements IModel {
         // Process regular fields and time series
         await HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
     
-        if(!this.isPostLoadExecuted() && postLoadExecute){       
-              
-            await this.postLoad();            
+        if(!this.isPostLoadExecuted() && postLoadExecute){            
+            await this.postLoad();
+            this.setPostLoadExecuted();
         }        
 
         return this as any as T;
@@ -267,8 +266,7 @@ class RWSModel<T> implements IModel {
         return;
     }
 
-    public async postLoad(): Promise<void> {  
-        this.setPostLoadExecuted();      
+    public async postLoad(): Promise<void> {
         return;
     }
 
@@ -406,7 +404,7 @@ class RWSModel<T> implements IModel {
         return this.services.dbService;
     }
 
-    public async reload(inPostLoad = false): Promise<RWSModel<T> | null>
+    public async reload(): Promise<RWSModel<T> | null>
     {
         const pk = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<T>);
         const where: any = {};
@@ -419,7 +417,7 @@ class RWSModel<T> implements IModel {
             where[pk as string] = this[pk as string]
         }         
         
-        return await FindUtils.findOneBy(this.constructor as OpModelType<any>, { conditions: where, cancelPostLoad: inPostLoad });
+        return await FindUtils.findOneBy(this.constructor as OpModelType<any>, { conditions: where });
     }
 }
 

package/src/models/interfaces/IModel.ts

@@ -11,7 +11,7 @@ export interface IModel {
     save: () => Promise<this>;
     getDb: () => DBService;
     getCollection: () => string | null;
-    reload: (inPostLoad: boolean) => Promise<RWSModel<any>>;
+    reload: () => Promise<RWSModel<any>>;
     delete: () => Promise<void>;
     hasTimeSeries: () => boolean;