@formio/appserver 2.0.0-rc.8 → 2.1.1

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

@@ -1,714 +0,0 @@
-"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);
-            }));
-        });
-    });
-});