@rws-framework/db 3.7.3 → 3.9.0

package/dist/models/utils/FindUtils.js

@@ -1,88 +1,149 @@
 "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) {
-        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;
+        // 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;
+        });
     }
     static async find(opModel, id, findParams = 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;
+        // 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;
+        });
     }
     static async findBy(opModel, findParams) {
-        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)));
+        // 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;
                 }
-                return instanced;
+                return [];
+            }
+            catch (rwsError) {
+                console.error(rwsError);
+                throw rwsError;
             }
-            return [];
-        }
-        catch (rwsError) {
-            console.error(rwsError);
-            throw rwsError;
-        }
+        });
     }
     static async paginate(opModel, paginateParams, findParams) {
-        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)));
+        // 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;
                 }
-                return instanced;
+                return [];
+            }
+            catch (rwsError) {
+                console.error(rwsError);
+                throw rwsError;
             }
-            return [];
-        }
-        catch (rwsError) {
-            console.error(rwsError);
-            throw rwsError;
-        }
+        });
     }
 }
 exports.FindUtils = FindUtils;

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

@@ -0,0 +1,56 @@
+/**
+ * LoadingContext - Prevents circular references during model loading by tracking
+ * the chain of models currently being loaded per execution context
+ */
+declare global {
+    var __currentExecutionContext: object | undefined;
+}
+export declare class LoadingContext {
+    private static executionContexts;
+    private static defaultMaxDepth;
+    /**
+     * Get or create execution context identifier
+     */
+    private static getExecutionContext;
+    /**
+     * Create a new execution context for an operation
+     */
+    static withNewExecutionContext<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get the loading stack for current execution context
+     */
+    private static getLoadingStackInternal;
+    /**
+     * Check if a model with specific ID is currently being loaded
+     */
+    static isLoading(modelType: string, id: string | number): boolean;
+    /**
+     * Mark a model as currently being loaded
+     */
+    static startLoading(modelType: string, id: string | number): void;
+    /**
+     * Mark a model as finished loading
+     */
+    static finishLoading(modelType: string, id: string | number): void;
+    /**
+     * Get current loading stack for debugging
+     */
+    static getLoadingStack(): string[];
+    /**
+     * Clear the entire loading stack for current context
+     */
+    static clearStack(): void;
+    /**
+     * Set default maximum loading depth
+     */
+    static setDefaultMaxDepth(depth: number): void;
+    /**
+     * Create a unique key for model type and ID
+     */
+    private static createKey;
+    /**
+     * Execute a function with loading context protection
+     * Automatically manages start/finish loading calls
+     */
+    static withLoadingContext<T>(modelType: string, id: string | number, fn: () => Promise<T>): Promise<T>;
+}

