masterrecord 0.2.34 → 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.16
+// 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;
@@ -348,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/package.json

@@ -1,10 +1,10 @@
 {
   "name": "masterrecord",
-  "version": "0.2.34",
+  "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 ===');