@joystick.js/db-canary 0.0.0-canary.2209

package/tests/server/lib/operations/bulk_write.test.js

@@ -0,0 +1,128 @@
+import test from 'ava';
+import sinon from 'sinon';
+import bulk_write from '../../../../src/server/lib/operations/bulk_write.js';
+import insert_one from '../../../../src/server/lib/operations/insert_one.js';
+import { initialize_database, get_database, cleanup_database } from '../../../../src/server/lib/query_engine.js';
+
+test.beforeEach(() => {
+  initialize_database('./test_data');
+  const db = get_database();
+  db.clearSync();
+});
+
+test.afterEach(async () => {
+  await cleanup_database();
+});
+
+test('bulk_write - should perform insert, update, and delete in one transaction', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Alice', age: 20 });
+  const operations = [
+    { insert_one: { document: { name: 'Bob', age: 30 } } },
+    { update_one: { filter: { _id: inserted_id }, update: { $set: { age: 21 } } } },
+    { delete_one: { filter: { name: 'Bob' } } }
+  ];
+  const result = await bulk_write('default', 'users', operations);
+  t.true(result.acknowledged);
+  t.is(result.inserted_count, 1);
+  t.is(result.matched_count, 1);
+  t.is(result.modified_count, 1);
+  t.is(result.deleted_count, 1);
+  t.truthy(result.inserted_ids[0]);
+  const db = get_database();
+  const alice_data = db.get(`default:users:${inserted_id}`);
+  const alice = JSON.parse(alice_data);
+  t.is(alice.age, 21);
+  const bob_id = result.inserted_ids[0];
+  const bob_data = db.get(`default:users:${bob_id}`);
+  t.falsy(bob_data);
+});
+
+test('bulk_write - should upsert with update_one', async (t) => {
+  const operations = [
+    { update_one: { filter: { name: 'Carol' }, update: { $set: { age: 40 } }, upsert: true } }
+  ];
+  const result = await bulk_write('default', 'users', operations);
+  t.is(result.upserted_count, 1);
+  t.truthy(result.upserted_ids[0]);
+  const db = get_database();
+  const doc_data = db.get(`default:users:${result.upserted_ids[0]}`);
+  if (doc_data) {
+    const doc = JSON.parse(doc_data);
+    t.is(doc.name, 'Carol');
+    t.is(doc.age, 40);
+  } else {
+    t.fail('Document not found');
+  }
+});
+
+test('bulk_write - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(() => bulk_write('default', '', [{ insert_one: { document: { name: 'X' } } }]), { message: 'Collection name is required' });
+});
+
+test('bulk_write - should throw if operations is not a non-empty array', async (t) => {
+  await t.throwsAsync(() => bulk_write('default', 'users', null), { message: 'Operations must be a non-empty array' });
+  await t.throwsAsync(() => bulk_write('default', 'users', []), { message: 'Operations must be a non-empty array' });
+});
+
+test('bulk_write - should throw on unsupported operation type', async (t) => {
+  const operations = [{ fooBar: { document: { name: 'Y' } } }];
+  await t.throwsAsync(() => bulk_write('default', 'users', operations), { message: 'Unsupported bulk operation: fooBar' });
+});
+
+test('bulk_write - should rollback all operations if one fails', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { _id: 'fixed_id', name: 'Zed' });
+  const operations = [
+    { insert_one: { document: { _id: 'fixed_id', name: 'Duplicate' } } },
+    { insert_one: { document: { name: 'ShouldNotInsert' } } }
+  ];
+  await t.throwsAsync(() => bulk_write('default', 'users', operations));
+  const db = get_database();
+  const range_data = Array.from(db.getRange({ start: 'default:users:', end: 'default:users:\xFF' }));
+  const should_not_insert = range_data.find(({ value }) => {
+    const doc = JSON.parse(value);
+    return doc.name === 'ShouldNotInsert';
+  });
+  t.falsy(should_not_insert);
+});
+
+test('bulk_write - should support backward compatibility with camelCase operations', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Alice', age: 20 });
+  const operations = [
+    { insertOne: { document: { name: 'Bob', age: 30 } } },
+    { updateOne: { filter: { _id: inserted_id }, update: { $set: { age: 21 } } } },
+    { deleteOne: { filter: { name: 'Bob' } } }
+  ];
+  const result = await bulk_write('default', 'users', operations);
+  t.true(result.acknowledged);
+  t.is(result.inserted_count, 1);
+  t.is(result.matched_count, 1);
+  t.is(result.modified_count, 1);
+  t.is(result.deleted_count, 1);
+  t.truthy(result.inserted_ids[0]);
+  const db = get_database();
+  const alice_data = db.get(`default:users:${inserted_id}`);
+  const alice = JSON.parse(alice_data);
+  t.is(alice.age, 21);
+  const bob_id = result.inserted_ids[0];
+  const bob_data = db.get(`default:users:${bob_id}`);
+  t.falsy(bob_data);
+});
+
+test('bulk_write - should support mixed snake_case and camelCase operations', async (t) => {
+  const operations = [
+    { insert_one: { document: { name: 'Snake', type: 'snake_case' } } },
+    { insertOne: { document: { name: 'Camel', type: 'camelCase' } } }
+  ];
+  const result = await bulk_write('default', 'users', operations);
+  t.true(result.acknowledged);
+  t.is(result.inserted_count, 2);
+  t.truthy(result.inserted_ids[0]);
+  t.truthy(result.inserted_ids[1]);
+  const db = get_database();
+  const snake_data = db.get(`default:users:${result.inserted_ids[0]}`);
+  const camel_data = db.get(`default:users:${result.inserted_ids[1]}`);
+  const snake_doc = JSON.parse(snake_data);
+  const camel_doc = JSON.parse(camel_data);
+  t.is(snake_doc.name, 'Snake');
+  t.is(camel_doc.name, 'Camel');
+});

