masterrecord 0.2.33 → 0.2.36

package/.claude/settings.local.json

@@ -3,7 +3,13 @@
     "allow": [
       "Read(//Users/alexanderrich/Documents/development/bookbaghq/bookbag-ce/components/models/app/models/**)",
       "Read(//Users/alexanderrich/Documents/development/bookbaghq/bookbag-ce/components/models/app/controllers/api/**)",
-      "Read(//Users/alexanderrich/Documents/development/bookbaghq/bookbag-ce/config/environments/**)"
+      "Read(//Users/alexanderrich/Documents/development/bookbaghq/bookbag-ce/config/environments/**)",
+      "Bash(node test/tablePrefixTest.js:*)",
+      "Bash(node test/whereChainingTest.js:*)",
+      "Bash(npm whoami:*)",
+      "Bash(npm pkg fix:*)",
+      "Bash(~/.npmrc)",
+      "Bash(cat:*)"
     ],
     "deny": [],
     "ask": []

package/QueryLanguage/queryScript.js

@@ -140,7 +140,7 @@ class queryScript{
         else if(type === "where"){
             // If where already exists, merge new expressions into existing where so multiple
             // chained where(...) calls combine into a single WHERE clause (joined by AND).
-            if(obj.where && obj[entityName] && cachedExpr[entityName]){
+            if(obj.where && obj.where[entityName] && cachedExpr[entityName]){
                 const existingQuery = obj.where[entityName].query || {};
                 const incomingQuery = cachedExpr[entityName].query || {};
                 const existingExprs = existingQuery.expressions || [];

package/context.js

@@ -1,4 +1,4 @@
-// Version 0.0.15
+// Version 0.0.17
 
 var modelBuilder  = require('./Entity/entityModelBuilder');
 var query = require('masterrecord/QueryLanguage/queryMethods');
@@ -24,6 +24,7 @@ class context {
     __relationshipModels = [];
     __environment = "";
     __name = "";
+    tablePrefix = "";
     isSQLite = false;
     isMySQL = false;
     isPostgres = false;
@@ -146,7 +147,23 @@ class context {
                 const envFileB = path.join(directFolder, `${envType}.json`);
                 const picked = fs.existsSync(envFileA) ? envFileA : (fs.existsSync(envFileB) ? envFileB : null);
                 if(picked){
-                    file = { file: picked, rootFolder: path.dirname(path.dirname(picked)) };
+                    // Smart root folder detection for plugin paths
+                    // If the env file is in a bb-plugins/<plugin-name>/config/environments/ structure,
+                    // we should set rootFolder to the project root, not the plugin's config folder
+                    let detectedRoot = path.dirname(path.dirname(picked));
+
+                    // Check if we're in a bb-plugins structure
+                    const pickedParts = picked.split(path.sep);
+                    const pluginsIndex = pickedParts.findIndex(part => part === 'bb-plugins');
+
+                    if(pluginsIndex !== -1 && pluginsIndex + 3 < pickedParts.length) {
+                        // We're in bb-plugins/<plugin-name>/config/environments/...
+                        // Set rootFolder to the project root (parent of bb-plugins)
+                        const projectRootParts = pickedParts.slice(0, pluginsIndex);
+                        detectedRoot = projectRootParts.join(path.sep) || path.sep;
+                    }
+
+                    file = { file: picked, rootFolder: detectedRoot };
                 }
             }
             if(!file){
@@ -332,7 +349,14 @@ class context {
 
     dbset(model, name){
         var validModel = modelBuilder.create(model);
-        validModel.__name = name === undefined ? model.name : name;
+        var tableName = name === undefined ? model.name : name;
+
+        // Apply tablePrefix if set
+        if(this.tablePrefix && typeof this.tablePrefix === 'string' && this.tablePrefix.length > 0){
+            tableName = this.tablePrefix + tableName;
+        }
+
+        validModel.__name = tableName;
         this.__entities.push(validModel); // model object
         var buildMod = tools.createNewInstance(validModel, query, this);
         this.__builderEntities.push(buildMod); // query builder entites

package/docs/belongsTo-relationships.md

@@ -0,0 +1,190 @@
+# belongsTo Relationships in MasterRecord
+
+## Overview
+
+When you define a `belongsTo` relationship in MasterRecord, the ORM creates **two separate properties** on your model instances:
+
+1. **The foreign key field** (e.g., `document_id`) - the actual database column value
+2. **The relationship property** (e.g., `Document`) - for accessing/setting the related object or ID
+
+## How belongsTo Works Internally
+
+### Entity Definition
+
+```javascript
+// DocumentChunk entity
+DocumentChunk(db) {
+  db.integer("id").primary().notNull().autoIncrement();
+  db.string("content");
+  db.belongsTo("Document", "document_id");  // Creates both Document and document_id properties
+}
+```
+
+The `belongsTo("Document", "document_id")` call:
+- **Does NOT** create a separate `document_id` field definition
+- Tells MasterRecord that `document_id` is a foreign key to the `Document` entity
+- Creates a relationship property named `Document`
+
+### Model Instance Properties
+
+When you query records or create new instances, **both properties are available**:
+
+```javascript
+const chunk = context.DocumentChunk.where("r => r.id == 1").single();
+
+// Both of these work:
+console.log(chunk.document_id);  // Accesses the foreign key value (e.g., 5)
+console.log(chunk.Document);     // Accesses the relationship (object or ID)
+```
+
+## Usage Patterns
+
+### Pattern 1: INSERT Operations (Setting Foreign Keys)
+
+When **creating new records**, use the **relationship property name**:
+
+```javascript
+const chunk = new DocumentChunk();
+chunk.content = "Sample content";
+chunk.Document = documentId;  // ✅ CORRECT - Use relationship property for INSERT
+
+context.DocumentChunk.add(chunk);
+context.saveChanges();
+```
+
+**Why?** The `belongsTo` setter (entityTrackerModel.js:98-105) triggers dirty field tracking and marks the model as modified when you set the relationship property.
+
+### Pattern 2: READ Operations (Accessing Foreign Keys)
+
+When **reading or filtering records**, use the **foreign key field name**:
+
+```javascript
+// ✅ CORRECT - Use foreign key for filtering
+const chunks = context.DocumentChunk
+  .where(`r => r.document_id == ${docId}`)
+  .toList();
+
+// ✅ CORRECT - Use foreign key in JavaScript filters
+const filtered = allChunks.filter(c => documentIds.includes(c.document_id));
+
+// ✅ CORRECT - Access foreign key value directly
+if (chunk.document_id === targetId) {
+  // ...
+}
+```
+
+**Why?** When records are loaded from the database, the raw column data includes `document_id`. The `build` method (entityTrackerModel.js:21-59) creates getters/setters for all non-relationship fields from the database result.
+
+### Pattern 3: UPDATE Operations
+
+For updates, you can use either property:
+
+```javascript
+// Using relationship property (preferred for consistency)
+chunk.Document = newDocumentId;
+
+// Using foreign key directly (also works)
+chunk.document_id = newDocumentId;
+```
+
+Both will work because:
+- Setting `chunk.Document` triggers the relationship setter (line 98-105)
+- Setting `chunk.document_id` directly modifies the underlying value
+
+## Code References
+
+The behavior is implemented in `/Entity/entityTrackerModel.js`:
+
+### Creating Non-Relationship Properties (lines 21-59)
+
+```javascript
+for (const [modelField, modelFieldValue] of modelFields) {
+    if(!$that._isRelationship(currentEntity[modelField])){
+        // Creates getter/setter for document_id (from database column)
+        modelClass["__proto__"]["_" + modelField] = modelFieldValue;
+        Object.defineProperty(modelClass, modelField, {
+            set: function(value) {
+                modelClass.__state = "modified";
+                modelClass.__dirtyFields.push(modelField);
+                this["__proto__"]["_" + modelField] = value;
+            },
+            get: function() {
+                return this["__proto__"]["_" + modelField];
+            }
+        });
+    }
+}
+```
+
+This loop processes fields from the database result (like `document_id`) and makes them accessible as properties.
+
+### Creating Relationship Properties (lines 89-149)
+
+```javascript
+if($that._isRelationship(currentEntity[entityField])){
+    // Creates getter/setter for Document (relationship property)
+    Object.defineProperty(modelClass, entityField, {
+        set: function(value) {
+            if(typeof value === "string" || typeof value === "number" ||
+               typeof value === "boolean" || typeof value === "bigint") {
+                modelClass.__state = "modified";
+                modelClass.__dirtyFields.push(entityField);
+                modelClass.__context.__track(modelClass);
+            }
+            this["__proto__"]["_" + entityField] = value;
+        },
+        get: function() {
+            // Complex getter logic for lazy loading, etc.
+            return this["__proto__"]["_" + entityField];
+        }
+    });
+
+    if(currentEntity[entityField].relationshipType === "belongsTo"){
+        // Initialize relationship value from database result
+        if(currentModel[entityField]){
+            modelClass[entityField] = currentModel[entityField];
+        }
+    }
+}
+```
+
+This creates the `Document` property for relationship access.
+
+## Real-World Example from bookbag-ce
+
+In `bookbag-ce`, the `UserChat` entity demonstrates this pattern:
+
+```javascript
+// Entity definition
+UserChat(db) {
+  db.integer("id").primary().notNull().autoIncrement();
+  db.belongsTo("Chat", "chat_id");  // Only defines relationship, not chat_id field
+}
+
+// Controller usage (chatController.js:66)
+const messages = context.UserChat
+  .where(`r => r.chat_id == ${chatId}`)  // ✅ Uses foreign key for filtering
+  .toList();
+```
+
+Even though `chat_id` is never explicitly defined as a field, it's accessible because:
+1. The database returns `chat_id` as a column
+2. `entityTrackerModel.build()` creates properties for all columns from the result
+3. The `belongsTo` relationship doesn't prevent the foreign key from being accessible
+
+## Summary
+
+| Operation | Property to Use | Example |
+|-----------|----------------|---------|
+| **INSERT** (setting FK) | Relationship property | `chunk.Document = docId` |
+| **READ** (accessing FK) | Foreign key field | `chunk.document_id` |
+| **FILTER** (where clauses) | Foreign key field | `r.document_id == 5` |
+| **UPDATE** (changing FK) | Either (prefer relationship) | `chunk.Document = newId` |
+
+## Key Takeaways
+
+1. **belongsTo creates TWO properties**, not one
+2. The **foreign key column** (`document_id`) is automatically available from database results
+3. The **relationship property** (`Document`) is created by the ORM for setting relationships
+4. **Use the relationship property for INSERT**, foreign key field for READ/FILTER
+5. Both properties reference the same underlying foreign key value in the database

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "masterrecord",
-  "version": "0.2.33",
+  "version": "0.2.36",
   "description": "An Object-relational mapping for the Master framework. Master Record connects classes to relational database tables to establish a database with almost zero-configuration ",
   "main": "MasterRecord.js",
   "bin": {
-    "masterrecord": "./Migrations/cli.js"
+    "masterrecord": "Migrations/cli.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -27,12 +27,12 @@
     "masterrecord"
   ],
   "dependencies": {
-    "commander": "^14.0.1",
-    "glob": "^11.0.3",
+    "commander": "^14.0.2",
+    "glob": "^13.0.0",
     "deep-object-diff": "^1.1.9",
     "pg": "^8.16.3",
     "sync-mysql2": "^1.0.7",
     "app-root-path": "^3.1.0",
-    "better-sqlite3": "^12.4.1"
+    "better-sqlite3": "^12.5.0"
   }
 }

package/readme.md

@@ -369,6 +369,232 @@ set master=development && masterrecord update-database-all
 - For SQLite contexts, the `connection` path will be created if the directory does not exist.
 - For MySQL contexts, `ensure-database <ContextName>` can create the DB (permissions required) before migrations run.
 - If you rename/move the project root, re-run `enable-migrations-all` or any single-context command once; snapshots use relative paths and will continue working.
-- If `update-database-all` reports “no migration files found” for a context, run `get-migrations <ContextName>`. If empty, create a migration with `add-migration <Name> <ContextName>` or use `add-migration-all <Name>`.
+- If `update-database-all` reports "no migration files found" for a context, run `get-migrations <ContextName>`. If empty, create a migration with `add-migration <Name> <ContextName>` or use `add-migration-all <Name>`.
+
+## Table Prefixes
+
+MasterRecord supports automatic table prefixing for both MySQL and SQLite databases. This is useful for:
+- Multi-tenant applications sharing a single database
+- Plugin systems where each plugin needs isolated tables
+- Avoiding table name conflicts in shared database environments
+
+### Using tablePrefix
+
+Set the `tablePrefix` property in your Context constructor before calling `dbset()`:
+
+```javascript
+var masterrecord = require('masterrecord');
+const User = require('./models/User');
+const Post = require('./models/Post');
+
+class AppContext extends masterrecord.context {
+    constructor() {
+        super();
+
+        // Set table prefix
+        this.tablePrefix = 'myapp_';
+
+        // Configure environment
+        this.env('config/environments');
+
+        // Register models - prefix will be automatically applied
+        this.dbset(User);      // Creates table: myapp_User
+        this.dbset(Post);      // Creates table: myapp_Post
+    }
+}
+
+module.exports = AppContext;
+```
+
+### How it works
+
+When `tablePrefix` is set:
+1. The prefix is automatically prepended to all table names during `dbset()` registration
+2. Works with both the default table name (model class name) and custom names
+3. Applies to all database operations: queries, inserts, updates, deletes, and migrations
+4. Supports both MySQL and SQLite databases
+
+### Example with custom table names
+
+```javascript
+class AppContext extends masterrecord.context {
+    constructor() {
+        super();
+        this.tablePrefix = 'myapp_';
+        this.env('config/environments');
+
+        // Custom table name + prefix
+        this.dbset(User, 'users');       // Creates table: myapp_users
+        this.dbset(Post, 'blog_posts');  // Creates table: myapp_blog_posts
+    }
+}
+```
+
+### Plugin example
+
+Perfect for plugin systems where each plugin needs isolated tables:
+
+```javascript
+// RAG Plugin Context
+class RagContext extends masterrecord.context {
+    constructor() {
+        super();
+
+        // Prefix all RAG plugin tables
+        this.tablePrefix = 'rag_';
+
+        this.env(path.join(__dirname, '../../config/environments'));
+
+        this.dbset(Document);       // Creates table: rag_Document
+        this.dbset(DocumentChunk);  // Creates table: rag_DocumentChunk
+        this.dbset(Settings);       // Creates table: rag_Settings
+    }
+}
+```
+
+### Migrations with table prefixes
+
+Table prefixes work seamlessly with migrations:
+
+```bash
+# Enable migrations (prefix is read from your Context)
+master=development masterrecord enable-migrations AppContext
+
+# Create migration (tables will have prefix in migration file)
+master=development masterrecord add-migration Init AppContext
+
+# Apply migration (creates prefixed tables)
+master=development masterrecord update-database AppContext
+```
+
+The generated migration files will reference the prefixed table names, so you don't need to manually add prefixes in your migration code.
+
+### Notes
+- The prefix is applied during Context construction, so it must be set before `dbset()` calls
+- The prefix is stored in migration snapshots, ensuring consistency across migration operations
+- Empty strings or non-string values are ignored (no prefix applied)
+- Both MySQL and SQLite fully support table prefixes with no special configuration needed
+
+## Query Method Chaining
+
+MasterRecord supports fluent query chaining for building complex queries. You can chain multiple `where()`, `orderBy()`, `skip()`, `take()`, and other methods together to build your query dynamically.
+
+### Chaining Multiple where() Clauses
+
+Multiple `where()` calls are automatically combined with AND logic:
+
+```javascript
+// Build query dynamically
+let query = context.QaTask;
+
+// Add first condition
+query = query.where(t => t.assigned_worker_id == $$, currentUser.id);
+
+// Add second condition (combines with AND)
+query = query.where(t => t.status == $$, 'pending');
+
+// Add ordering and execute
+let tasks = query.orderBy(t => t.created_at).toList();
+```
+
+**Generated SQL:**
+```sql
+SELECT * FROM QaTask AS t
+WHERE t.assigned_worker_id = 123
+  AND t.status = 'pending'
+ORDER BY t.created_at ASC
+```
+
+### Dynamic Query Building
+
+This is especially useful for building queries based on conditional logic:
+
+```javascript
+let query = context.User;
+
+// Always apply base filter
+query = query.where(u => u.is_active == true);
+
+// Conditionally add filters
+if (searchTerm) {
+    query = query.where(u => u.name.like($$), `%${searchTerm}%`);
+}
+
+if (roleFilter) {
+    query = query.where(u => u.role == $$, roleFilter);
+}
+
+// Add pagination
+query = query
+    .orderBy(u => u.created_at)
+    .skip(offset)
+    .take(limit);
+
+// Execute query
+let users = query.toList();
+```
+
+### Chainable Query Methods
+
+All of these methods return the query builder and can be chained:
+
+- **`where(query, ...args)`** - Add WHERE condition (multiple calls combine with AND)
+- **`and(query, ...args)`** - Explicitly add AND condition (alternative to chaining where)
+- **`orderBy(query, ...args)`** - Sort ascending
+- **`orderByDescending(query, ...args)`** - Sort descending
+- **`skip(number)`** - Skip N records (pagination offset)
+- **`take(number)`** - Limit to N records (pagination limit)
+- **`select(query, ...args)`** - Select specific fields
+- **`include(query, ...args)`** - Eager load relationships
+
+### Combining with OR Logic
+
+For OR conditions within a single where clause, use the `||` operator:
+
+```javascript
+// Single where with OR
+let tasks = context.Task
+    .where(t => t.status == 'pending' || t.status == 'in_progress')
+    .toList();
+```
+
+**Generated SQL:**
+```sql
+SELECT * FROM Task AS t
+WHERE (t.status = 'pending' OR t.status = 'in_progress')
+```
+
+### Complex Example
+
+```javascript
+// Complex query with multiple conditions
+let query = context.Order;
+
+// Base filters
+query = query.where(o => o.customer_id == $$, customerId);
+query = query.where(o => o.status == $$ || o.status == $$, 'pending', 'processing');
+
+// Date range filter
+if (startDate) {
+    query = query.where(o => o.created_at >= $$, startDate);
+}
+if (endDate) {
+    query = query.where(o => o.created_at <= $$, endDate);
+}
+
+// Sorting and pagination
+let orders = query
+    .orderByDescending(o => o.created_at)
+    .skip(page * pageSize)
+    .take(pageSize)
+    .toList();
+```
+
+### Important Notes
+
+- Each `where()` call adds an AND condition to the existing WHERE clause
+- Conditions are combined in the order they're added
+- The query is only executed when you call a terminal method: `toList()`, `single()`, `count()`
+- Query builders are reusable - calling `toList()` resets the builder for the next query
 
 

package/test/tablePrefixTest.js

@@ -0,0 +1,100 @@
+// Test for tablePrefix functionality
+// Run with: node test/tablePrefixTest.js
+
+var masterrecord = require('../MasterRecord');
+
+// Define a simple test model
+class TestUser extends masterrecord.model {
+    id(db) {
+        db.integer().primaryKey().autoIncrement();
+    }
+
+    name(db) {
+        db.string();
+    }
+
+    email(db) {
+        db.string();
+    }
+}
+
+class TestPost extends masterrecord.model {
+    id(db) {
+        db.integer().primaryKey().autoIncrement();
+    }
+
+    title(db) {
+        db.string();
+    }
+}
+
+// Test 1: Context WITHOUT prefix
+class TestContextNoPrefix extends masterrecord.context {
+    constructor() {
+        super();
+        this.dbset(TestUser, 'User');
+        this.dbset(TestPost, 'Post');
+    }
+}
+
+// Test 2: Context WITH prefix
+class TestContextWithPrefix extends masterrecord.context {
+    constructor() {
+        super();
+        this.tablePrefix = 'myapp_';
+        this.dbset(TestUser, 'User');
+        this.dbset(TestPost, 'Post');
+    }
+}
+
+// Test 3: Context WITH prefix using default names
+class TestContextWithPrefixDefault extends masterrecord.context {
+    constructor() {
+        super();
+        this.tablePrefix = 'test_';
+        this.dbset(TestUser);
+        this.dbset(TestPost);
+    }
+}
+
+// Run tests
+console.log('=== MasterRecord tablePrefix Tests ===\n');
+
+// Test 1: No prefix
+console.log('Test 1: Context without prefix');
+const ctx1 = new TestContextNoPrefix();
+const user1TableName = ctx1.__entities[0].__name;
+const post1TableName = ctx1.__entities[1].__name;
+console.log(`  User table name: ${user1TableName}`);
+console.log(`  Post table name: ${post1TableName}`);
+console.log(`  Expected: User, Post`);
+console.log(`  Result: ${user1TableName === 'User' && post1TableName === 'Post' ? '✓ PASS' : '✗ FAIL'}\n`);
+
+// Test 2: With prefix and custom names
+console.log('Test 2: Context with prefix "myapp_" and custom table names');
+const ctx2 = new TestContextWithPrefix();
+const user2TableName = ctx2.__entities[0].__name;
+const post2TableName = ctx2.__entities[1].__name;
+console.log(`  User table name: ${user2TableName}`);
+console.log(`  Post table name: ${post2TableName}`);
+console.log(`  Expected: myapp_User, myapp_Post`);
+console.log(`  Result: ${user2TableName === 'myapp_User' && post2TableName === 'myapp_Post' ? '✓ PASS' : '✗ FAIL'}\n`);
+
+// Test 3: With prefix using default names
+console.log('Test 3: Context with prefix "test_" and default table names');
+const ctx3 = new TestContextWithPrefixDefault();
+const user3TableName = ctx3.__entities[0].__name;
+const post3TableName = ctx3.__entities[1].__name;
+console.log(`  TestUser table name: ${user3TableName}`);
+console.log(`  TestPost table name: ${post3TableName}`);
+console.log(`  Expected: test_TestUser, test_TestPost`);
+console.log(`  Result: ${user3TableName === 'test_TestUser' && post3TableName === 'test_TestPost' ? '✓ PASS' : '✗ FAIL'}\n`);
+
+// Test 4: Verify query builder has correct table name
+console.log('Test 4: Query builder references');
+console.log(`  ctx2.myapp_User exists: ${ctx2.myapp_User !== undefined ? '✓ PASS' : '✗ FAIL'}`);
+console.log(`  ctx2.myapp_Post exists: ${ctx2.myapp_Post !== undefined ? '✓ PASS' : '✗ FAIL'}`);
+console.log(`  ctx3.test_TestUser exists: ${ctx3.test_TestUser !== undefined ? '✓ PASS' : '✗ FAIL'}`);
+console.log(`  ctx3.test_TestPost exists: ${ctx3.test_TestPost !== undefined ? '✓ PASS' : '✗ FAIL'}\n`);
+
+console.log('=== Tests Complete ===');

package/test/whereChainingTest.js

@@ -0,0 +1,88 @@
+// Test for where() chaining functionality
+// This test verifies that multiple .where() calls combine properly with AND
+
+var queryScript = require('../QueryLanguage/queryScript');
+
+console.log('=== MasterRecord where() Chaining Test ===\n');
+
+// Simulate what happens in the query builder
+const qs = new queryScript();
+
+// Test Case: Two chained where() calls (like the user's example)
+// let query = this._qaContext.QaTask;
+// query = query.where(t => t.assigned_worker_id == $$, this._currentUser.id);
+// query = query.where(t => t.status == $$, status);
+
+console.log('Test: Chaining two where() calls');
+console.log('  First:  where(t => t.assigned_worker_id == 123)');
+console.log('  Second: where(t => t.status == "pending")');
+console.log();
+
+// First where call
+qs.where('t => t.assigned_worker_id == 123', 'QaTask');
+
+console.log('After first where():');
+console.log('  script.where exists:', qs.script.where !== false);
+console.log('  script.where.QaTask exists:', qs.script.where && qs.script.where.QaTask !== undefined);
+if (qs.script.where && qs.script.where.QaTask && qs.script.where.QaTask.query) {
+    const exprs1 = qs.script.where.QaTask.query.expressions || [];
+    console.log('  Expressions count:', exprs1.length);
+    console.log('  Expression 1:', JSON.stringify(exprs1[0]));
+}
+console.log();
+
+// Second where call (this should MERGE, not overwrite)
+qs.where('t => t.status == "pending"', 'QaTask');
+
+console.log('After second where():');
+console.log('  script.where exists:', qs.script.where !== false);
+console.log('  script.where.QaTask exists:', qs.script.where && qs.script.where.QaTask !== undefined);
+
+if (qs.script.where && qs.script.where.QaTask && qs.script.where.QaTask.query) {
+    const exprs2 = qs.script.where.QaTask.query.expressions || [];
+    console.log('  Expressions count:', exprs2.length);
+    console.log('  Expression 1:', JSON.stringify(exprs2[0]));
+    console.log('  Expression 2:', JSON.stringify(exprs2[1]));
+    console.log();
+
+    // Verify results
+    console.log('=== Test Results ===');
+    if (exprs2.length === 2) {
+        console.log('✓ PASS: Both where conditions are present');
+        console.log('  - First condition: assigned_worker_id == 123');
+        console.log('  - Second condition: status == "pending"');
+        console.log('  - These should be combined with AND in the SQL');
+    } else {
+        console.log('✗ FAIL: Expected 2 expressions, got', exprs2.length);
+        if (exprs2.length === 1) {
+            console.log('  - Only the last where() was applied (bug not fixed)');
+        }
+    }
+} else {
+    console.log('✗ FAIL: script.where structure is invalid');
+}
+
+console.log();
+console.log('=== Additional Test: Three where() calls ===');
+
+// Test with three chained where calls
+const qs2 = new queryScript();
+qs2.where('t => t.user_id == 1', 'Task');
+qs2.where('t => t.status == "active"', 'Task');
+qs2.where('t => t.priority == "high"', 'Task');
+
+if (qs2.script.where && qs2.script.where.Task && qs2.script.where.Task.query) {
+    const exprs3 = qs2.script.where.Task.query.expressions || [];
+    console.log('Expressions count:', exprs3.length);
+    if (exprs3.length === 3) {
+        console.log('✓ PASS: All three where conditions are present');
+        exprs3.forEach((expr, idx) => {
+            console.log(`  ${idx + 1}. ${expr.field} ${expr.func} ${expr.arg}`);
+        });
+    } else {
+        console.log('✗ FAIL: Expected 3 expressions, got', exprs3.length);
+    }
+}
+
+console.log();
+console.log('=== Test Complete ===');