package/dist/models/utils/LoadingContext.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * LoadingContext - Prevents circular references during model loading by tracking
+ * the chain of models currently being loaded per execution context
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadingContext = void 0;
+class LoadingContext {
+    static executionContexts = new WeakMap();
+    static defaultMaxDepth = 10;
+    /**
+     * Get or create execution context identifier
+     */
+    static getExecutionContext() {
+        // Use a simple object as execution context identifier
+        // In a real-world scenario, this could be tied to request context
+        if (!globalThis.__currentExecutionContext) {
+            globalThis.__currentExecutionContext = {};
+        }
+        return globalThis.__currentExecutionContext;
+    }
+    /**
+     * Create a new execution context for an operation
+     */
+    static withNewExecutionContext(fn) {
+        const previousContext = globalThis.__currentExecutionContext;
+        try {
+            globalThis.__currentExecutionContext = {};
+            return fn();
+        }
+        finally {
+            globalThis.__currentExecutionContext = previousContext;
+        }
+    }
+    /**
+     * Get the loading stack for current execution context
+     */
+    static getLoadingStackInternal() {
+        const context = this.getExecutionContext();
+        if (!this.executionContexts.has(context)) {
+            this.executionContexts.set(context, new Set());
+        }
+        return this.executionContexts.get(context);
+    }
+    /**
+     * Check if a model with specific ID is currently being loaded
+     */
+    static isLoading(modelType, id) {
+        const key = this.createKey(modelType, id);
+        const loadingStack = this.getLoadingStackInternal();
+        return loadingStack.has(key);
+    }
+    /**
+     * Mark a model as currently being loaded
+     */
+    static startLoading(modelType, id) {
+        const key = this.createKey(modelType, id);
+        const loadingStack = this.getLoadingStackInternal();
+        // Check for maximum depth to prevent infinite chains
+        if (loadingStack.size >= this.defaultMaxDepth) {
+            const stackArray = Array.from(loadingStack);
+            throw new Error(`Maximum loading depth (${this.defaultMaxDepth}) exceeded. ` +
+                `Possible circular reference detected. Loading stack: ${stackArray.join(' -> ')} -> ${key}`);
+        }
+        loadingStack.add(key);
+    }
+    /**
+     * Mark a model as finished loading
+     */
+    static finishLoading(modelType, id) {
+        const key = this.createKey(modelType, id);
+        const loadingStack = this.getLoadingStackInternal();
+        loadingStack.delete(key);
+    }
+    /**
+     * Get current loading stack for debugging
+     */
+    static getLoadingStack() {
+        const loadingStack = this.getLoadingStackInternal();
+        return Array.from(loadingStack);
+    }
+    /**
+     * Clear the entire loading stack for current context
+     */
+    static clearStack() {
+        const loadingStack = this.getLoadingStackInternal();
+        loadingStack.clear();
+    }
+    /**
+     * Set default maximum loading depth
+     */
+    static setDefaultMaxDepth(depth) {
+        this.defaultMaxDepth = depth;
+    }
+    /**
+     * Create a unique key for model type and ID
+     */
+    static createKey(modelType, id) {
+        return `${modelType}:${id}`;
+    }
+    /**
+     * Execute a function with loading context protection
+     * Automatically manages start/finish loading calls
+     */
+    static async withLoadingContext(modelType, id, fn) {
+        if (this.isLoading(modelType, id)) {
+            // If already loading, return null to break the cycle
+            return null;
+        }
+        this.startLoading(modelType, id);
+        try {
+            return await fn();
+        }
+        finally {
+            this.finishLoading(modelType, id);
+        }
+    }
+}
+exports.LoadingContext = LoadingContext;

package/dist/models/utils/LoadingContext.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple test to verify LoadingContext functionality
+ */
+declare function testLoadingContext(): Promise<void>;
+export { testLoadingContext };

package/dist/models/utils/LoadingContext.test.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testLoadingContext = testLoadingContext;
+const LoadingContext_1 = require("./LoadingContext");
+/**
+ * Simple test to verify LoadingContext functionality
+ */
+async function testLoadingContext() {
+    console.log('Testing LoadingContext...');
+    // Test 1: Basic loading detection
+    console.log('Test 1: Basic loading detection');
+    console.log('Is User:1 loading?', LoadingContext_1.LoadingContext.isLoading('User', 1)); // Should be false
+    LoadingContext_1.LoadingContext.startLoading('User', 1);
+    console.log('Is User:1 loading?', LoadingContext_1.LoadingContext.isLoading('User', 1)); // Should be true
+    LoadingContext_1.LoadingContext.finishLoading('User', 1);
+    console.log('Is User:1 loading?', LoadingContext_1.LoadingContext.isLoading('User', 1)); // Should be false
+    // Test 2: Circular reference detection
+    console.log('\nTest 2: Circular reference detection');
+    try {
+        await LoadingContext_1.LoadingContext.withLoadingContext('User', 1, async () => {
+            console.log('Loading User:1...');
+            // Simulate trying to load the same model again (circular reference)
+            const result = await LoadingContext_1.LoadingContext.withLoadingContext('User', 1, async () => {
+                console.log('This should not execute - circular reference detected');
+                return 'should not reach here';
+            });
+            console.log('Circular reference result:', result); // Should be null
+            return 'User loaded successfully';
+        });
+    }
+    catch (error) {
+        console.error('Error in circular reference test:', error);
+    }
+    // Test 3: Maximum depth protection
+    console.log('\nTest 3: Maximum depth protection');
+    LoadingContext_1.LoadingContext.setMaxDepth(3);
+    try {
+        LoadingContext_1.LoadingContext.startLoading('Model1', 1);
+        LoadingContext_1.LoadingContext.startLoading('Model2', 2);
+        LoadingContext_1.LoadingContext.startLoading('Model3', 3);
+        // This should throw an error
+        LoadingContext_1.LoadingContext.startLoading('Model4', 4);
+    }
+    catch (error) {
+        console.log('Expected error caught:', error.message);
+    }
+    finally {
+        LoadingContext_1.LoadingContext.clearStack();
+    }
+    console.log('LoadingContext tests completed!');
+}

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

