masterrecord 0.3.26 → 0.3.29

package/test/bulk-operations-test.js

@@ -0,0 +1,235 @@
+/**
+ * Test: Bulk Operations API
+ * Tests: bulkCreate, bulkUpdate, bulkDelete
+ */
+
+const masterrecord = require('../MasterRecord.js');
+const path = require('path');
+const fs = require('fs');
+
+console.log("╔════════════════════════════════════════════════════════════════╗");
+console.log("║                 Bulk Operations API Test                      ║");
+console.log("╚════════════════════════════════════════════════════════════════╝\n");
+
+let passed = 0;
+let failed = 0;
+
+class User {
+    id(db) {
+        db.integer().primary().auto();
+    }
+    name(db) {
+        db.string();
+    }
+    email(db) {
+        db.string();
+    }
+    status(db) {
+        db.string();
+    }
+}
+
+class TestContext extends masterrecord.context {
+    constructor() {
+        super();
+    }
+    onConfig(db) {
+        this.dbset(User);
+    }
+}
+
+const dbPath = path.join(__dirname, '..', 'database', 'bulkOperations.db');
+if (fs.existsSync(dbPath)) {
+    fs.unlinkSync(dbPath);
+}
+
+async function runTests() {
+    const db = new TestContext();
+
+    // Initialize SQLite database
+    const SQLLiteEngine = require('../SQLLiteEngine');
+    const sqlite3 = require('better-sqlite3');
+    db.isSQLite = true;
+    db.isMySQL = false;
+    db.isPostgres = false;
+    db._SQLEngine = new SQLLiteEngine();
+    db.db = new sqlite3(dbPath);
+    db._SQLEngine.setDB(db.db, 'better-sqlite3');
+
+    db.onConfig();
+
+    // Create table
+    db.db.exec('CREATE TABLE IF NOT EXISTS User (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, email TEXT, status TEXT)');
+
+    // Test 1: bulkCreate creates multiple entities
+    console.log("📝 Test 1: bulkCreate creates multiple entities");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const users = await db.bulkCreate('User', [
+            { name: 'Alice', email: 'alice@example.com', status: 'active' },
+            { name: 'Bob', email: 'bob@example.com', status: 'active' },
+            { name: 'Charlie', email: 'charlie@example.com', status: 'inactive' },
+            { name: 'Dave', email: 'dave@example.com', status: 'active' },
+            { name: 'Eve', email: 'eve@example.com', status: 'pending' }
+        ]);
+
+        if (users.length === 5 && users.every(u => u.id)) {
+            console.log("   ✓ Created 5 entities");
+            console.log(`   ✓ All entities have IDs: ${users.map(u => u.id).join(', ')}`);
+            passed++;
+        } else {
+            console.log(`   ✗ bulkCreate failed: ${users.length} entities created`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 2: bulkCreate returns entities in order
+    console.log("\n📝 Test 2: bulkCreate returns entities in order");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const users = await db.User.toList();
+        const names = users.map(u => u.name);
+
+        if (names[0] === 'Alice' && names[4] === 'Eve') {
+            console.log("   ✓ Entities created in correct order");
+            passed++;
+        } else {
+            console.log(`   ✗ Order incorrect: ${names.join(', ')}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 3: bulkUpdate updates multiple entities
+    console.log("\n📝 Test 3: bulkUpdate updates multiple entities");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        await db.bulkUpdate('User', [
+            { id: 1, status: 'inactive' },
+            { id: 2, status: 'inactive' },
+            { id: 4, status: 'inactive' }
+        ]);
+
+        const user1 = await db.User.findById(1);
+        const user2 = await db.User.findById(2);
+        const user4 = await db.User.findById(4);
+
+        if (user1.status === 'inactive' && user2.status === 'inactive' && user4.status === 'inactive') {
+            console.log("   ✓ Updated 3 entities");
+            console.log("   ✓ Status changed to: inactive");
+            passed++;
+        } else {
+            console.log(`   ✗ Update failed: statuses are ${user1.status}, ${user2.status}, ${user4.status}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 4: bulkUpdate leaves other fields unchanged
+    console.log("\n📝 Test 4: bulkUpdate leaves other fields unchanged");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const user1 = await db.User.findById(1);
+
+        if (user1.name === 'Alice' && user1.email === 'alice@example.com') {
+            console.log("   ✓ Other fields unchanged");
+            passed++;
+        } else {
+            console.log(`   ✗ Fields changed: name=${user1.name}, email=${user1.email}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 5: bulkDelete deletes multiple entities
+    console.log("\n📝 Test 5: bulkDelete deletes multiple entities");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        await db.bulkDelete('User', [3, 5]);
+
+        const user3 = await db.User.findById(3);
+        const user5 = await db.User.findById(5);
+        const remaining = await db.User.toList();
+
+        if (user3 === null && user5 === null && remaining.length === 3) {
+            console.log("   ✓ Deleted 2 entities");
+            console.log(`   ✓ Remaining entities: ${remaining.length}`);
+            passed++;
+        } else {
+            console.log(`   ✗ Delete failed: user3=${user3}, user5=${user5}, remaining=${remaining.length}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 6: bulkCreate with empty array throws error
+    console.log("\n📝 Test 6: bulkCreate with empty array throws error");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        await db.bulkCreate('User', []);
+        console.log(`   ✗ Should have thrown error`);
+        failed++;
+    } catch(err) {
+        if (err.message.includes('non-empty array')) {
+            console.log("   ✓ Empty array rejected");
+            passed++;
+        } else {
+            console.log(`   ✗ Wrong error: ${err.message}`);
+            failed++;
+        }
+    }
+
+    // Test 7: bulkUpdate with invalid entity throws error
+    console.log("\n📝 Test 7: bulkUpdate with invalid entity throws error");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        await db.bulkUpdate('NonExistentEntity', [{ id: 1, name: 'Test' }]);
+        console.log(`   ✗ Should have thrown error`);
+        failed++;
+    } catch(err) {
+        if (err.message.includes('not found')) {
+            console.log("   ✓ Invalid entity name rejected");
+            passed++;
+        } else {
+            console.log(`   ✗ Wrong error: ${err.message}`);
+            failed++;
+        }
+    }
+
+    // Test 8: bulkDelete with non-existent IDs doesn't throw
+    console.log("\n📝 Test 8: bulkDelete with non-existent IDs doesn't throw");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        await db.bulkDelete('User', [999, 1000, 1001]);
+        console.log("   ✓ Non-existent IDs handled gracefully");
+        passed++;
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Summary
+    console.log("\n" + "=".repeat(64));
+    console.log(`Test Results: ${passed} passed, ${failed} failed`);
+    console.log("=".repeat(64));
+
+    if (failed > 0) {
+        process.exit(1);
+    }
+}
+
+runTests().catch(err => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});

package/test/cache-toObject-test.js

@@ -0,0 +1,105 @@
+/**
+ * Test to verify caching properly handles entity reconstruction
+ */
+const assert = require('assert');
+const context = require('../context');
+
+describe('Cache Entity Reconstruction Test', function() {
+    let db;
+
+    before(async function() {
+        // Create in-memory SQLite database
+        db = new context({ filename: ":memory:", type: "SQLLite" });
+
+        // Define a test entity
+        db.TestEntity = {
+            __name: "TestEntity",
+            id: db.EntityModel("id").integer().primary().auto(),
+            name: db.EntityModel("name").string(),
+            description: db.EntityModel("description").string()
+        };
+
+        await db.initialize();
+    });
+
+    after(async function() {
+        if (db && db.close) {
+            await db.close();
+        }
+    });
+
+    it('should properly return cached single entity with toObject method', async function() {
+        // Insert test data
+        const entity = db.TestEntity.create();
+        entity.name = "Test Item";
+        entity.description = "Test Description";
+        await db.saveChanges();
+
+        // First query (cache miss) - with caching enabled
+        const result1 = await db.TestEntity.cache().where(t => t.id === entity.id).single();
+
+        assert(result1, 'First query should return result');
+        assert.strictEqual(result1.name, "Test Item");
+        assert(typeof result1.toObject === 'function', 'Result should have toObject method');
+
+        // Convert to plain object should work
+        const plain1 = result1.toObject();
+        assert.strictEqual(plain1.name, "Test Item");
+
+        // Second query (cache hit) - should return entity with methods
+        const result2 = await db.TestEntity.cache().where(t => t.id === entity.id).single();
+
+        assert(result2, 'Cached query should return result');
+        assert.strictEqual(result2.name, "Test Item");
+        assert(typeof result2.toObject === 'function', 'Cached result should have toObject method');
+
+        // toObject should work on cached entity
+        const plain2 = result2.toObject();
+        assert.strictEqual(plain2.name, "Test Item");
+    });
+
+    it('should properly return cached list with toObject methods', async function() {
+        // Clear any existing data
+        const existing = await db.TestEntity.toList();
+        for (const item of existing) {
+            await item.delete();
+        }
+        await db.saveChanges();
+
+        // Insert test data
+        const entity1 = db.TestEntity.create();
+        entity1.name = "Item 1";
+        const entity2 = db.TestEntity.create();
+        entity2.name = "Item 2";
+        await db.saveChanges();
+
+        // First query (cache miss)
+        const list1 = await db.TestEntity.cache().toList();
+
+        assert(Array.isArray(list1), 'First query should return array');
+        assert.strictEqual(list1.length, 2);
+        assert(typeof list1[0].toObject === 'function', 'First item should have toObject method');
+        assert(typeof list1[1].toObject === 'function', 'Second item should have toObject method');
+
+        const plain1 = list1[0].toObject();
+        assert.strictEqual(plain1.name, "Item 1");
+
+        // Second query (cache hit)
+        const list2 = await db.TestEntity.cache().toList();
+
+        assert(Array.isArray(list2), 'Cached query should return array');
+        assert.strictEqual(list2.length, 2, 'Cached array should have correct length');
+        assert(typeof list2[0].toObject === 'function', 'Cached first item should have toObject method');
+        assert(typeof list2[1].toObject === 'function', 'Cached second item should have toObject method');
+
+        const plain2 = list2[0].toObject();
+        assert.strictEqual(plain2.name, "Item 1");
+    });
+
+    it('should handle null results properly', async function() {
+        // Query for non-existent entity
+        const result = await db.TestEntity.cache().where(t => t.id === 99999).single();
+
+        assert.strictEqual(result, null, 'Non-existent entity should return null');
+    });
+});

package/test/debug-id-test.js

@@ -0,0 +1,63 @@
+/**
+ * Debug test to trace ID setting
+ */
+
+const masterrecord = require('../MasterRecord.js');
+const path = require('path');
+const fs = require('fs');
+
+class User {
+    id(db) {
+        db.integer().primary().auto();
+    }
+    name(db) {
+        db.string();
+    }
+}
+
+class TestContext extends masterrecord.context {
+    constructor() {
+        super();
+        this.database = path.join(__dirname, '..', 'database', 'debugIdTest.db');
+    }
+    onConfig(db) {
+        this.dbset(User);
+    }
+}
+
+// Clean
+if (fs.existsSync(path.join(__dirname, '..', 'database', 'debugIdTest.db'))) {
+    fs.unlinkSync(path.join(__dirname, '..', 'database', 'debugIdTest.db'));
+}
+
+async function test() {
+    const db = new TestContext();
+    db.onConfig();
+
+    const user = db.User.new();
+    user.name = 'Test';
+
+    console.log('\n=== Manual ID set test ===');
+    console.log('Before manual set - user.id:', user.id);
+
+    user.id = 123;
+    console.log('After user.id = 123 - user.id:', user.id);
+    console.log('After manual set - user.__proto__._id:', user.__proto__._id);
+
+    user.id = 456;
+    console.log('After user.id = 456 - user.id:', user.id);
+
+    console.log('\n=== Now test with save ===');
+    const user2 = db.User.new();
+    user2.name = 'Test2';
+
+    console.log('Before save - tracked entities:', db.__trackedEntities.length);
+    console.log('Before save - user2.__state:', user2.__state);
+
+    await user2.save();
+
+    console.log('After save - user2.id:', user2.id);
+    console.log('After save - user2.__proto__._id:', user2.__proto__._id);
+}
+
+test().catch(console.error);

package/test/double-where-bug-test.js

@@ -0,0 +1,71 @@
+/**
+ * Test for double WHERE clause bug fix
+ * Verifies that multiple queries don't accumulate parameters
+ */
+
+// Note: This test doesn't actually run queries, just tests query building
+// No database needed
+const queryMethods = require('../QueryLanguage/queryMethods');
+const modelBuilder = require('../Entity/entityModelBuilder');
+
+// Mock entity
+const mockEntity = {
+    __name: 'TestEntity',
+    id: { type: 'number' },
+    name: { type: 'string' }
+};
+
+// Create test context
+class TestContext extends context {
+    constructor() {
+        super();
+        this.dbset(mockEntity);
+    }
+}
+
+console.log('=== Testing double WHERE clause bug fix ===\n');
+
+try {
+    const ctx = new TestContext();
+
+    // Access the entity multiple times and build queries
+    console.log('Test 1: Multiple separate queries should not share state');
+    const query1 = ctx.TestEntity.where(e => e.id == $$, 1);
+    const query2 = ctx.TestEntity.where(e => e.id == $$, 2);
+
+    // Check that they have different queryObject instances
+    const haveDifferentInstances = query1.__queryObject !== query2.__queryObject;
+    console.log(`  ✓ Query instances are separate: ${haveDifferentInstances}`);
+
+    // Check parameter accumulation
+    const params1 = query1.__queryObject.parameters.get();
+    const params2 = query2.__queryObject.parameters.get();
+
+    console.log(`  Query 1 parameters: [${params1}]`);
+    console.log(`  Query 2 parameters: [${params2}]`);
+
+    if (params1.length === 1 && params1[0] === 1 && params2.length === 1 && params2[0] === 2) {
+        console.log('  ✓ Parameters are correctly isolated\n');
+    } else {
+        console.error('  ✗ FAIL: Parameters are not isolated!\n');
+        process.exit(1);
+    }
+
+    console.log('Test 2: Accessing entity property multiple times returns fresh instances');
+    const instance1 = ctx.TestEntity;
+    const instance2 = ctx.TestEntity;
+    const areDifferent = instance1 !== instance2;
+    console.log(`  ✓ Each access returns a new instance: ${areDifferent}\n`);
+
+    if (!areDifferent) {
+        console.error('  ✗ FAIL: Instances are being reused!\n');
+        process.exit(1);
+    }
+
+    console.log('✅ All tests passed! Double WHERE bug is fixed.\n');
+
+} catch (error) {
+    console.error('❌ Test failed with error:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+}