@rws-framework/db 3.8.0 → 3.9.0

package/src/models/utils/FindUtils.ts

@@ -6,32 +6,50 @@ import { RelationUtils } from "./RelationUtils";
 import { OpModelType } from "..";
 import { ModelUtils } from "./ModelUtils";
 import { FindByType, IPaginationParams } from "../../types/FindParams";
+import { LoadingContext } from "./LoadingContext";
+import chalk from 'chalk';
+
+function circularReferenceWarning(modelType: string, id: string | number): void {
+    console.warn(chalk.yellow(`Circular reference detected: ${modelType}:${id} is already being loaded. Breaking cycle.`));
+}
 
 export class FindUtils {
     public static async findOneBy<T extends RWSModel<T>>(
         opModel: OpModelType<T>,
         findParams?: FindByType
     ): Promise<T | 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);
-
+        // Wrap in new execution context to ensure clean loading stack per operation
+        return 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.isLoading(modelType, id)) {
+                    circularReferenceWarning(modelType, id);
+                    return null;
+                }
 
-        if (dbData) {
-            const inst: T = new (opModel as { new(): T })();
-            const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);        
-            return loaded as T;
-        }
+                return await LoadingContext.withLoadingContext(modelType, id, async () => {
+                    const inst: T = new (opModel as { new(): T })();
+                    const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);        
+                    return loaded as T;
+                });
+            }
 
-        return null;
+            return null;
+        });
     }
 
     public static async find<T extends RWSModel<T>>(
@@ -39,59 +57,89 @@ export class FindUtils {
         id: string | number,
         findParams: Omit<FindByType, 'conditions'> = null
     ): Promise<T | 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);
+        // Wrap in new execution context to ensure clean loading stack per operation
+        return 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.isLoading(modelType, id)) {
+                    circularReferenceWarning(modelType, id);
+                    return null;
+                }
 
-        if (dbData) {
-            const inst: T = new (opModel as { new(): T })();
-            const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
-            return loaded as T;
-        }
+                return await LoadingContext.withLoadingContext(modelType, id, async () => {
+                    const inst: T = new (opModel as { new(): T })();
+                    const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
+                    return loaded as T;
+                });
+            }
 
-        return null;
+            return null;
+        });
     }
 
     public static async findBy<T extends RWSModel<T>>(
         opModel: OpModelType<T>,
         findParams?: FindByType
     ): Promise<T[]> {
-        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: T[] = [];
-
-                for (const data of dbData) {
-                    const inst: T = new (opModel as { new(): T })();
-
-                    instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true)) as T);
+        // Wrap in new execution context to ensure clean loading stack per operation
+        return 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: T[] = [];
+
+                    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.isLoading(modelType, id)) {
+                            circularReferenceWarning(modelType, id);
+                            continue;
+                        }
+
+                        const loaded = await LoadingContext.withLoadingContext(modelType, id, async () => {
+                            const inst: T = new (opModel as { new(): T })();
+                            return await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true) as T;
+                        });
+
+                        if (loaded) {
+                            instanced.push(loaded);
+                        }
+                    }
+
+                    return instanced;
                 }
 
-                return instanced;
-            }
+                return [];
+            } catch (rwsError: Error | any) {
+                console.error(rwsError);
 
-            return [];
-        } catch (rwsError: Error | any) {
-            console.error(rwsError);
-
-            throw rwsError;
-        }
+                throw rwsError;
+            }
+        });
     }
 
     public static async paginate<T extends RWSModel<T>>(
@@ -99,32 +147,50 @@ export class FindUtils {
         paginateParams: IPaginationParams,
         findParams?: FindByType
     ): Promise<T[]> {
-        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: T[] = [];
-
-                for (const data of dbData) {
-                    const inst: T = new (opModel as { new(): T })();                    
-                    instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true)) as T);
+        // Wrap in new execution context to ensure clean loading stack per operation
+        return 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: T[] = [];
+
+                    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.isLoading(modelType, id)) {
+                            circularReferenceWarning(modelType, id);
+                            continue;
+                        }
+
+                        const loaded = await LoadingContext.withLoadingContext(modelType, id, async () => {
+                            const inst: T = new (opModel as { new(): T })();
+                            return await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true) as T;
+                        });
+
+                        if (loaded) {
+                            instanced.push(loaded);
+                        }
+                    }
+
+                    return instanced;
                 }
 
