smartdata/test/test.filters.ts

import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as smartmongo from '@push.rocks/smartmongo';
import * as smartunique from '@push.rocks/smartunique';
import * as smartdata from '../ts/index.js';

const { SmartdataDb, Collection, svDb, unI, index } = smartdata;

let smartmongoInstance: smartmongo.SmartMongo;
let testDb: smartdata.SmartdataDb;

// Define test document classes
@Collection(() => testDb)
class TestUser extends smartdata.SmartDataDbDoc<TestUser, TestUser> {
  @unI()
  public id: string = smartunique.shortId();

  @svDb()
  public name: string;

  @svDb()
  public age: number;

  @svDb()
  public email: string;

  @svDb()
  public roles: string[];

  @svDb()
  public tags: string[];

  @svDb()
  public status: 'active' | 'inactive' | 'pending';

  @svDb()
  public metadata: {
    lastLogin?: Date;
    loginCount?: number;
    preferences?: Record<string, any>;
  };

  @svDb()
  public scores: number[];

  constructor(data: Partial<TestUser> = {}) {
    super();
    Object.assign(this, data);
  }
}

@Collection(() => testDb)
class TestOrder extends smartdata.SmartDataDbDoc<TestOrder, TestOrder> {
  @unI()
  public id: string = smartunique.shortId();

  @svDb()
  public userId: string;

  @svDb()
  public items: Array<{
    product: string;
    quantity: number;
    price: number;
  }>;

  @svDb()
  public totalAmount: number;

  @svDb()
  public status: string;

  @svDb()
  public tags: string[];

  constructor(data: Partial<TestOrder> = {}) {
    super();
    Object.assign(this, data);
  }
}

// Setup and teardown
tap.test('should create a test database instance', async () => {
  smartmongoInstance = await smartmongo.SmartMongo.createAndStart();
  testDb = new smartdata.SmartdataDb(await smartmongoInstance.getMongoDescriptor());
  await testDb.init();
  expect(testDb).toBeInstanceOf(SmartdataDb);
});

tap.test('should create test data', async () => {
  // Create test users
  const users = [
    new TestUser({
      name: 'John Doe',
      age: 30,
      email: 'john@example.com',
      roles: ['admin', 'user'],
      tags: ['javascript', 'nodejs', 'mongodb'],
      status: 'active',
      metadata: { loginCount: 5, lastLogin: new Date() },
      scores: [85, 90, 78]
    }),
    new TestUser({
      name: 'Jane Smith',
      age: 25,
      email: 'jane@example.com',
      roles: ['user'],
      tags: ['python', 'mongodb'],
      status: 'active',
      metadata: { loginCount: 3 },
      scores: [92, 88, 95]
    }),
    new TestUser({
      name: 'Bob Johnson',
      age: 35,
      email: 'bob@example.com',
      roles: ['moderator', 'user'],
      tags: ['javascript', 'react', 'nodejs'],
      status: 'inactive',
      metadata: { loginCount: 0 },
      scores: [70, 75, 80]
    }),
    new TestUser({
      name: 'Alice Brown',
      age: 28,
      email: 'alice@example.com',
      roles: ['admin'],
      tags: ['typescript', 'angular', 'mongodb'],
      status: 'active',
      metadata: { loginCount: 10 },
      scores: [95, 98, 100]
    }),
    new TestUser({
      name: 'Charlie Wilson',
      age: 22,
      email: 'charlie@example.com',
      roles: ['user'],
      tags: ['golang', 'kubernetes'],
      status: 'pending',
      metadata: { loginCount: 1 },
      scores: [60, 65]
    })
  ];

  for (const user of users) {
    await user.save();
  }

  // Create test orders
  const orders = [
    new TestOrder({
      userId: users[0].id,
      items: [
        { product: 'laptop', quantity: 1, price: 1200 },
        { product: 'mouse', quantity: 2, price: 25 }
      ],
      totalAmount: 1250,
      status: 'completed',
      tags: ['electronics', 'priority']
    }),
    new TestOrder({
      userId: users[1].id,
      items: [
        { product: 'book', quantity: 3, price: 15 },
        { product: 'pen', quantity: 5, price: 2 }
      ],
      totalAmount: 55,
      status: 'pending',
      tags: ['stationery']
    }),
    new TestOrder({
      userId: users[0].id,
      items: [
        { product: 'laptop', quantity: 2, price: 1200 },
        { product: 'keyboard', quantity: 2, price: 80 }
      ],
      totalAmount: 2560,
      status: 'processing',
      tags: ['electronics', 'bulk']
    })
  ];

  for (const order of orders) {
    await order.save();
  }

  const savedUsers = await TestUser.getInstances({});
  const savedOrders = await TestOrder.getInstances({});
  expect(savedUsers.length).toEqual(5);
  expect(savedOrders.length).toEqual(3);
});