package/tests/server/lib/operations/create_index.test.js

@@ -0,0 +1,138 @@
+import test from 'ava';
+import { initialize_database, get_database, cleanup_database } from '../../../../src/server/lib/query_engine.js';
+import { initialize_index_database, get_index_database } from '../../../../src/server/lib/index_manager.js';
+import create_index_operation from '../../../../src/server/lib/operations/create_index.js';
+
+test.beforeEach(() => {
+  initialize_database('./test_data');
+  initialize_index_database();
+  
+  const main_db = get_database();
+  const index_db = get_index_database();
+  
+  try {
+    const main_range = main_db.getRange();
+    for (const { key } of main_range) {
+      try {
+        main_db.remove(key);
+      } catch (error) {
+        // Ignore errors during cleanup
+      }
+    }
+  } catch (error) {
+    // Ignore errors during cleanup
+  }
+  
+  try {
+    const index_range = index_db.getRange();
+    for (const { key } of index_range) {
+      try {
+        index_db.remove(key);
+      } catch (error) {
+        // Ignore errors during cleanup
+      }
+    }
+  } catch (error) {
+    // Ignore errors during cleanup
+  }
+});
+
+test.afterEach(async () => {
+  await cleanup_database();
+});
+
+test('create_index_operation - should create an index successfully', async (t) => {
+  const result = await create_index_operation('default', 'users', 'email');
+  
+  t.is(result.acknowledged, true);
+});
+
+test('create_index_operation - should create a unique index', async (t) => {
+  const result = await create_index_operation('default', 'users', 'email', { unique: true });
+  
+  t.is(result.acknowledged, true);
+});
+
+test('create_index_operation - should create a sparse index', async (t) => {
+  const result = await create_index_operation('default', 'users', 'email', { sparse: true });
+  
+  t.is(result.acknowledged, true);
+});
+
+test('create_index_operation - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(
+    () => create_index_operation('default', '', 'email'),
+    { message: 'Collection name is required' }
+  );
+});
+
+test('create_index_operation - should throw if field name is missing', async (t) => {
+  await t.throwsAsync(
+    () => create_index_operation('default', 'users', ''),
+    { message: 'Field name is required' }
+  );
+});
+
+test('create_index_operation - should throw if index already exists', async (t) => {
+  await create_index_operation('default', 'users', 'email');
+  
+  await t.throwsAsync(
+    () => create_index_operation('default', 'users', 'email'),
+    { message: 'Index on default.users.email already exists' }
+  );
+});
+
+test('create_index_operation - should create index with upsert when index does not exist', async (t) => {
+  const result = await create_index_operation('default', 'users', 'email', { upsert: true });
+  
+  t.is(result.acknowledged, true);
+  t.is(result.operation_type, 'created');
+  t.is(result.message, 'Index created on default.users.email');
+});
+
+test('create_index_operation - should not change index with upsert when index exists with same options', async (t) => {
+  await create_index_operation('default', 'users', 'email', { unique: true });
+  
+  const result = await create_index_operation('default', 'users', 'email', { unique: true, upsert: true });
+  
+  t.is(result.acknowledged, true);
+  t.is(result.operation_type, 'unchanged');
+  t.is(result.message, 'Index already exists on default.users.email');
+});
+
+test('create_index_operation - should update index with upsert when index exists with different options', async (t) => {
+  await create_index_operation('default', 'users', 'email', { unique: false });
+  
+  const result = await create_index_operation('default', 'users', 'email', { unique: true, upsert: true });
+  
+  t.is(result.acknowledged, true);
+  t.is(result.operation_type, 'updated');
+  t.is(result.message, 'Index updated on default.users.email');
+});
+
+test('create_index_operation - should update sparse index option with upsert', async (t) => {
+  await create_index_operation('default', 'users', 'email', { sparse: false });
+  
+  const result = await create_index_operation('default', 'users', 'email', { sparse: true, upsert: true });
+  
+  t.is(result.acknowledged, true);
+  t.is(result.operation_type, 'updated');
+  t.is(result.message, 'Index updated on default.users.email');
+});
+
+test('create_index_operation - should handle upsert with existing data and unique constraint', async (t) => {
+  const main_db = get_database();
+  
+  // Insert test documents with duplicate values
+  main_db.put('default:users:1', JSON.stringify({ _id: '1', email: 'test@example.com' }));
+  main_db.put('default:users:2', JSON.stringify({ _id: '2', email: 'test@example.com' }));
+  
+  // Create non-unique index first
+  await create_index_operation('default', 'users', 'email', { unique: false });
+  
+  // Try to update to unique index - should fail due to duplicates
+  await t.throwsAsync(
+    () => create_index_operation('default', 'users', 'email', { unique: true, upsert: true }),
+    { message: /Duplicate value for unique index/ }
+  );
+});

