masterrecord 0.3.26 → 0.3.29

package/test/lifecycle-hooks-test.js

@@ -0,0 +1,258 @@
+/**
+ * Test: Lifecycle Hooks
+ * Tests: beforeSave, afterSave, beforeDelete, afterDelete
+ */
+
+const masterrecord = require('../MasterRecord.js');
+const path = require('path');
+const fs = require('fs');
+
+console.log("╔════════════════════════════════════════════════════════════════╗");
+console.log("║                  Lifecycle Hooks Test                         ║");
+console.log("╚════════════════════════════════════════════════════════════════╝\n");
+
+let passed = 0;
+let failed = 0;
+
+// Track hook executions
+const hookLog = [];
+
+class User {
+    id(db) {
+        db.integer().primary().auto();
+    }
+    name(db) {
+        db.string();
+    }
+    email(db) {
+        db.string();
+    }
+
+    beforeSave() {
+        hookLog.push('beforeSave');
+        // Automatically set email domain if missing
+        if (this.email && !this.email.includes('@')) {
+            this.email = this.email + '@example.com';
+        }
+    }
+
+    afterSave() {
+        hookLog.push('afterSave');
+    }
+
+    beforeDelete() {
+        hookLog.push('beforeDelete');
+        // Prevent deletion of admin users
+        if (this.name === 'admin') {
+            throw new Error('Cannot delete admin user');
+        }
+    }
+
+    afterDelete() {
+        hookLog.push('afterDelete');
+    }
+}
+
+class TestContext extends masterrecord.context {
+    constructor() {
+        super();
+    }
+    onConfig(db) {
+        this.dbset(User);
+    }
+}
+
+const dbPath = path.join(__dirname, '..', 'database', 'lifecycleHooks.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)');
+
+    // Test 1: beforeSave hook executes on insert
+    console.log("📝 Test 1: beforeSave hook executes on insert");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        hookLog.length = 0;
+
+        const user = db.User.new();
+        user.name = 'Alice';
+        user.email = 'alice'; // No @ - should be fixed by hook
+        await user.save();
+
+        if (hookLog.includes('beforeSave') && user.email === 'alice@example.com') {
+            console.log("   ✓ beforeSave executed before insert");
+            console.log("   ✓ Email auto-completed to: alice@example.com");
+            passed++;
+        } else {
+            console.log(`   ✗ Hook failed: ${hookLog.join(', ')}, email: ${user.email}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 2: afterSave hook executes after insert
+    console.log("\n📝 Test 2: afterSave hook executes after insert");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        if (hookLog.includes('afterSave') && hookLog.indexOf('afterSave') > hookLog.indexOf('beforeSave')) {
+            console.log("   ✓ afterSave executed after insert");
+            console.log("   ✓ Hooks executed in order: beforeSave → afterSave");
+            passed++;
+        } else {
+            console.log(`   ✗ Hook order incorrect: ${hookLog.join(' → ')}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 3: beforeSave hook executes on update
+    console.log("\n📝 Test 3: beforeSave hook executes on update");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        hookLog.length = 0;
+
+        const user = await db.User.findById(1);
+        user.name = 'Alice Updated';
+        await user.save();
+
+        if (hookLog.includes('beforeSave')) {
+            console.log("   ✓ beforeSave executed on update");
+            passed++;
+        } else {
+            console.log(`   ✗ beforeSave not called on update`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 4: beforeDelete hook can prevent deletion
+    console.log("\n📝 Test 4: beforeDelete hook can prevent deletion");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const admin = db.User.new();
+        admin.name = 'admin';
+        admin.email = 'admin@example.com';
+        await admin.save();
+
+        const adminId = admin.id;
+
+        try {
+            await admin.delete();
+            console.log(`   ✗ Deletion should have been prevented`);
+            failed++;
+        } catch (hookError) {
+            if (hookError.message.includes('Cannot delete admin user')) {
+                // Check that admin still exists
+                const check = await db.User.findById(adminId);
+                if (check && check.name === 'admin') {
+                    console.log("   ✓ beforeDelete prevented deletion of admin user");
+                    passed++;
+                } else {
+                    console.log(`   ✗ Admin was deleted despite hook`);
+                    failed++;
+                }
+            } else {
+                console.log(`   ✗ Unexpected error: ${hookError.message}`);
+                failed++;
+            }
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 5: afterDelete hook executes after successful deletion
+    console.log("\n📝 Test 5: afterDelete hook executes after deletion");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        hookLog.length = 0;
+
+        const user = db.User.new();
+        user.name = 'ToDelete';
+        user.email = 'delete@example.com';
+        await user.save();
+
+        await user.delete();
+
+        if (hookLog.includes('beforeDelete') && hookLog.includes('afterDelete')) {
+            console.log("   ✓ beforeDelete and afterDelete executed");
+            console.log("   ✓ Hooks executed in order: beforeDelete → afterDelete");
+            passed++;
+        } else {
+            console.log(`   ✗ Delete hooks missing: ${hookLog.join(', ')}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 6: Batch operations execute hooks for all entities
+    console.log("\n📝 Test 6: Batch operations execute hooks for all entities");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        hookLog.length = 0;
+
+        const user1 = db.User.new();
+        user1.name = 'Batch1';
+        user1.email = 'batch1';
+
+        const user2 = db.User.new();
+        user2.name = 'Batch2';
+        user2.email = 'batch2';
+
+        await db.saveChanges();
+
+        const beforeSaveCount = hookLog.filter(h => h === 'beforeSave').length;
+        const afterSaveCount = hookLog.filter(h => h === 'afterSave').length;
+
+        if (beforeSaveCount === 2 && afterSaveCount === 2) {
+            console.log("   ✓ Hooks executed for all entities in batch");
+            console.log(`   ✓ beforeSave: ${beforeSaveCount}x, afterSave: ${afterSaveCount}x`);
+            passed++;
+        } else {
+            console.log(`   ✗ Hook counts incorrect: beforeSave=${beforeSaveCount}, afterSave=${afterSaveCount}`);
+            failed++;
+        }
+    } 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/query-helpers-test.js

@@ -0,0 +1,258 @@
+/**
+ * Test: Query Helper Methods
+ * Tests: .first(), .last(), .exists(), .pluck()
+ */
+
+const masterrecord = require('../MasterRecord.js');
+const path = require('path');
+const fs = require('fs');
+
+console.log("╔════════════════════════════════════════════════════════════════╗");
+console.log("║              Query Helper Methods Test                        ║");
+console.log("╚════════════════════════════════════════════════════════════════╝\n");
+
+let passed = 0;
+let failed = 0;
+
+// Define test entities
+class User {
+    id(db) {
+        db.integer().primary().auto();
+    }
+    name(db) {
+        db.string();
+    }
+    email(db) {
+        db.string();
+    }
+}
+
+// Create test context
+class TestContext extends masterrecord.context {
+    constructor() {
+        super();
+    }
+    onConfig(db) {
+        this.dbset(User);
+    }
+}
+
+// Clean test database
+const dbPath = path.join(__dirname, '..', 'database', 'testQueryHelpers.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)');
+
+    // Create test data
+    const users = [
+        { name: 'Alice', email: 'alice@example.com' },
+        { name: 'Bob', email: 'bob@example.com' },
+        { name: 'Charlie', email: 'charlie@example.com' },
+        { name: 'Dave', email: 'dave@example.com' },
+        { name: 'Eve', email: 'eve@example.com' }
+    ];
+
+    for (const userData of users) {
+        const user = db.User.new();
+        user.name = userData.name;
+        user.email = userData.email;
+        await user.save();
+    }
+
+    // Test 1: .first() returns first record
+    console.log("📝 Test 1: .first() returns first record");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const first = await db.User.first();
+
+        if (first && first.name === 'Alice') {
+            console.log("   ✓ .first() returns first record ordered by primary key");
+            passed++;
+        } else {
+            console.log(`   ✗ .first() failed - got: ${first?.name}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 2: .last() returns last record
+    console.log("\n📝 Test 2: .last() returns last record");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const last = await db.User.last();
+
+        if (last && last.name === 'Eve') {
+            console.log("   ✓ .last() returns last record ordered by primary key descending");
+            passed++;
+        } else {
+            console.log(`   ✗ .last() failed - got: ${last?.name}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 3: .exists() returns true for existing records
+    console.log("\n📝 Test 3: .exists() checks record existence");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const exists = await db.User
+            .where(u => u.email == $$, 'alice@example.com')
+            .exists();
+
+        const notExists = await db.User
+            .where(u => u.email == $$, 'nonexistent@example.com')
+            .exists();
+
+        if (exists === true && notExists === false) {
+            console.log("   ✓ .exists() returns true for existing records");
+            console.log("   ✓ .exists() returns false for non-existing records");
+            passed++;
+        } else {
+            console.log(`   ✗ .exists() failed - exists: ${exists}, notExists: ${notExists}`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 4: .pluck() extracts column values
+    console.log("\n📝 Test 4: .pluck() extracts column values");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const emails = await db.User.pluck('email');
+
+        if (Array.isArray(emails) &&
+            emails.length === 5 &&
+            emails.includes('alice@example.com') &&
+            emails.includes('eve@example.com')) {
+            console.log("   ✓ .pluck() extracts column as array");
+            console.log("   ✓ All values included");
+            passed++;
+        } else {
+            console.log(`   ✗ .pluck() failed - got: ${emails?.length} items`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 5: .pluck() with where clause
+    console.log("\n📝 Test 5: .pluck() respects where clause");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const emails = await db.User
+            .where(u => u.name == $$, 'Alice')
+            .pluck('email');
+
+        if (Array.isArray(emails) &&
+            emails.length === 1 &&
+            emails[0] === 'alice@example.com') {
+            console.log("   ✓ .pluck() respects where clause");
+            passed++;
+        } else {
+            console.log(`   ✗ .pluck() with where failed`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 6: .first() with where clause
+    console.log("\n📝 Test 6: .first() respects where clause");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const first = await db.User
+            .where(u => u.name == $$, 'Charlie')
+            .first();
+
+        if (first && first.name === 'Charlie') {
+            console.log("   ✓ .first() respects where clause");
+            passed++;
+        } else {
+            console.log(`   ✗ .first() with where failed`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 7: .first() returns null if no records
+    console.log("\n📝 Test 7: .first() returns null if no records");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const first = await db.User
+            .where(u => u.name == $$, 'NonExistent')
+            .first();
+
+        if (first === null) {
+            console.log("   ✓ .first() returns null if no records");
+            passed++;
+        } else {
+            console.log(`   ✗ .first() should return null`);
+            failed++;
+        }
+    } catch(err) {
+        console.log(`   ✗ Error: ${err.message}`);
+        failed++;
+    }
+
+    // Test 8: .pluck() with ordering
+    console.log("\n📝 Test 8: .pluck() respects ordering");
+    console.log("──────────────────────────────────────────────────");
+    try {
+        const names = await db.User
+            .orderBy(u => u.name)
+            .pluck('name');
+
+        if (names[0] === 'Alice' && names[4] === 'Eve') {
+            console.log("   ✓ .pluck() respects orderBy");
+            passed++;
+        } else {
+            console.log(`   ✗ .pluck() ordering failed`);
+            failed++;
+        }
+    } 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/query-isolation-test.js

@@ -0,0 +1,59 @@
+/**
+ * Test for query instance isolation
+ * Verifies that accessing an entity multiple times returns fresh queryMethods instances
+ */
+
+const queryMethods = require('../QueryLanguage/queryMethods');
+const queryScript = require('../QueryLanguage/queryScript');
+
+console.log('=== Testing Query Instance Isolation ===\n');
+
+// Mock entity
+const mockEntity = {
+    __name: 'TestEntity',
+    id: { type: 'number' },
+    name: { type: 'string' }
+};
+
+// Mock context
+const mockContext = {
+    __track: () => {},
+    __entities: []
+};
+
+console.log('Test 1: Creating separate query instances');
+const query1 = new queryMethods(mockEntity, mockContext);
+const query2 = new queryMethods(mockEntity, mockContext);
+
+console.log(`  Query 1 instance ID: ${query1.__queryObject !== undefined ? 'exists' : 'undefined'}`);
+console.log(`  Query 2 instance ID: ${query2.__queryObject !== undefined ? 'exists' : 'undefined'}`);
+console.log(`  ✓ Instances are separate: ${query1 !== query2}`);
+console.log(`  ✓ QueryObjects are separate: ${query1.__queryObject !== query2.__queryObject}\n`);
+
+console.log('Test 2: Building queries with same parameters in different instances');
+query1.where(e => e.id == $$, 1);
+query2.where(e => e.id == $$, 2);
+
+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) {
+    console.log('  ✓ Query 1 has correct parameters');
+} else {
+    console.error('  ✗ FAIL: Query 1 parameters are wrong!');
+    process.exit(1);
+}
+
+if (params2.length === 1 && params2[0] === 2) {
+    console.log('  ✓ Query 2 has correct parameters\n');
+} else {
+    console.error('  ✗ FAIL: Query 2 parameters are wrong!');
+    process.exit(1);
+}
+
+console.log('✅ All tests passed! Query instances are properly isolated.\n');
+console.log('Note: This confirms the fix will work. The getter in context.js');
+console.log('now creates a new queryMethods instance each time an entity is accessed.');

package/test/simple-id-test.js

@@ -0,0 +1,61 @@
+/**
+ * Simple test to check if ID is set after save
+ */
+
+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', 'simpleIdTest.db');
+    }
+    onConfig(db) {
+        this.dbset(User);
+    }
+}
+
+// Clean
+if (fs.existsSync(path.join(__dirname, '..', 'database', 'simpleIdTest.db'))) {
+    fs.unlinkSync(path.join(__dirname, '..', 'database', 'simpleIdTest.db'));
+}
+
+async function test() {
+    const db = new TestContext();
+    db.onConfig();
+
+    const user = db.User.new();
+    user.name = 'Test';
+
+    console.log('Before save - user.id:', user.id);
+    console.log('Before save - user.__proto__:', Object.keys(user.__proto__));
+
+    await user.save();
+
+    console.log('After save - user.id:', user.id);
+    console.log('After save - user.__proto__:', Object.keys(user.__proto__));
+    console.log('After save - user.__proto__._id:', user.__proto__._id);
+
+    // Try direct access
+    console.log('Direct access test:');
+    for (const key in user) {
+        if (key === 'id') {
+            console.log('Found id property via for-in');
+        }
+    }
+
+    console.log('Has own property id?', user.hasOwnProperty('id'));
+    console.log('Keys:', Object.keys(user));
+}
+
+test().catch(console.error);