// ============= BASIC FILTER TESTS =============
tap.test('should filter by simple equality', async () => {
  const users = await TestUser.getInstances({ name: 'John Doe' });
  expect(users.length).toEqual(1);
  expect(users[0].name).toEqual('John Doe');
});

tap.test('should filter by multiple fields (implicit AND)', async () => {
  const users = await TestUser.getInstances({ 
    status: 'active',
    age: 30
  });
  expect(users.length).toEqual(1);
  expect(users[0].name).toEqual('John Doe');
});

tap.test('should filter by nested object fields', async () => {
  const users = await TestUser.getInstances({
    'metadata.loginCount': 5
  });
  expect(users.length).toEqual(1);
  expect(users[0].name).toEqual('John Doe');
});

// ============= COMPARISON OPERATOR TESTS =============
tap.test('should filter using $gt operator', async () => {
  const users = await TestUser.getInstances({
    age: { $gt: 30 }
  });
  expect(users.length).toEqual(1);
  expect(users[0].name).toEqual('Bob Johnson');
});

tap.test('should filter using $gte operator', async () => {
  const users = await TestUser.getInstances({
    age: { $gte: 30 }
  });
  expect(users.length).toEqual(2);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Bob Johnson', 'John Doe']);
});

tap.test('should filter using $lt operator', async () => {
  const users = await TestUser.getInstances({
    age: { $lt: 25 }
  });
  expect(users.length).toEqual(1);
  expect(users[0].name).toEqual('Charlie Wilson');
});

tap.test('should filter using $lte operator', async () => {
  const users = await TestUser.getInstances({
    age: { $lte: 25 }
  });
  expect(users.length).toEqual(2);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Charlie Wilson', 'Jane Smith']);
});

tap.test('should filter using $ne operator', async () => {
  const users = await TestUser.getInstances({
    status: { $ne: 'active' }
  });
  expect(users.length).toEqual(2);
  const statuses = users.map(u => u.status).sort();
  expect(statuses).toEqual(['inactive', 'pending']);
});

tap.test('should filter using multiple comparison operators', async () => {
  const users = await TestUser.getInstances({
    age: { $gte: 25, $lt: 30 }
  });
  expect(users.length).toEqual(2);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Alice Brown', 'Jane Smith']);
});

// ============= ARRAY OPERATOR TESTS =============
tap.test('should filter using $in operator', async () => {
  const users = await TestUser.getInstances({
    status: { $in: ['active', 'pending'] }
  });
  expect(users.length).toEqual(4);
  expect(users.every(u => ['active', 'pending'].includes(u.status))).toEqual(true);
});

tap.test('should filter arrays using $in operator', async () => {
  const users = await TestUser.getInstances({
    roles: { $in: ['admin'] }
  });
  expect(users.length).toEqual(2);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Alice Brown', 'John Doe']);
});

tap.test('should filter using $nin operator', async () => {
  const users = await TestUser.getInstances({
    status: { $nin: ['inactive', 'pending'] }
  });
  expect(users.length).toEqual(3);
  expect(users.every(u => u.status === 'active')).toEqual(true);
});

tap.test('should filter arrays using $all operator', async () => {
  const users = await TestUser.getInstances({
    tags: { $all: ['javascript', 'nodejs'] }
  });
  expect(users.length).toEqual(2);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Bob Johnson', 'John Doe']);
});

tap.test('should filter arrays using $size operator', async () => {
  const users = await TestUser.getInstances({
    scores: { $size: 2 }
  });
  expect(users.length).toEqual(1);
  expect(users[0].name).toEqual('Charlie Wilson');
});