package/tests/server/lib/operations/delete_one.test.js

@@ -0,0 +1,52 @@
+import test from 'ava';
+import sinon from 'sinon';
+import delete_one from '../../../../src/server/lib/operations/delete_one.js';
+import insert_one from '../../../../src/server/lib/operations/insert_one.js';
+import { initialize_database, get_database, cleanup_database } from '../../../../src/server/lib/query_engine.js';
+
+test.beforeEach(() => {
+  initialize_database('./test_data');
+  const db = get_database();
+  db.clearSync();
+});
+
+test.afterEach(async () => {
+  await cleanup_database();
+});
+
+test('delete_one - should delete a document by filter', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Alice' });
+  const result = await delete_one('default', 'users', { _id: inserted_id });
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 1);
+  const db = get_database();
+  const doc = db.get(`default:users:${inserted_id}`);
+  t.falsy(doc);
+});
+
+test('delete_one - should only delete one matching document', async (t) => {
+  await insert_one('default', 'users', { name: 'Bob', group: 'g1' });
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Carol', group: 'g1' });
+  const result = await delete_one('default', 'users', { group: 'g1' });
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 1);
+  const db = get_database();
+  const doc1 = db.get(`default:users:${inserted_id}`);
+  t.truthy(doc1);
+});
+
+test('delete_one - should return deleted_count 0 if no match', async (t) => {
+  await insert_one('default', 'users', { name: 'Dan' });
+  const result = await delete_one('default', 'users', { name: 'Nonexistent' });
+  t.true(result.acknowledged);
+  t.is(result.deleted_count, 0);
+});
+
+test('delete_one - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(() => delete_one('default', '', { name: 'Eve' }), { message: 'Collection name is required' });
+});
+
+test('delete_one - should throw if filter is not an object', async (t) => {
+  await t.throwsAsync(() => delete_one('default', 'users', null), { message: 'Filter must be a valid object' });
+  await t.throwsAsync(() => delete_one('default', 'users', 'not-an-object'), { message: 'Filter must be a valid object' });
+});