-                return instanced;
-            }
+                return [];
+            } catch (rwsError: Error | any) {
+                console.error(rwsError);
 
-            return [];
-        } catch (rwsError: Error | any) {
-            console.error(rwsError);
-
-            throw rwsError;
-        }
+                throw rwsError;
+            }
+        });
     }
 }

package/src/models/utils/LoadingContext.ts

@@ -0,0 +1,140 @@
+/**
+ * LoadingContext - Prevents circular references during model loading by tracking
+ * the chain of models currently being loaded per execution context
+ */
+
+// Extend the global object type to include our execution context
+declare global {
+    var __currentExecutionContext: object | undefined;
+}
+
+export class LoadingContext {
+    private static executionContexts = new WeakMap<object, Set<string>>();
+    private static defaultMaxDepth: number = 10;
+
+    /**
+     * Get or create execution context identifier
+     */
+    private static getExecutionContext(): object {
+        // 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<T>(fn: () => Promise<T>): Promise<T> {
+        const previousContext = globalThis.__currentExecutionContext;
+        
+        try {
+            globalThis.__currentExecutionContext = {};
+            return fn();
+        } finally {
+            globalThis.__currentExecutionContext = previousContext;
+        }
+    }
+
+    /**
+     * Get the loading stack for current execution context
+     */
+    private static getLoadingStackInternal(): Set<string> {
+        const context = this.getExecutionContext();
+        if (!this.executionContexts.has(context)) {
+            this.executionContexts.set(context, new Set<string>());
+        }
+        return this.executionContexts.get(context)!;
+    }
+
+    /**
+     * Check if a model with specific ID is currently being loaded
+     */
+    static isLoading(modelType: string, id: string | number): boolean {
+        const key = this.createKey(modelType, id);
+        const loadingStack = this.getLoadingStackInternal();
+        return loadingStack.has(key);
+    }
+
+    /**
+     * Mark a model as currently being loaded
+     */
+    static startLoading(modelType: string, id: string | number): void {
+        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: string, id: string | number): void {
+        const key = this.createKey(modelType, id);
+        const loadingStack = this.getLoadingStackInternal();
+        loadingStack.delete(key);
+    }
+
+    /**
+     * Get current loading stack for debugging
+     */
+    static getLoadingStack(): string[] {
+        const loadingStack = this.getLoadingStackInternal();
+        return Array.from(loadingStack);
+    }
+
+    /**
+     * Clear the entire loading stack for current context
+     */
+    static clearStack(): void {
+        const loadingStack = this.getLoadingStackInternal();
+        loadingStack.clear();
+    }
+
+    /**
+     * Set default maximum loading depth
+     */
+    static setDefaultMaxDepth(depth: number): void {
+        this.defaultMaxDepth = depth;
+    }
+
+    /**
+     * Create a unique key for model type and ID
+     */
+    private static createKey(modelType: string, id: string | number): string {
+        return `${modelType}:${id}`;
+    }
+
+    /**
+     * Execute a function with loading context protection
+     * Automatically manages start/finish loading calls
+     */
+    static async withLoadingContext<T>(
+        modelType: string, 
+        id: string | number, 
+        fn: () => Promise<T>
+    ): Promise<T> {
+        if (this.isLoading(modelType, id)) {
+            // If already loading, return null to break the cycle
+            return null as T;
+        }
+
+        this.startLoading(modelType, id);
+        try {
+            return await fn();
+        } finally {
+            this.finishLoading(modelType, id);
+        }
+    }
+}

package/src/models/utils/index.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';