tap.test('should filter arrays using $elemMatch operator', async () => {
  const orders = await TestOrder.getInstances({
    items: {
      $elemMatch: {
        product: 'laptop',
        quantity: { $gte: 2 }
      }
    }
  });
  expect(orders.length).toEqual(1);
  expect(orders[0].totalAmount).toEqual(2560);
});

tap.test('should filter using $elemMatch with single condition', async () => {
  const orders = await TestOrder.getInstances({
    items: {
      $elemMatch: {
        price: { $gt: 100 }
      }
    }
  });
  expect(orders.length).toEqual(2);
  expect(orders.every(o => o.items.some(i => i.price > 100))).toEqual(true);
});

// ============= LOGICAL OPERATOR TESTS =============
tap.test('should filter using $or operator', async () => {
  const users = await TestUser.getInstances({
    $or: [
      { age: { $lt: 25 } },
      { status: 'inactive' }
    ]
  });
  expect(users.length).toEqual(2);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Bob Johnson', 'Charlie Wilson']);
});

tap.test('should filter using $and operator', async () => {
  const users = await TestUser.getInstances({
    $and: [
      { status: 'active' },
      { age: { $gte: 28 } }
    ]
  });
  expect(users.length).toEqual(2);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Alice Brown', 'John Doe']);
});

tap.test('should filter using $nor operator', async () => {
  const users = await TestUser.getInstances({
    $nor: [
      { status: 'inactive' },
      { age: { $lt: 25 } }
    ]
  });
  expect(users.length).toEqual(3);
  expect(users.every(u => u.status !== 'inactive' && u.age >= 25)).toEqual(true);
});

tap.test('should filter using nested logical operators', async () => {
  const users = await TestUser.getInstances({
    $or: [
      {
        $and: [
          { status: 'active' },
          { roles: { $in: ['admin'] } }
        ]
      },
      { age: { $lt: 23 } }
    ]
  });
  expect(users.length).toEqual(3);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Alice Brown', 'Charlie Wilson', 'John Doe']);
});

// ============= ELEMENT OPERATOR TESTS =============
tap.test('should filter using $exists operator', async () => {
  const users = await TestUser.getInstances({
    'metadata.lastLogin': { $exists: true }
  });
  expect(users.length).toEqual(1);
  expect(users[0].name).toEqual('John Doe');
});

tap.test('should filter using $exists false', async () => {
  const users = await TestUser.getInstances({
    'metadata.preferences': { $exists: false }
  });
  expect(users.length).toEqual(5);
});

// ============= COMPLEX FILTER TESTS =============
tap.test('should handle complex nested filters', async () => {
  const users = await TestUser.getInstances({
    $and: [
      { status: 'active' },
      {
        $or: [
          { age: { $gte: 30 } },
          { roles: { $all: ['admin'] } }
        ]
      },
      { tags: { $in: ['mongodb'] } }
    ]
  });
  expect(users.length).toEqual(2);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Alice Brown', 'John Doe']);
});

tap.test('should combine multiple operator types', async () => {
  const orders = await TestOrder.getInstances({
    $and: [
      { totalAmount: { $gte: 100 } },
      { status: { $in: ['completed', 'processing'] } },
      { tags: { $in: ['electronics'] } }
    ]
  });
  expect(orders.length).toEqual(2);
  expect(orders.every(o => o.totalAmount >= 100)).toEqual(true);
});

// ============= ERROR HANDLING TESTS =============
tap.test('should throw error for $where operator', async () => {
  let error: Error | null = null;
  try {
    await TestUser.getInstances({
      $where: 'this.age > 25'
    });
  } catch (e) {
    error = e as Error;
  }
  expect(error).toBeTruthy();
  expect(error?.message).toMatch(/\$where.*not allowed/);
});

tap.test('should throw error for invalid $in value', async () => {
  let error: Error | null = null;
  try {
    await TestUser.getInstances({
      status: { $in: 'active' as any } // Should be an array
    });
  } catch (e) {
    error = e as Error;
  }
  expect(error).toBeTruthy();
  expect(error?.message).toMatch(/\$in.*requires.*array/);
});

