@rws-framework/db 3.9.0 → 3.9.3

package/src/models/utils/FindUtils.ts

@@ -6,50 +6,32 @@ 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> {
-        // 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;
-                }
+        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('');
 
-                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;
-        });
+        const collection = Reflect.get(opModel, '_collection');
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
+
+
+        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 null;
     }
 
     public static async find<T extends RWSModel<T>>(
@@ -57,89 +39,59 @@ export class FindUtils {
         id: string | number,
         findParams: Omit<FindByType, 'conditions'> = null
     ): Promise<T | null> {
-        // 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;
-                }
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
 
-                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;
-                });
-            }
+        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: 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[]> {
-        // 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;
-                }
+        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 })();
 
-                return [];
-            } catch (rwsError: Error | any) {
-                console.error(rwsError);
+                    instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true)) as T);
+                }
 
-                throw rwsError;
+                return instanced;
             }
-        });
+
+            return [];
+        } catch (rwsError: Error | any) {
+            console.error(rwsError);
+
+            throw rwsError;
+        }
     }
 
     public static async paginate<T extends RWSModel<T>>(
@@ -147,50 +99,32 @@ export class FindUtils {
         paginateParams: IPaginationParams,
         findParams?: FindByType
     ): Promise<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;
+        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);
                 }
 
-                return [];
-            } catch (rwsError: Error | any) {
-                console.error(rwsError);
-
-                throw rwsError;
+                return instanced;
             }
-        });
+
+            return [];
+        } catch (rwsError: Error | any) {
+            console.error(rwsError);
+
+            throw rwsError;
+        }
     }
 }

package/LOADING_CONTEXT_FIX.md