package/tests/server/lib/operations/drop_index.test.js

@@ -0,0 +1,72 @@
+import test from 'ava';
+import { initialize_database, get_database, cleanup_database } from '../../../../src/server/lib/query_engine.js';
+import { initialize_index_database, get_index_database, create_index, cleanup_index_database } from '../../../../src/server/lib/index_manager.js';
+import drop_index_operation from '../../../../src/server/lib/operations/drop_index.js';
+
+test.beforeEach(() => {
+  initialize_database('./test_data');
+  initialize_index_database();
+  
+  const main_db = get_database();
+  const index_db = get_index_database();
+  
+  try {
+    const main_range = main_db.getRange();
+    for (const { key } of main_range) {
+      try {
+        main_db.remove(key);
+      } catch (error) {
+        // Ignore errors during cleanup
+      }
+    }
+  } catch (error) {
+    // Ignore errors during cleanup
+  }
+  
+  try {
+    const index_range = index_db.getRange();
+    for (const { key } of index_range) {
+      try {
+        index_db.remove(key);
+      } catch (error) {
+        // Ignore errors during cleanup
+      }
+    }
+  } catch (error) {
+    // Ignore errors during cleanup
+  }
+});
+
+test.afterEach(async (t) => {
+  cleanup_index_database();
+  await cleanup_database();
+});
+
+test('drop_index_operation - should drop an index successfully', async (t) => {
+  await create_index('default', 'users', 'email');
+  
+  const result = await drop_index_operation('default', 'users', 'email');
+  
+  t.is(result.acknowledged, true);
+});
+
+test('drop_index_operation - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(
+    () => drop_index_operation('default', '', 'email'),
+    { message: 'Collection name is required' }
+  );
+});
+
+test('drop_index_operation - should throw if field name is missing', async (t) => {
+  await t.throwsAsync(
+    () => drop_index_operation('default', 'users', ''),
+    { message: 'Field name is required' }
+  );
+});
+
+test('drop_index_operation - should throw if index does not exist', async (t) => {
+  await t.throwsAsync(
+    () => drop_index_operation('default', 'users', 'email'),
+    { message: 'Index on default.users.email does not exist' }
+  );
+});

package/tests/server/lib/operations/find.test.js

