@formio/appserver 2.0.0-rc.1 → 2.0.0-rc.4

package/lib/modules/mongodb/db.spec.js

@@ -0,0 +1,714 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const db_1 = require("./db");
+const mongodb_memory_server_1 = require("mongodb-memory-server");
+describe('Database', () => {
+    let mongod;
+    let database;
+    let config;
+    before(() => __awaiter(void 0, void 0, void 0, function* () {
+        mongod = yield mongodb_memory_server_1.MongoMemoryServer.create();
+        const uri = mongod.getUri();
+        config = {
+            url: uri,
+            config: {}
+        };
+        database = new db_1.Database(config);
+    }));
+    after(() => __awaiter(void 0, void 0, void 0, function* () {
+        // Close the database connection
+        if (database) {
+            yield database.close();
+        }
+        // Then stop the MongoDB memory server
+        if (mongod) {
+            yield mongod.stop();
+        }
+    }));
+    describe('constructor', () => {
+        it('should initialize with default values', () => {
+            const db = new db_1.Database(config);
+            (0, chai_1.expect)(db.db).to.be.null;
+            (0, chai_1.expect)(db.currentCollectionName).to.equal('submissions');
+            (0, chai_1.expect)(db.currentCollection).to.be.null;
+            (0, chai_1.expect)(db.defaultCollection).to.be.null;
+            (0, chai_1.expect)(db.prefix).to.equal('');
+        });
+    });
+    describe('ObjectId', () => {
+        it('should handle null/undefined input', () => {
+            (0, chai_1.expect)(database.ObjectId(null)).to.be.null;
+            (0, chai_1.expect)(database.ObjectId(undefined)).to.be.null;
+        });
+        it('should handle $in queries', () => {
+            const input = { $in: ['507f1f77bcf86cd799439011', '507f1f77bcf86cd799439012'] };
+            const result = database.ObjectId(input);
+            (0, chai_1.expect)(result).to.have.property('$in');
+            (0, chai_1.expect)(result.$in).to.be.an('array');
+        });
+        it('should return original value for invalid ObjectId strings', () => {
+            const invalidId = 'invalid-id';
+            const result = database.ObjectId(invalidId);
+            (0, chai_1.expect)(result).to.equal(invalidId);
+        });
+    });
+    describe('collectionName', () => {
+        it('should return collection name without prefix', () => {
+            database.prefix = '';
+            (0, chai_1.expect)(database.collectionName('test')).to.equal('test');
+        });
+        it('should return collection name with prefix', () => {
+            database.prefix = 'myapp.';
+            (0, chai_1.expect)(database.collectionName('test')).to.equal('myapp.test');
+        });
+    });
+    describe('connect', () => {
+        it('should connect to database', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield database.connect();
+            (0, chai_1.expect)(database.db).to.not.be.null;
+            (0, chai_1.expect)(database.defaultCollection).to.not.be.null;
+        }));
+        it('should set prefix when provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const db = new db_1.Database(config);
+            yield db.connect('testapp');
+            (0, chai_1.expect)(db.prefix).to.equal('testapp.');
+        }));
+    });
+    describe('collection', () => {
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            if (!database.db) {
+                yield database.connect();
+            }
+        }));
+        it('should return collection when db is connected', () => {
+            const collection = database.collection('test');
+            (0, chai_1.expect)(collection).to.not.be.null;
+        });
+        it('should return null when db is not connected', () => {
+            const db = new db_1.Database(config);
+            const collection = db.collection('test');
+            (0, chai_1.expect)(collection).to.be.null;
+        });
+    });
+    describe('CRUD Operations', () => {
+        let scope;
+        let testCollection;
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            if (!database.db) {
+                yield database.connect();
+            }
+            // Setup a basic scope for testing
+            scope = {
+                form: {
+                    _id: '507f1f77bcf86cd799439011',
+                    components: []
+                },
+                project: {
+                    _id: '507f1f77bcf86cd799439012'
+                }
+            };
+            testCollection = yield database.formCollection(scope);
+        }));
+        afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            // Clean up test data after each test
+            if (testCollection) {
+                yield testCollection.deleteMany({});
+            }
+        }));
+        describe('create', () => {
+            it('should create a new record with basic data', () => __awaiter(void 0, void 0, void 0, function* () {
+                const recordData = {
+                    data: { name: 'Test User', email: 'test@example.com' },
+                    metadata: { source: 'test' }
+                };
+                const result = yield database.create(scope, recordData);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result._id).to.exist;
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data.name).to.equal('Test User');
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data.email).to.equal('test@example.com');
+                // Verify using raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: result === null || result === void 0 ? void 0 : result._id });
+                (0, chai_1.expect)(rawRecord).to.not.be.null;
+                (0, chai_1.expect)(rawRecord.data.name).to.equal('Test User');
+                (0, chai_1.expect)(rawRecord.data.email).to.equal('test@example.com');
+                (0, chai_1.expect)(rawRecord.metadata.source).to.equal('test');
+            }));
+            it('should set timestamps and system fields', () => __awaiter(void 0, void 0, void 0, function* () {
+                const beforeCreate = new Date();
+                const recordData = {
+                    data: { content: 'Test content' }
+                };
+                const result = yield database.create(scope, recordData);
+                const afterCreate = new Date();
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.created).to.be.a('date');
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.modified).to.be.a('date');
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.deleted).to.be.null;
+                // Verify using raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: result === null || result === void 0 ? void 0 : result._id });
+                (0, chai_1.expect)(rawRecord.created.getTime()).to.be.at.least(beforeCreate.getTime());
+                (0, chai_1.expect)(rawRecord.created.getTime()).to.be.at.most(afterCreate.getTime());
+                (0, chai_1.expect)(rawRecord.form.toString()).to.equal(scope.form._id);
+                (0, chai_1.expect)(rawRecord.project.toString()).to.equal(scope.project._id);
+                (0, chai_1.expect)(rawRecord.deleted).to.be.null;
+            }));
+            it('should create multiple records', () => __awaiter(void 0, void 0, void 0, function* () {
+                const records = [
+                    { data: { name: 'User 1', type: 'first' } },
+                    { data: { name: 'User 2', type: 'second' } },
+                    { data: { name: 'User 3', type: 'third' } }
+                ];
+                const results = [];
+                for (const recordData of records) {
+                    const result = yield database.create(scope, recordData);
+                    results.push(result);
+                }
+                (0, chai_1.expect)(results).to.have.length(3);
+                // Verify all records exist using raw MongoDB find
+                const allRecords = yield testCollection.find({}).toArray();
+                (0, chai_1.expect)(allRecords).to.have.length(3);
+                const names = allRecords.map((record) => record.data.name).sort();
+                (0, chai_1.expect)(names).to.deep.equal(['User 1', 'User 2', 'User 3']);
+            }));
+        });
+        describe('read', () => {
+            let createdRecords;
+            beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+                // Create test data
+                const testData = [
+                    { data: { name: 'John Doe', age: 30, active: 1 } },
+                    { data: { name: 'Jane Smith', age: 25, active: 0 } },
+                    { data: { name: 'Bob Johnson', age: 35, active: 1 } }
+                ];
+                createdRecords = [];
+                for (const recordData of testData) {
+                    const result = yield database.create(scope, recordData);
+                    createdRecords.push(result);
+                }
+            }));
+            it('should find single record by id string', () => __awaiter(void 0, void 0, void 0, function* () {
+                const targetId = createdRecords[0]._id.toString();
+                const result = yield database.read(scope, targetId);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result._id.toString()).to.equal(targetId);
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data.name).to.equal('John Doe');
+                // Verify against raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: createdRecords[0]._id });
+                (0, chai_1.expect)(rawRecord).to.not.be.null;
+                (0, chai_1.expect)(rawRecord.data.name).to.equal(result === null || result === void 0 ? void 0 : result.data.name);
+            }));
+            it('should return null for non-existent id', () => __awaiter(void 0, void 0, void 0, function* () {
+                const nonExistentId = '507f1f77bcf86cd799439999';
+                const result = yield database.read(scope, nonExistentId);
+                (0, chai_1.expect)(result).to.be.null;
+                // Verify against raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: database.ObjectId(nonExistentId) });
+                (0, chai_1.expect)(rawRecord).to.be.null;
+            }));
+            it('should return null for invalid id format', () => __awaiter(void 0, void 0, void 0, function* () {
+                const invalidId = 'invalid-id-format';
+                const result = yield database.read(scope, invalidId);
+                (0, chai_1.expect)(result).to.be.null;
+                // Verify against raw MongoDB find - should not find anything
+                const rawRecord = yield testCollection.findOne({ _id: invalidId });
+                (0, chai_1.expect)(rawRecord).to.be.null;
+            }));
+            it('should handle ObjectId conversion correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+                const targetRecord = createdRecords[1];
+                const idString = targetRecord._id.toString();
+                const result = yield database.read(scope, idString);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result._id.toString()).to.equal(idString);
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data.name).to.equal('Jane Smith');
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data.age).to.equal(25);
+                // Verify against raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: targetRecord._id });
+                (0, chai_1.expect)(rawRecord.data.name).to.equal('Jane Smith');
+                (0, chai_1.expect)(rawRecord.data.age).to.equal(25);
+            }));
+            it('should return null when database is not connected', () => __awaiter(void 0, void 0, void 0, function* () {
+                const db = new db_1.Database(config);
+                const result = yield db.read(scope, createdRecords[0]._id.toString());
+                (0, chai_1.expect)(result).to.be.null;
+            }));
+        });
+        describe('update', () => {
+            let testRecord;
+            beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+                // Create a test record
+                const recordData = {
+                    data: { name: 'Original Name', status: 'draft', version: 1 }
+                };
+                testRecord = yield database.create(scope, recordData);
+            }));
+            it('should update a single record by id string', () => __awaiter(void 0, void 0, void 0, function* () {
+                const updateData = {
+                    data: { name: 'Updated Name', status: 'published', version: 2 }
+                };
+                yield new Promise(resolve => setTimeout(resolve, 10)); // Ensure timestamp difference
+                const result = yield database.update(scope, testRecord._id.toString(), updateData);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data.name).to.equal('Updated Name');
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data.status).to.equal('published');
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.data.version).to.equal(2);
+                // Verify against raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: testRecord._id });
+                (0, chai_1.expect)(rawRecord.data.name).to.equal('Updated Name');
+                (0, chai_1.expect)(rawRecord.data.status).to.equal('published');
+                (0, chai_1.expect)(rawRecord.data.version).to.equal(2);
+                (0, chai_1.expect)(rawRecord.modified.getTime()).to.be.greaterThan(rawRecord.created.getTime());
+            }));
+            it('should return null for non-existent id', () => __awaiter(void 0, void 0, void 0, function* () {
+                const updateData = { data: { status: 'updated' } };
+                const nonExistentId = '507f1f77bcf86cd799439999';
+                const result = yield database.update(scope, nonExistentId, updateData);
+                (0, chai_1.expect)(result).to.be.null;
+                // Verify original record unchanged
+                const rawRecord = yield testCollection.findOne({ _id: testRecord._id });
+                (0, chai_1.expect)(rawRecord.data.name).to.equal('Original Name');
+                (0, chai_1.expect)(rawRecord.data.status).to.equal('draft');
+            }));
+            it('should return null for invalid id format', () => __awaiter(void 0, void 0, void 0, function* () {
+                const updateData = { data: { status: 'updated' } };
+                const invalidId = 'invalid-id-format';
+                const result = yield database.update(scope, invalidId, updateData);
+                (0, chai_1.expect)(result).to.be.null;
+                // Verify original record unchanged
+                const rawRecord = yield testCollection.findOne({ _id: testRecord._id });
+                (0, chai_1.expect)(rawRecord.data.name).to.equal('Original Name');
+            }));
+            it('should update timestamps correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+                const originalModified = testRecord.modified;
+                const updateData = {
+                    data: { status: 'updated' }
+                };
+                // Wait a moment to ensure timestamp difference
+                yield new Promise(resolve => setTimeout(resolve, 10));
+                const result = yield database.update(scope, testRecord._id.toString(), updateData);
+                (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.modified.getTime()).to.be.greaterThan(originalModified.getTime());
+                // Verify against raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: testRecord._id });
+                (0, chai_1.expect)(rawRecord.modified.getTime()).to.be.greaterThan(originalModified.getTime());
+            }));
+            it('should return null when database is not connected', () => __awaiter(void 0, void 0, void 0, function* () {
+                const db = new db_1.Database(config);
+                const updateData = { data: { status: 'updated' } };
+                const result = yield db.update(scope, testRecord._id.toString(), updateData);
+                (0, chai_1.expect)(result).to.be.null;
+            }));
+        });
+        describe('delete', () => {
+            let testRecords;
+            beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+                // Create test records
+                const testData = [
+                    { data: { name: 'Record 1', category: 'temp' } },
+                    { data: { name: 'Record 2', category: 'temp' } },
+                    { data: { name: 'Record 3', category: 'permanent' } }
+                ];
+                testRecords = [];
+                for (const recordData of testData) {
+                    const result = yield database.create(scope, recordData);
+                    testRecords.push(result);
+                }
+            }));
+            it('should soft delete a single record by id string', () => __awaiter(void 0, void 0, void 0, function* () {
+                const targetRecord = testRecords[0];
+                const result = yield database.delete(scope, targetRecord._id.toString());
+                (0, chai_1.expect)(result).to.be.true;
+                // Verify against raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: targetRecord._id });
+                (0, chai_1.expect)(rawRecord.deleted).to.not.be.null;
+                (0, chai_1.expect)(rawRecord.deleted).to.be.a('date');
+                // Verify record still exists in database (soft delete)
+                const allRecords = yield testCollection.find({}).toArray();
+                (0, chai_1.expect)(allRecords).to.have.length(3);
+            }));
+            it('should hard delete a single record when specified', () => __awaiter(void 0, void 0, void 0, function* () {
+                const targetRecord = testRecords[0];
+                const result = yield database.delete(scope, targetRecord._id.toString(), true);
+                (0, chai_1.expect)(result).to.be.true;
+                // Verify record is completely removed from database
+                const rawRecord = yield testCollection.findOne({ _id: targetRecord._id });
+                (0, chai_1.expect)(rawRecord).to.be.null;
+                // Verify total count decreased
+                const allRecords = yield testCollection.find({}).toArray();
+                (0, chai_1.expect)(allRecords).to.have.length(2);
+            }));
+            it('should return false for non-existent id', () => __awaiter(void 0, void 0, void 0, function* () {
+                const nonExistentId = '507f1f77bcf86cd799439999';
+                const result = yield database.delete(scope, nonExistentId);
+                (0, chai_1.expect)(result).to.be.false;
+                // Verify no records were affected
+                const allRecords = yield testCollection.find({}).toArray();
+                (0, chai_1.expect)(allRecords).to.have.length(3);
+                allRecords.forEach((record) => {
+                    (0, chai_1.expect)(record.deleted).to.be.null;
+                });
+            }));
+            it('should return false for invalid id format', () => __awaiter(void 0, void 0, void 0, function* () {
+                const invalidId = 'invalid-id-format';
+                const result = yield database.delete(scope, invalidId);
+                (0, chai_1.expect)(result).to.be.false;
+                // Verify no records were affected
+                const allRecords = yield testCollection.find({}).toArray();
+                (0, chai_1.expect)(allRecords).to.have.length(3);
+            }));
+            it('should handle deletion of already deleted record', () => __awaiter(void 0, void 0, void 0, function* () {
+                // First, soft delete a record
+                const targetRecord = testRecords[0];
+                const firstDelete = yield database.delete(scope, targetRecord._id.toString());
+                (0, chai_1.expect)(firstDelete).to.be.true;
+                // Try to delete it again
+                const secondDelete = yield database.delete(scope, targetRecord._id.toString());
+                (0, chai_1.expect)(secondDelete).to.be.false; // Should be false
+                // Verify it's still soft deleted (not hard deleted)
+                const rawRecord = yield testCollection.findOne({ _id: targetRecord._id });
+                (0, chai_1.expect)(rawRecord).to.not.be.null;
+                (0, chai_1.expect)(rawRecord.deleted).to.not.be.null;
+            }));
+            it('should hard delete an already soft deleted record', () => __awaiter(void 0, void 0, void 0, function* () {
+                const targetRecord = testRecords[0];
+                // First, soft delete the record
+                const softDelete = yield database.delete(scope, targetRecord._id.toString());
+                (0, chai_1.expect)(softDelete).to.be.true;
+                // Then hard delete it
+                const hardDelete = yield database.delete(scope, targetRecord._id.toString(), true);
+                (0, chai_1.expect)(hardDelete).to.be.true;
+                // Verify record is completely removed from database
+                const rawRecord = yield testCollection.findOne({ _id: targetRecord._id });
+                (0, chai_1.expect)(rawRecord).to.be.null;
+                // Verify total count decreased
+                const allRecords = yield testCollection.find({}).toArray();
+                (0, chai_1.expect)(allRecords).to.have.length(2);
+            }));
+            it('should update modified timestamp on soft delete', () => __awaiter(void 0, void 0, void 0, function* () {
+                const targetRecord = testRecords[0];
+                const originalModified = targetRecord.modified;
+                // Wait a moment to ensure timestamp difference
+                yield new Promise(resolve => setTimeout(resolve, 10));
+                const result = yield database.delete(scope, targetRecord._id.toString());
+                (0, chai_1.expect)(result).to.be.true;
+                // Verify against raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: targetRecord._id });
+                (0, chai_1.expect)(rawRecord.modified.getTime()).to.be.greaterThan(originalModified.getTime());
+            }));
+            it('should return false when database is not connected', () => __awaiter(void 0, void 0, void 0, function* () {
+                const db = new db_1.Database(config);
+                const result = yield db.delete(scope, testRecords[0]._id.toString());
+                (0, chai_1.expect)(result).to.be.false;
+            }));
+        });
+        describe('CRUD Integration Tests', () => {
+            it('should perform complete CRUD lifecycle', () => __awaiter(void 0, void 0, void 0, function* () {
+                // CREATE
+                const createData = {
+                    data: { name: 'CRUD Test User', email: 'crud@test.com', status: 'new' }
+                };
+                const created = yield database.create(scope, createData);
+                (0, chai_1.expect)(created).to.not.be.null;
+                // Verify creation with raw MongoDB
+                let rawRecord = yield testCollection.findOne({ _id: created === null || created === void 0 ? void 0 : created._id });
+                (0, chai_1.expect)(rawRecord.data.name).to.equal('CRUD Test User');
+                // READ
+                const readResult = yield database.read(scope, created === null || created === void 0 ? void 0 : created._id.toString());
+                (0, chai_1.expect)(readResult).to.not.be.null;
+                (0, chai_1.expect)(readResult === null || readResult === void 0 ? void 0 : readResult.data.name).to.equal('CRUD Test User');
+                // UPDATE
+                const updateData = {
+                    data: { name: 'Updated CRUD User', status: 'modified' }
+                };
+                const updated = yield database.update(scope, created === null || created === void 0 ? void 0 : created._id.toString(), updateData);
+                (0, chai_1.expect)(updated).to.not.be.null;
+                (0, chai_1.expect)(updated === null || updated === void 0 ? void 0 : updated.data.name).to.equal('Updated CRUD User');
+                // Verify update with raw MongoDB
+                rawRecord = yield testCollection.findOne({ _id: created === null || created === void 0 ? void 0 : created._id });
+                (0, chai_1.expect)(rawRecord.data.name).to.equal('Updated CRUD User');
+                (0, chai_1.expect)(rawRecord.data.status).to.equal('modified');
+                // DELETE (soft)
+                const deleted = yield database.delete(scope, created === null || created === void 0 ? void 0 : created._id.toString());
+                (0, chai_1.expect)(deleted).to.be.true;
+                // Verify soft delete with raw MongoDB
+                rawRecord = yield testCollection.findOne({ _id: created === null || created === void 0 ? void 0 : created._id });
+                (0, chai_1.expect)(rawRecord).to.not.be.null;
+                (0, chai_1.expect)(rawRecord.deleted).to.not.be.null;
+                // HARD DELETE
+                const hardDeleted = yield database.delete(scope, created === null || created === void 0 ? void 0 : created._id.toString(), true);
+                (0, chai_1.expect)(hardDeleted).to.be.true;
+                // Verify hard delete with raw MongoDB
+                rawRecord = yield testCollection.findOne({ _id: created === null || created === void 0 ? void 0 : created._id });
+                (0, chai_1.expect)(rawRecord).to.be.null;
+            }));
+        });
+        describe('index', () => {
+            let testRecords;
+            beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+                // Create a comprehensive dataset for testing
+                const testData = [
+                    { data: { name: 'Alice Johnson', age: 28, department: 'Engineering', active: true, salary: 75000 } },
+                    { data: { name: 'Bob Smith', age: 35, department: 'Marketing', active: true, salary: 65000 } },
+                    { data: { name: 'Carol Davis', age: 42, department: 'Engineering', active: false, salary: 85000 } },
+                    { data: { name: 'David Wilson', age: 29, department: 'Sales', active: true, salary: 55000 } },
+                    { data: { name: 'Eve Brown', age: 31, department: 'Engineering', active: true, salary: 78000 } },
+                    { data: { name: 'Frank Miller', age: 45, department: 'Marketing', active: false, salary: 70000 } },
+                    { data: { name: 'Grace Lee', age: 26, department: 'Sales', active: true, salary: 52000 } },
+                    { data: { name: 'Henry Taylor', age: 38, department: 'Engineering', active: true, salary: 82000 } },
+                    { data: { name: 'Ivy Chen', age: 33, department: 'Marketing', active: true, salary: 68000 } },
+                    { data: { name: 'Jack White', age: 27, department: 'Sales', active: false, salary: 49000 } }
+                ];
+                testRecords = [];
+                for (const recordData of testData) {
+                    const result = yield database.create(scope, recordData);
+                    testRecords.push(result);
+                }
+                // Wait a moment to ensure all records are created with different timestamps
+                yield new Promise(resolve => setTimeout(resolve, 10));
+            }));
+            it('should return all records with default parameters', () => __awaiter(void 0, void 0, void 0, function* () {
+                var _a, _b;
+                const result = yield database.index(scope);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)((_a = result === null || result === void 0 ? void 0 : result.items) === null || _a === void 0 ? void 0 : _a.length).to.be.at.most(10); // Default limit might be 10
+                // Verify against raw MongoDB find (matching the filters applied by the query method)
+                const rawQuery = {
+                    deleted: null,
+                    form: database.ObjectId(scope.form._id),
+                    project: database.ObjectId(scope.project._id)
+                };
+                // Apply the same default limit and sort as the index method
+                const rawRecords = yield testCollection.find(rawQuery).sort({ created: -1 }).limit(10).toArray();
+                (0, chai_1.expect)(rawRecords).to.have.length(10);
+                // Compare first few records (accounting for potential default limit)
+                const compareLength = Math.min((_b = result === null || result === void 0 ? void 0 : result.items) === null || _b === void 0 ? void 0 : _b.length, rawRecords.length);
+                (0, chai_1.expect)(result.items.length).to.equal(compareLength);
+                // Verify that the returned records match the raw query results in content and order
+                for (let i = 0; i < compareLength; i++) {
+                    (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.items[i].data.name).to.equal(rawRecords[i].data.name);
+                    (0, chai_1.expect)(result === null || result === void 0 ? void 0 : result.items[i].data.department).to.equal(rawRecords[i].data.department);
+                }
+            }));
+            it('should handle query filtering', () => __awaiter(void 0, void 0, void 0, function* () {
+                const query = { 'data.department': 'Engineering' };
+                const result = yield database.index(scope, query);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result.items.length).to.equal(4); // Should match 4 engineering records
+                // Verify all returned records match the query
+                result.items.forEach((record) => {
+                    (0, chai_1.expect)(record.data.department).to.equal('Engineering');
+                });
+                // Verify against raw MongoDB find
+                const rawRecords = yield testCollection.find(query).sort({ created: -1 }).toArray();
+                (0, chai_1.expect)(rawRecords).to.have.length(4);
+                (0, chai_1.expect)(result.items.length).to.equal(rawRecords.length);
+                // Compare records
+                for (let i = 0; i < result.items.length; i++) {
+                    (0, chai_1.expect)(result.items[i]._id.toString()).to.equal(rawRecords[i]._id.toString());
+                    (0, chai_1.expect)(result.items[i].data.department).to.equal('Engineering');
+                }
+            }));
+            it('should handle complex query filtering', () => __awaiter(void 0, void 0, void 0, function* () {
+                const query = {
+                    'data.active': true,
+                    'data.salary': { $gte: 70000 }
+                };
+                const result = yield database.index(scope, query);
+                (0, chai_1.expect)(result).to.not.be.null;
+                // Verify all returned records match the complex query
+                result.items.forEach((record) => {
+                    (0, chai_1.expect)(record.data.active).to.be.true;
+                    (0, chai_1.expect)(record.data.salary).to.be.at.least(70000);
+                });
+                // Verify against raw MongoDB find
+                const rawRecords = yield testCollection.find(query).sort({ created: -1 }).toArray();
+                (0, chai_1.expect)(result.items.length).to.equal(rawRecords.length);
+                // Compare records
+                for (let i = 0; i < result.items.length; i++) {
+                    (0, chai_1.expect)(result.items[i]._id.toString()).to.equal(rawRecords[i]._id.toString());
+                    (0, chai_1.expect)(result.items[i].data.active).to.be.true;
+                    (0, chai_1.expect)(result.items[i].data.salary).to.be.at.least(70000);
+                }
+            }));
+            it('should handle limit parameter', () => __awaiter(void 0, void 0, void 0, function* () {
+                const limit = 3;
+                const result = yield database.index(scope, { limit });
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result.items.length).to.equal(limit);
+                // Verify against raw MongoDB find with limit
+                const rawRecords = yield testCollection.find({}).sort({ created: -1 }).limit(limit).toArray();
+                (0, chai_1.expect)(rawRecords).to.have.length(limit);
+                (0, chai_1.expect)(result.items.length).to.equal(rawRecords.length);
+                // Compare records
+                for (let i = 0; i < result.items.length; i++) {
+                    (0, chai_1.expect)(result.items[i]._id.toString()).to.equal(rawRecords[i]._id.toString());
+                }
+            }));
+            it('should handle skip parameter for pagination', () => __awaiter(void 0, void 0, void 0, function* () {
+                const limit = 3;
+                const skip = 2;
+                const result = yield database.index(scope, { limit, skip });
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result.items.length).to.equal(limit);
+                // Verify against raw MongoDB find with skip and limit
+                const rawRecords = yield testCollection.find({}).sort({ created: -1 }).skip(skip).limit(limit).toArray();
+                (0, chai_1.expect)(rawRecords).to.have.length(limit);
+                (0, chai_1.expect)(result.items.length).to.equal(rawRecords.length);
+                // Compare records
+                for (let i = 0; i < result.items.length; i++) {
+                    (0, chai_1.expect)(result.items[i]._id.toString()).to.equal(rawRecords[i]._id.toString());
+                }
+            }));
+            it('should handle custom sort parameter', () => __awaiter(void 0, void 0, void 0, function* () {
+                const sort = { 'data.age': 1 }; // Sort by age ascending
+                const result = yield database.index(scope, { sort, limit: 10, skip: 0 });
+                (0, chai_1.expect)(result).to.not.be.null;
+                // Verify sorting
+                for (let i = 1; i < result.items.length; i++) {
+                    (0, chai_1.expect)(result.items[i].data.age).to.be.at.least(result.items[i - 1].data.age);
+                }
+                // Verify against raw MongoDB find with custom sort
+                const rawRecords = yield testCollection.find({}).sort(sort).toArray();
+                (0, chai_1.expect)(result.items.length).to.be.at.most(rawRecords.length);
+                // Compare first records (accounting for potential limit)
+                const compareLength = Math.min(result.items.length, rawRecords.length);
+                for (let i = 0; i < compareLength; i++) {
+                    (0, chai_1.expect)(result.items[i]._id.toString()).to.equal(rawRecords[i]._id.toString());
+                    (0, chai_1.expect)(result.items[i].data.age).to.equal(rawRecords[i].data.age);
+                }
+            }));
+            it('should handle select parameter for field projection', () => __awaiter(void 0, void 0, void 0, function* () {
+                const select = { 'data.name': 1, 'data.department': 1 };
+                const result = yield database.index(scope, { limit: 10, skip: 0, sort: { created: -1 }, select });
+                (0, chai_1.expect)(result).to.not.be.null;
+                // Verify field projection (only selected fields should be present in data)
+                result.items.forEach((record) => {
+                    (0, chai_1.expect)(record.data.name).to.exist;
+                    (0, chai_1.expect)(record.data.department).to.exist;
+                    // Other fields should not be present (depending on implementation)
+                    // Note: MongoDB projection behavior may vary based on implementation
+                });
+                // Verify against raw MongoDB find with projection
+                const rawRecords = yield testCollection.find({}, { projection: select }).sort({ created: -1 }).toArray();
+                (0, chai_1.expect)(result.items.length).to.be.at.most(rawRecords.length);
+            }));
+            it('should handle empty query results', () => __awaiter(void 0, void 0, void 0, function* () {
+                const query = { 'data.department': 'NonExistentDepartment' };
+                const result = yield database.index(scope, query);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result.items.length).to.equal(0);
+                // Verify against raw MongoDB find
+                const rawRecords = yield testCollection.find(query).toArray();
+                (0, chai_1.expect)(rawRecords).to.have.length(0);
+                (0, chai_1.expect)(result.items.length).to.equal(rawRecords.length);
+            }));
+            it('should exclude soft deleted records by default', () => __awaiter(void 0, void 0, void 0, function* () {
+                // Soft delete one record
+                yield database.delete(scope, testRecords[0]._id.toString());
+                const result = yield database.index(scope);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result.items.length).to.equal(9); // Should be one less
+                // Verify deleted record is not included
+                const deletedRecordInResult = result.items.find((record) => record._id.toString() === testRecords[0]._id.toString());
+                (0, chai_1.expect)(deletedRecordInResult).to.be.undefined;
+                // Verify against raw MongoDB find (excluding deleted)
+                const rawRecords = yield testCollection.find({ deleted: null }).sort({ created: -1 }).toArray();
+                (0, chai_1.expect)(rawRecords).to.have.length(9);
+                (0, chai_1.expect)(result.items.length).to.be.at.most(rawRecords.length);
+            }));
+            it('should handle includeDeleted parameter if available', () => __awaiter(void 0, void 0, void 0, function* () {
+                // Soft delete one record
+                yield database.delete(scope, testRecords[0]._id.toString());
+                // This test assumes the index method has an includeDeleted parameter
+                // Adjust based on actual implementation
+                const result = yield database.index(scope, { limit: 10, skip: 0, sort: { created: -1 }, select: {}, includeDeleted: true });
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result.items.length).to.equal(10); // Should include deleted record
+                // Verify against raw MongoDB find (including deleted)
+                const rawRecords = yield testCollection.find({}).sort({ created: -1 }).toArray();
+                (0, chai_1.expect)(rawRecords).to.have.length(10);
+                (0, chai_1.expect)(result.items.length).to.be.at.most(rawRecords.length);
+            }));
+            it('should handle pagination correctly across multiple pages', () => __awaiter(void 0, void 0, void 0, function* () {
+                const pageSize = 3;
+                const pages = [];
+                // Get first 3 pages
+                for (let page = 0; page < 3; page++) {
+                    const skip = page * pageSize;
+                    const result = yield database.index(scope, { limit: pageSize, skip });
+                    pages.push(result);
+                }
+                // Verify no duplicate records across pages
+                const allIds = pages.flatMap(page => page.items).map((record) => record._id.toString());
+                const uniqueIds = [...new Set(allIds)];
+                (0, chai_1.expect)(allIds.length).to.equal(uniqueIds.length);
+                // Verify against raw MongoDB pagination
+                const rawPage1 = yield testCollection.find({}).sort({ created: -1 }).limit(pageSize).toArray();
+                const rawPage2 = yield testCollection.find({}).sort({ created: -1 }).skip(pageSize).limit(pageSize).toArray();
+                const rawPage3 = yield testCollection.find({}).sort({ created: -1 }).skip(pageSize * 2).limit(pageSize).toArray();
+                // Compare first page
+                (0, chai_1.expect)(pages[0].items.length).to.equal(rawPage1.length);
+                for (let i = 0; i < pages[0].items.length; i++) {
+                    (0, chai_1.expect)(pages[0].items[i]._id.toString()).to.equal(rawPage1[i]._id.toString());
+                }
+                // Compare second page
+                (0, chai_1.expect)(pages[1].items.length).to.equal(rawPage2.length);
+                for (let i = 0; i < pages[1].items.length; i++) {
+                    (0, chai_1.expect)(pages[1].items[i]._id.toString()).to.equal(rawPage2[i]._id.toString());
+                }
+            }));
+            it('should return empty array when database is not connected', () => __awaiter(void 0, void 0, void 0, function* () {
+                const db = new db_1.Database(config);
+                const result = yield db.index(scope);
+                (0, chai_1.expect)(result.items).to.be.an('array');
+                (0, chai_1.expect)(result.items.length).to.equal(0);
+            }));
+            it('should handle ObjectId queries correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+                const targetRecord = testRecords[0];
+                const query = { _id: targetRecord._id };
+                const result = yield database.index(scope, query);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result.items.length).to.equal(1);
+                (0, chai_1.expect)(result.items[0]._id.toString()).to.equal(targetRecord._id.toString());
+                // Verify against raw MongoDB find
+                const rawRecord = yield testCollection.findOne({ _id: targetRecord._id });
+                (0, chai_1.expect)(rawRecord).to.not.be.null;
+                (0, chai_1.expect)(result.items[0].data.name).to.equal(rawRecord.data.name);
+            }));
+            it('should handle regex queries', () => __awaiter(void 0, void 0, void 0, function* () {
+                const query = { 'data.name': { $regex: /^A/, $options: 'i' } }; // Names starting with 'A'
+                const result = yield database.index(scope, query);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result.items.length).to.equal(1); // Should match 'Alice Johnson'
+                (0, chai_1.expect)(result.items[0].data.name).to.equal('Alice Johnson');
+                // Verify against raw MongoDB find
+                const rawRecords = yield testCollection.find(query).sort({ created: -1 }).toArray();
+                (0, chai_1.expect)(rawRecords).to.have.length(1);
+                (0, chai_1.expect)(result.items.length).to.equal(rawRecords.length);
+                (0, chai_1.expect)(result.items[0].data.name).to.equal(rawRecords[0].data.name);
+            }));
+            it('should handle $in queries', () => __awaiter(void 0, void 0, void 0, function* () {
+                const query = { 'data.department': { $in: ['Engineering', 'Sales'] } };
+                const result = yield database.index(scope, query);
+                (0, chai_1.expect)(result).to.not.be.null;
+                (0, chai_1.expect)(result.items.length).to.equal(7); // 4 Engineering + 3 Sales
+                // Verify all returned records match the query
+                result.items.forEach((record) => {
+                    (0, chai_1.expect)(['Engineering', 'Sales']).to.include(record.data.department);
+                });
+                // Verify against raw MongoDB find
+                const rawRecords = yield testCollection.find(query).sort({ created: -1 }).toArray();
+                (0, chai_1.expect)(rawRecords).to.have.length(7);
+                (0, chai_1.expect)(result.items.length).to.equal(rawRecords.length);
+            }));
+        });
+    });
+});