@@ -1,139 +0,0 @@
-# LoadingContext Implementation - Solution 1 Documentation (Updated)
-
-## Problem Statement
-
-The RWS framework had two related issues in the postLoad mechanism:
-
-### 1. Original Circular Reference Issue
-- **User model postLoad** calls `userGroup.reload(true)` 
-- **UserGroup model postLoad** calls `User.find(owner, { cancelPostLoad: true })`
-- If that User gets loaded elsewhere without `cancelPostLoad: true`, it could trigger an infinite cycle
-
-### 2. Cross-Request Stack Persistence Issue (Discovered)
-- The LoadingContext had a **global loading stack** that persisted across HTTP requests
-- Stack built up and never got cleared between requests
-- Caused false positive "already being loaded" errors for subsequent requests
-- Led to models not loading properly and authentication failures
-
-## Solution: Request-Scoped Loading Context
-
-### Key Fix: Execution Context Isolation
-
-The critical fix was changing from a **global static loading stack** to **per-execution-context stacks**:
-
-**Before (Problematic):**
-```typescript
-class LoadingContext {
-    private static loadingStack: Set<string> = new Set(); // GLOBAL - persisted across requests
-}
-```
-
-**After (Fixed):**
-```typescript
-class LoadingContext {
-    private static executionContexts = new WeakMap<object, Set<string>>(); // Per-context isolation
-    
-    static withNewExecutionContext<T>(fn: () => Promise<T>): Promise<T> {
-        // Creates fresh context for each operation
-    }
-}
-```
-
-### Implementation Components
-
-#### 1. LoadingContext Class (`/models/utils/LoadingContext.ts`) - Updated
-
-**Key Changes:**
-- **Execution Context Isolation**: Each operation gets its own loading stack
-- **WeakMap for Context Storage**: Associates loading stacks with execution contexts
-- **Automatic Context Creation**: `withNewExecutionContext()` creates fresh contexts
-- **Per-Request Isolation**: Each HTTP request gets its own clean loading context
-
-#### 2. FindUtils Integration (`/models/utils/LoadingUtils.ts`) - Critical Fix
-
-**All top-level methods now wrap operations in new execution contexts:**
-
-```typescript
-public static async findOneBy<T extends RWSModel<T>>(
-    opModel: OpModelType<T>,
-    findParams?: FindByType
-): Promise<T | null> {
-    // CRITICAL: Wrap in new execution context to ensure clean loading stack
-    return LoadingContext.withNewExecutionContext(async () => {
-        // ... existing logic with circular reference protection
-    });
-}
-```
-
-### How The Fix Works
-
-#### Before Fix (Problematic):
-```
-Request 1: User.find(11) -> adds "User:11" to global stack
-Request 1: UserGroup.reload() -> adds "UserGroup:10" to global stack  
-Request 1: Completes, but stack NOT cleared
-Request 2: User.find(11) -> "User:11" already in global stack -> FALSE POSITIVE error
-```
-
-#### After Fix (Working):
-```
-Request 1: LoadingContext.withNewExecutionContext() -> creates fresh context
-Request 1: User.find(11) -> adds "User:11" to context-specific stack
-Request 1: UserGroup.reload() -> adds "UserGroup:10" to same context stack
-Request 1: Completes -> context automatically cleaned up
-
-Request 2: LoadingContext.withNewExecutionContext() -> creates NEW fresh context  
-Request 2: User.find(11) -> adds "User:11" to NEW context stack -> works normally
-```
-
-### Request Isolation Benefits
-
-1. **No Cross-Request Interference**: Each HTTP request gets its own loading context
-2. **Automatic Cleanup**: No manual stack management needed
-3. **Proper Circular Detection**: Still prevents infinite loops within single operations
-4. **No False Positives**: Eliminates "already loading" errors between requests
-
-### Configuration
-
-```typescript
-// Set maximum loading depth for new contexts (default: 10)
-LoadingContext.setDefaultMaxDepth(15);
-
-// Get current loading stack for debugging current context
-console.log(LoadingContext.getLoadingStack());
-
-// Manual context creation (usually not needed)
-await LoadingContext.withNewExecutionContext(async () => {
-    // Database operations here get fresh context
-});
-```
-
-### Testing Results
-
-**Before Fix - Error Logs:**
-```
-Circular reference detected: User:11 is already being loaded. Breaking cycle.
-UnauthorizedException: Unauthorized
-Circular reference detected: User:11 is already being loaded. Breaking cycle.
-Circular reference detected: UserGroup:10 is already being loaded. Breaking cycle.
-Circular reference detected: UserGroup:10 is already being loaded. Breaking cycle.
-// Repeated across multiple requests - FALSE POSITIVES
-```
-
-**After Fix:**
-- Clean loading per HTTP request
-- No false positive circular reference detections  
-- Proper circular reference protection within individual operations
-- No authentication failures due to loading issues
-- No cross-request interference
-
-### Backward Compatibility
-
-- **100% backward compatible**: No changes needed to existing model code
-- **Existing `cancelPostLoad` still works**: Provides additional layer of protection
-- **All existing APIs preserved**: No breaking changes to any interfaces
-- **Automatic context management**: Developers don't need to manage contexts manually
-
-### Summary
-
-This fix resolves both the original circular reference issue AND the newly discovered cross-request stack persistence problem. The key insight was that the loading context needs to be **request-scoped** rather than **application-global**. Each database operation chain now gets its own clean loading context, preventing both infinite recursion within operations and false positive detection across operations.

package/LOADING_CONTEXT_IMPLEMENTATION.md