@@ -0,0 +1,93 @@
+import test from 'ava';
+import sinon from 'sinon';
+import find from '../../../../src/server/lib/operations/find.js';
+import insert_one from '../../../../src/server/lib/operations/insert_one.js';
+import { initialize_database, get_database, cleanup_database } from '../../../../src/server/lib/query_engine.js';
+
+test.beforeEach(() => {
+  initialize_database('./test_data');
+  const db = get_database();
+  db.clearSync();
+});
+
+test.afterEach(async (t) => {
+  await cleanup_database();
+});
+
+test('find - should find multiple documents by filter', async (t) => {
+  await insert_one('default', 'users', { name: 'Alice', age: 25 });
+  await insert_one('default', 'users', { name: 'Bob', age: 25 });
+  await insert_one('default', 'users', { name: 'Carol', age: 30 });
+  const docs = await find('default', 'users', { age: 25 });
+  t.is(docs.length, 2);
+  t.true(docs.some(doc => doc.name === 'Alice'));
+  t.true(docs.some(doc => doc.name === 'Bob'));
+});
+
+test('find - should return empty array if no match', async (t) => {
+  await insert_one('default', 'users', { name: 'Dan' });
+  const docs = await find('default', 'users', { name: 'Nonexistent' });
+  t.deepEqual(docs, []);
+});
+
+test('find - should support all query operators', async (t) => {
+  await insert_one('default', 'users', { name: 'Eve', age: 20, tags: ['a'], email: 'eve@example.com' });
+  await insert_one('default', 'users', { name: 'Frank', age: 30, tags: ['b'], email: 'frank@example.com' });
+  t.is((await find('default', 'users', { age: { $eq: 20 } })).length, 1);
+  t.is((await find('default', 'users', { age: { $ne: 20 } })).length, 1);
+  t.is((await find('default', 'users', { age: { $gt: 25 } })).length, 1);
+  t.is((await find('default', 'users', { age: { $gte: 30 } })).length, 1);
+  t.is((await find('default', 'users', { age: { $lt: 25 } })).length, 1);
+  t.is((await find('default', 'users', { age: { $lte: 20 } })).length, 1);
+  t.is((await find('default', 'users', { name: { $in: ['Eve', 'X'] } })).length, 1);
+  t.is((await find('default', 'users', { name: { $nin: ['Frank'] } })).length, 1);
+  t.is((await find('default', 'users', { email: { $exists: true } })).length, 2);
+  t.is((await find('default', 'users', { phone: { $exists: false } })).length, 2);
+  t.is((await find('default', 'users', { email: { $regex: '^eve@' } })).length, 1);
+});
+
+test('find - should apply projection inclusion', async (t) => {
+  await insert_one('default', 'users', { name: 'Grace', age: 40, email: 'g@example.com' });
+  const docs = await find('default', 'users', { name: 'Grace' }, { projection: { name: 1, _id: 1 } });
+  t.is(docs.length, 1);
+  t.truthy(docs[0].name);
+  t.truthy(docs[0]._id);
+  t.falsy(docs[0].age);
+  t.falsy(docs[0].email);
+});
+
+test('find - should apply projection exclusion', async (t) => {
+  await insert_one('default', 'users', { name: 'Heidi', age: 50, email: 'h@example.com' });
+  const docs = await find('default', 'users', { name: 'Heidi' }, { projection: { age: 0, email: 0 } });
+  t.is(docs.length, 1);
+  t.truthy(docs[0].name);
+  t.truthy(docs[0]._id);
+  t.falsy(docs[0].age);
+  t.falsy(docs[0].email);
+});
+
+test('find - should sort documents ascending and descending', async (t) => {
+  await insert_one('default', 'users', { name: 'Ivan', age: 10 });
+  await insert_one('default', 'users', { name: 'Judy', age: 20 });
+  await insert_one('default', 'users', { name: 'Karl', age: 30 });
+  const asc = await find('default', 'users', {}, { sort: { age: 1 } });
+  t.deepEqual(asc.map(doc => doc.name), ['Ivan', 'Judy', 'Karl']);
+  const desc = await find('default', 'users', {}, { sort: { age: -1 } });
+  t.deepEqual(desc.map(doc => doc.name), ['Karl', 'Judy', 'Ivan']);
+});
+
+test('find - should limit and skip results', async (t) => {
+  await insert_one('default', 'users', { name: 'Liam', age: 1 });
+  await insert_one('default', 'users', { name: 'Mona', age: 2 });
+  await insert_one('default', 'users', { name: 'Nina', age: 3 });
+  const limited = await find('default', 'users', {}, { sort: { age: 1 }, limit: 2 });
+  t.is(limited.length, 2);
+  t.deepEqual(limited.map(doc => doc.name), ['Liam', 'Mona']);
+  const skipped = await find('default', 'users', {}, { sort: { age: 1 }, skip: 1 });
+  t.is(skipped.length, 2);
+  t.deepEqual(skipped.map(doc => doc.name), ['Mona', 'Nina']);
+});
+
+test('find - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(() => find('default', '', {}), { message: 'Collection name is required' });
+});