tap.test('should throw error for invalid $size value', async () => {
  let error: Error | null = null;
  try {
    await TestUser.getInstances({
      scores: { $size: '3' as any } // Should be a number
    });
  } catch (e) {
    error = e as Error;
  }
  expect(error).toBeTruthy();
  expect(error?.message).toMatch(/\$size.*requires.*numeric/);
});

tap.test('should throw error for dots in field names', async () => {
  let error: Error | null = null;
  try {
    await TestUser.getInstances({
      'some.nested.field': { 'invalid.key': 'value' }
    });
  } catch (e) {
    error = e as Error;
  }
  expect(error).toBeTruthy();
  expect(error?.message).toMatch(/keys cannot contain dots/);
});

// ============= EDGE CASE TESTS =============
tap.test('should handle empty filter (return all)', async () => {
  const users = await TestUser.getInstances({});
  expect(users.length).toEqual(5);
});

tap.test('should handle null values in filter', async () => {
  // First, create a user with null email
  const nullUser = new TestUser({
    name: 'Null User',
    age: 40,
    email: null as any,
    roles: ['user'],
    tags: [],
    status: 'active',
    metadata: {},
    scores: []
  });
  await nullUser.save();

  const users = await TestUser.getInstances({ email: null });
  expect(users.length).toEqual(1);
  expect(users[0].name).toEqual('Null User');

  // Clean up
  await nullUser.delete();
});

tap.test('should handle arrays as direct equality match', async () => {
  // This tests that arrays without operators are treated as equality matches
  const users = await TestUser.getInstances({
    roles: ['user'] // Exact match for array
  });
  expect(users.length).toEqual(2);  // Both Jane and Charlie have exactly ['user']
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Charlie Wilson', 'Jane Smith']);
});

tap.test('should handle regex operator', async () => {
  const users = await TestUser.getInstances({
    name: { $regex: '^J', $options: 'i' }
  });
  expect(users.length).toEqual(2);
  const names = users.map(u => u.name).sort();
  expect(names).toEqual(['Jane Smith', 'John Doe']);
});

tap.test('should handle unknown operators by letting MongoDB reject them', async () => {
  // Unknown operators should be passed through to MongoDB, which will reject them
  let error: Error | null = null;
  
  try {
    await TestUser.getInstances({
      age: { $unknownOp: 30 } as any
    });
  } catch (e) {
    error = e as Error;
  }

  expect(error).toBeTruthy();
  expect(error?.message).toMatch(/unknown operator.*\$unknownOp/);
});

// ============= PERFORMANCE TESTS =============
tap.test('should efficiently filter large result sets', async () => {
  // Create many test documents
  const manyUsers = [];
  for (let i = 0; i < 100; i++) {
    manyUsers.push(new TestUser({
      name: `User ${i}`,
      age: 20 + (i % 40),
      email: `user${i}@example.com`,
      roles: i % 3 === 0 ? ['admin'] : ['user'],
      tags: i % 2 === 0 ? ['even', 'test'] : ['odd', 'test'],
      status: i % 4 === 0 ? 'inactive' : 'active',
      metadata: { loginCount: i },
      scores: [i, i + 10, i + 20]
    }));
  }

  // Save in batches for efficiency
  for (const user of manyUsers) {
    await user.save();
  }

  // Complex filter that should still be fast
  const startTime = Date.now();
  const filtered = await TestUser.getInstances({
    $and: [
      { age: { $gte: 30, $lt: 40 } },
      { status: 'active' },
      { tags: { $in: ['even'] } },
      { 'metadata.loginCount': { $gte: 20 } }
    ]
  });
  const duration = Date.now() - startTime;

  console.log(`Complex filter on 100+ documents took ${duration}ms`);
  expect(duration).toBeLessThan(1000); // Should complete in under 1 second
  expect(filtered.length).toBeGreaterThan(0);

  // Clean up
  for (const user of manyUsers) {
    await user.delete();
  }
});

// ============= CLEANUP =============
tap.test('should clean up test database', async () => {
  await testDb.mongoDb.dropDatabase();
  await testDb.close();
  await smartmongoInstance.stop();
});

export default tap.start();