@@ -0,0 +1,7 @@
+export { FindUtils } from './FindUtils';
+export { HydrateUtils } from './HydrateUtils';
+export { LoadingContext } from './LoadingContext';
+export { ModelUtils } from './ModelUtils';
+export { PaginationUtils } from './PaginationUtils';
+export { RelationUtils } from './RelationUtils';
+export { TimeSeriesUtils } from './TimeSeriesUtils';

package/dist/models/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeSeriesUtils = exports.RelationUtils = exports.PaginationUtils = exports.ModelUtils = exports.LoadingContext = exports.HydrateUtils = exports.FindUtils = void 0;
+var FindUtils_1 = require("./FindUtils");
+Object.defineProperty(exports, "FindUtils", { enumerable: true, get: function () { return FindUtils_1.FindUtils; } });
+var HydrateUtils_1 = require("./HydrateUtils");
+Object.defineProperty(exports, "HydrateUtils", { enumerable: true, get: function () { return HydrateUtils_1.HydrateUtils; } });
+var LoadingContext_1 = require("./LoadingContext");
+Object.defineProperty(exports, "LoadingContext", { enumerable: true, get: function () { return LoadingContext_1.LoadingContext; } });
+var ModelUtils_1 = require("./ModelUtils");
+Object.defineProperty(exports, "ModelUtils", { enumerable: true, get: function () { return ModelUtils_1.ModelUtils; } });
+var PaginationUtils_1 = require("./PaginationUtils");
+Object.defineProperty(exports, "PaginationUtils", { enumerable: true, get: function () { return PaginationUtils_1.PaginationUtils; } });
+var RelationUtils_1 = require("./RelationUtils");
+Object.defineProperty(exports, "RelationUtils", { enumerable: true, get: function () { return RelationUtils_1.RelationUtils; } });
+var TimeSeriesUtils_1 = require("./TimeSeriesUtils");
+Object.defineProperty(exports, "TimeSeriesUtils", { enumerable: true, get: function () { return TimeSeriesUtils_1.TimeSeriesUtils; } });

package/package.json

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

package/src/models/core/RWSModel.ts

@@ -4,15 +4,16 @@ 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 { HydrateUtils } from '../utils/HydrateUtils';
-import { FindUtils } from '../utils/FindUtils';
+import { 
+    RelationUtils, 
+    TimeSeriesUtils, 
+    ModelUtils, 
+    HydrateUtils, 
+    FindUtils, 
+    LoadingContext 
+} from '../utils';
 
 class RWSModel<T> implements IModel {
     static services: IRWSModelServices = {};
@@ -137,9 +138,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();
-            this.setPostLoadExecuted();
+        if(!this.isPostLoadExecuted() && postLoadExecute){       
+              
+            await this.postLoad();            
         }        
 
         return this as any as T;
@@ -182,15 +183,16 @@ class RWSModel<T> implements IModel {
       
         for (const key in (this as any)) { 
             if (await this.hasRelation(key)) {                
-                data[key] = this.bindRelation(key, this[key]);  
+                if (this[key] === null) {
+                    // For null relations, use disconnect or set to null
+                    data[key] = {
+                        disconnect: true
+                    };
+                } else {
+                    data[key] = this.bindRelation(key, this[key]);  
+                }
                 
-                if(data[key] === null){
-                    const relationKey = await this.getRelationKey(key);
-                    if(relationKey){
-                        data[relationKey] = null;
-                        delete data[key];
-                    }
-                }            
+                // Don't try to set the foreign key directly anymore
                 continue;
             }
     
@@ -265,7 +267,8 @@ class RWSModel<T> implements IModel {
         return;
     }
 
-    public async postLoad(): Promise<void> {
+    public async postLoad(): Promise<void> {  
+        this.setPostLoadExecuted();      
         return;
     }
 
@@ -403,7 +406,7 @@ class RWSModel<T> implements IModel {
         return this.services.dbService;
     }
 
-    public async reload(): Promise<RWSModel<T> | null>
+    public async reload(inPostLoad = false): Promise<RWSModel<T> | null>
     {
         const pk = ModelUtils.findPrimaryKeyFields(this.constructor as OpModelType<T>);
         const where: any = {};
@@ -416,7 +419,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 });
+        return await FindUtils.findOneBy(this.constructor as OpModelType<any>, { conditions: where, cancelPostLoad: inPostLoad });
     }
 }
 

package/src/models/interfaces/IModel.ts

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