package/tests/server/lib/operations/find_one.test.js

@@ -0,0 +1,91 @@
+import test from 'ava';
+import sinon from 'sinon';
+import find_one from '../../../../src/server/lib/operations/find_one.js';
+import insert_one from '../../../../src/server/lib/operations/insert_one.js';
+import { initialize_database, get_database, cleanup_database } from '../../../../src/server/lib/query_engine.js';
+
+test.beforeEach(() => {
+  initialize_database('./test_data');
+  const db = get_database();
+  db.clearSync();
+});
+
+test.afterEach(async (t) => {
+  await cleanup_database();
+});
+
+test('find_one - should find a document by filter', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Alice', age: 25 });
+  const doc = await find_one('default', 'users', { _id: inserted_id });
+  t.truthy(doc);
+  t.is(doc.name, 'Alice');
+});
+
+test('find_one - should return null if no match', async (t) => {
+  await insert_one('default', 'users', { name: 'Bob' });
+  const doc = await find_one('default', 'users', { name: 'Nonexistent' });
+  t.is(doc, null);
+});
+
+test('find_one - should support $eq operator', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { age: 30 });
+  const doc = await find_one('default', 'users', { age: { $eq: 30 } });
+  t.truthy(doc);
+  t.is(doc._id, inserted_id);
+});
+
+test('find_one - should support $ne operator', async (t) => {
+  await insert_one('default', 'users', { name: 'Carol', age: 40 });
+  const doc = await find_one('default', 'users', { age: { $ne: 50 } });
+  t.truthy(doc);
+  t.is(doc.name, 'Carol');
+});
+
+test('find_one - should support $gt, $gte, $lt, $lte operators', async (t) => {
+  await insert_one('default', 'users', { name: 'Dan', age: 20 });
+  await insert_one('default', 'users', { name: 'Eve', age: 30 });
+  t.truthy(await find_one('default', 'users', { age: { $gt: 25 } }));
+  t.truthy(await find_one('default', 'users', { age: { $gte: 30 } }));
+  t.truthy(await find_one('default', 'users', { age: { $lt: 25 } }));
+  t.truthy(await find_one('default', 'users', { age: { $lte: 20 } }));
+});
+
+test('find_one - should support $in and $nin operators', async (t) => {
+  await insert_one('default', 'users', { name: 'Frank', role: 'admin' });
+  await insert_one('default', 'users', { name: 'Grace', role: 'user' });
+  t.truthy(await find_one('default', 'users', { role: { $in: ['admin', 'super'] } }));
+  t.truthy(await find_one('default', 'users', { role: { $nin: ['banned'] } }));
+});
+
+test('find_one - should support $exists operator', async (t) => {
+  await insert_one('default', 'users', { name: 'Heidi', email: 'h@example.com' });
+  t.truthy(await find_one('default', 'users', { email: { $exists: true } }));
+  t.truthy(await find_one('default', 'users', { phone: { $exists: false } }));
+});
+
+test('find_one - should support $regex operator', async (t) => {
+  await insert_one('default', 'users', { name: 'Ivan', email: 'ivan@example.com' });
+  t.truthy(await find_one('default', 'users', { email: { $regex: '^ivan@' } }));
+});
+
+test('find_one - should apply projection inclusion', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Judy', age: 50, email: 'j@example.com' });
+  const doc = await find_one('default', 'users', { _id: inserted_id }, { projection: { name: 1, _id: 1 } });
+  t.truthy(doc.name);
+  t.truthy(doc._id);
+  t.falsy(doc.age);
+  t.falsy(doc.email);
+});
+
+test('find_one - should apply projection exclusion', async (t) => {
+  const { inserted_id } = await insert_one('default', 'users', { name: 'Karl', age: 60, email: 'k@example.com' });
+  const doc = await find_one('default', 'users', { _id: inserted_id }, { projection: { age: 0, email: 0 } });
+  t.truthy(doc.name);
+  t.truthy(doc._id);
+  t.falsy(doc.age);
+  t.falsy(doc.email);
+});
+
+test('find_one - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(() => find_one('default', '', { name: 'Liam' }), { message: 'Collection name is required' });
+});