@@ -1,122 +0,0 @@
-# LoadingContext Implementation - Solution 1 Documentation
-
-## Problem Statement
-
-The RWS framework had a potential infinite recursion issue in the postLoad mechanism where:
-
-1. **User model postLoad** calls `userGroup.reload(true)` 
-2. **UserGroup model postLoad** calls `User.find(owner, { cancelPostLoad: true })`
-3. If that User gets loaded elsewhere without `cancelPostLoad: true`, it could trigger an infinite cycle
-
-The existing anti-recursion mechanism was **per-instance** rather than **per-loading-context**, meaning it only prevented the same object from running postLoad multiple times, but didn't prevent circular loading between different instances of related models.
-
-## Solution: Context-Based Loading Stack
-
-### Implementation Components
-
-#### 1. LoadingContext Class (`/models/utils/LoadingContext.ts`)
-
-A utility class that tracks the chain of models currently being loaded to prevent circular references:
-
-**Key Features:**
-- **Static loading stack**: Tracks `ModelType:ID` combinations currently being loaded
-- **Circular reference detection**: Prevents loading a model that's already in the loading chain
-- **Maximum depth protection**: Prevents infinite chains with configurable depth limit
-- **Automatic cleanup**: Uses try/finally blocks to ensure proper cleanup
-- **Debugging support**: Provides stack inspection and clear error messages
-
-**Key Methods:**
-- `isLoading(modelType, id)`: Check if a model is currently being loaded
-- `startLoading(modelType, id)`: Mark a model as being loaded
-- `finishLoading(modelType, id)`: Mark a model as finished loading
-- `withLoadingContext(modelType, id, fn)`: Execute function with automatic context management
-
-#### 2. FindUtils Integration (`/models/utils/FindUtils.ts`)
-
-Modified all find methods to use LoadingContext:
-
-**Changes in `find()`, `findOneBy()`, `findBy()`, and `paginate()`:**
-- Check if model is already being loaded before creating instance
-- Use `LoadingContext.withLoadingContext()` to wrap model loading
-- Return `null` or skip items that are already being loaded
-- Provide warning messages for detected circular references
-
-#### 3. RWSModel Integration (`/models/core/RWSModel.ts`)
-
-- Added LoadingContext import
-- The reload method now uses FindUtils which automatically gets the protection
-
-### How It Works
-
-#### Normal Loading Flow
-```
-1. User.find(1) -> LoadingContext.startLoading('User', 1)
-2. User._asyncFill() -> loads userGroup relation
-3. UserGroup.reload() -> LoadingContext.startLoading('UserGroup', 2)  
-4. UserGroup._asyncFill() -> loads owner relation
-5. User.find(owner) -> LoadingContext.startLoading('User', 3)
-6. Complete normally -> LoadingContext.finishLoading() for each
-```
-
-#### Circular Reference Prevention
-```
-1. User.find(1) -> LoadingContext.startLoading('User', 1)
-2. User._asyncFill() -> loads userGroup relation
-3. UserGroup.reload() -> LoadingContext.startLoading('UserGroup', 2)  
-4. UserGroup._asyncFill() -> tries to load User.find(1) again
-5. LoadingContext.isLoading('User', 1) returns true
-6. Returns null instead of creating infinite loop
-7. Warning logged: "Circular reference detected"
-```
-
-#### Maximum Depth Protection
-```
-If loading chain exceeds configurable limit (default 10):
-- Throws descriptive error with full loading stack
-- Shows exact chain: "Model1:1 -> Model2:2 -> Model3:3 -> ..."
-- Helps identify complex circular dependencies
-```
-
-### Benefits
-
-1. **Complete Circular Reference Prevention**: Unlike the previous per-instance flag, this prevents all types of circular loading
-2. **Transparent Integration**: Existing code doesn't need changes - works automatically through FindUtils
-3. **Performance Optimized**: Minimal overhead - just Set operations for tracking
-4. **Debugging Friendly**: Clear error messages and stack inspection capabilities
-5. **Configurable**: Adjustable maximum depth and behavior
-6. **Fail-Safe**: Always cleans up loading stack even if errors occur
-
-### Configuration Options
-
-```typescript
-// Set maximum loading depth (default: 10)
-LoadingContext.setMaxDepth(15);
-
-// Get current loading stack for debugging
-console.log(LoadingContext.getLoadingStack());
-
-// Clear stack in emergency situations
-LoadingContext.clearStack();
-```
-
-### Backward Compatibility
-
-- **100% backward compatible**: No changes needed to existing model code
-- **Existing `cancelPostLoad` still works**: Provides additional layer of protection
-- **All existing APIs preserved**: No breaking changes to FindUtils or RWSModel
-
-### Testing
-
-A test file (`LoadingContext.test.ts`) demonstrates:
-- Basic loading detection
-- Circular reference prevention  
-- Maximum depth protection
-- Automatic cleanup
-
-### Error Handling
-
-The implementation provides clear error messages:
-- **Circular Reference**: "Circular reference detected: User:1 is already being loaded. Breaking cycle."
-- **Maximum Depth**: "Maximum loading depth (10) exceeded. Possible circular reference detected. Loading stack: User:1 -> UserGroup:2 -> ..."
-
-This solution provides robust protection against infinite recursion while maintaining full backward compatibility and excellent debugging capabilities.

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

@@ -1,56 +0,0 @@
-/**
- * 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>;
-}