package/tests/server/lib/operations/get_indexes.test.js

@@ -0,0 +1,87 @@
+import test from 'ava';
+import { initialize_database, get_database, cleanup_database } from '../../../../src/server/lib/query_engine.js';
+import { initialize_index_database, get_index_database, create_index, cleanup_index_database } from '../../../../src/server/lib/index_manager.js';
+import get_indexes_operation from '../../../../src/server/lib/operations/get_indexes.js';
+
+test.beforeEach(() => {
+  initialize_database('./test_data');
+  initialize_index_database();
+  
+  const main_db = get_database();
+  const index_db = get_index_database();
+  
+  try {
+    const main_range = main_db.getRange();
+    for (const { key } of main_range) {
+      try {
+        main_db.remove(key);
+      } catch (error) {
+        // Ignore errors during cleanup
+      }
+    }
+  } catch (error) {
+    // Ignore errors during cleanup
+  }
+  
+  try {
+    const index_range = index_db.getRange();
+    for (const { key } of index_range) {
+      try {
+        index_db.remove(key);
+      } catch (error) {
+        // Ignore errors during cleanup
+      }
+    }
+  } catch (error) {
+    // Ignore errors during cleanup
+  }
+});
+
+test.afterEach(async (t) => {
+  cleanup_index_database();
+  await cleanup_database();
+});
+
+test('get_indexes_operation - should return empty array for collection with no indexes', async (t) => {
+  const result = await get_indexes_operation('default', 'users');
+  
+  t.is(result.acknowledged, true);
+  t.is(result.indexes.length, 0);
+});
+
+test('get_indexes_operation - should return all indexes for a collection', async (t) => {
+  await create_index('default', 'users', 'email');
+  await create_index('default', 'users', 'name');
+  
+  const result = await get_indexes_operation('default', 'users');
+  
+  t.is(result.acknowledged, true);
+  t.is(result.indexes.length, 2);
+  
+  const fields = result.indexes.map(index => index.field).sort();
+  t.deepEqual(fields, ['email', 'name']);
+});
+
+test('get_indexes_operation - should throw if collection name is missing', async (t) => {
+  await t.throwsAsync(
+    () => get_indexes_operation('default', ''),
+    { message: 'Collection name is required' }
+  );
+});
+
+test('get_indexes_operation - should return index metadata', async (t) => {
+  await create_index('default', 'users', 'email', { unique: true, sparse: false });
+  
+  const result = await get_indexes_operation('default', 'users');
+  
+  t.is(result.acknowledged, true);
+  t.is(result.indexes.length, 1);
+  
+  const index = result.indexes[0];
+  t.is(index.database, 'default');
+  t.is(index.collection, 'users');
+  t.is(index.field, 'email');
+  t.is(index.unique, true);
+  t.is(index.sparse, false);
+  t.truthy(index.created_at);
+});