uranio 1.3.0 → 1.4.0

package/.uranio/package.json

@@ -33,7 +33,7 @@
     "mongodb": "^7.1.0",
     "mysql2": "^3.17.5",
     "pg": "^8.18.0",
-    "uranio": "1.3.0",
+    "uranio": "1.4.0",
     "w3i": "^0.3.2"
   }
 }

package/.uranio/src/atom/mongodb.ts

@@ -157,6 +157,14 @@ export class MongoDBAtomClient<S extends atom_types.mongodb_atom> {
     }
     return (response as S);
   }
+
+  public async countAtoms({where}: {where?: where_types.Where<S>}): Promise<number> {
+    where = _instance_object_id(where);
+    const count = await this.collection.countDocuments(
+      where as mongodb.Filter<S>
+    );
+    return count;
+  }
 }
 
 // type StringId<T extends unknown> = T extends {_id: any}

package/.uranio/src/atom/mysql.ts

@@ -106,4 +106,17 @@ export class MySQLAtomClient<S extends atom_types.mysql_atom> {
     const response = await this.client.exe(query);
     return response;
   }
+
+  public async countAtoms(where?: where_types.Where<S>): Promise<number> {
+    const query = sql.build.select({
+      projection: ['COUNT(*) as count'],
+      table: this.name,
+      where,
+    });
+    const [rows] = await this.client.exe(query);
+    if (Array.isArray(rows) && rows[0]) {
+      return (rows[0] as any).count || 0;
+    }
+    return 0;
+  }
 }

package/.uranio/src/atom/postgresql.ts

@@ -106,4 +106,17 @@ export class PostgreSQLAtomClient<S extends atom_types.postgresql_atom> {
     const response = await this.client.exe(query);
     return response;
   }
+
+  public async countAtoms(where?: where_types.Where<S>): Promise<number> {
+    const query = sql.build.select({
+      projection: ['COUNT(*) as count'],
+      table: this.name,
+      where,
+    });
+    const [rows] = await this.client.exe(query);
+    if (Array.isArray(rows) && rows[0]) {
+      return (rows[0] as any).count || 0;
+    }
+    return 0;
+  }
 }

package/.uranio/tests/unit/atom/mongodb.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Unit tests for MongoDB Atom Client
+ * Tests atom methods with mocked database connections
+ */
+
+import {MongoDBAtomClient} from '../../../src/atom/mongodb';
+import {ObjectId} from 'mongodb';
+
+type TestAtom = {
+  _id: ObjectId;
+  name: string;
+  age: number;
+  email: string;
+};
+
+describe('MongoDBAtomClient', () => {
+  let mockDb: any;
+  let mockCollection: any;
+  let atomClient: MongoDBAtomClient<TestAtom>;
+
+  beforeEach(() => {
+    mockCollection = {
+      countDocuments: jest.fn(),
+      findOne: jest.fn(),
+      find: jest.fn(),
+      insertOne: jest.fn(),
+      insertMany: jest.fn(),
+      updateOne: jest.fn(),
+      updateMany: jest.fn(),
+      deleteOne: jest.fn(),
+      deleteMany: jest.fn(),
+      aggregate: jest.fn(),
+    };
+
+    mockDb = {
+      collection: jest.fn().mockReturnValue(mockCollection),
+    };
+
+    atomClient = new MongoDBAtomClient(mockDb, 'test_collection');
+  });
+
+  describe('countAtoms', () => {
+    it('should count all atoms without WHERE clause', async () => {
+      mockCollection.countDocuments.mockResolvedValue(42);
+
+      const count = await atomClient.countAtoms({});
+
+      expect(count).toBe(42);
+      expect(mockCollection.countDocuments).toHaveBeenCalledTimes(1);
+      expect(mockCollection.countDocuments).toHaveBeenCalledWith(undefined);
+    });
+
+    it('should count atoms with simple WHERE clause', async () => {
+      mockCollection.countDocuments.mockResolvedValue(10);
+
+      const count = await atomClient.countAtoms({where: {age: 25}});
+
+      expect(count).toBe(10);
+      expect(mockCollection.countDocuments).toHaveBeenCalledTimes(1);
+      expect(mockCollection.countDocuments).toHaveBeenCalledWith({age: 25});
+    });
+
+    it('should count atoms with comparison operators', async () => {
+      mockCollection.countDocuments.mockResolvedValue(5);
+
+      const count = await atomClient.countAtoms({where: {age: {$gte: 18}}});
+
+      expect(count).toBe(5);
+      expect(mockCollection.countDocuments).toHaveBeenCalledTimes(1);
+      expect(mockCollection.countDocuments).toHaveBeenCalledWith({age: {$gte: 18}});
+    });
+
+    it('should count atoms with multiple WHERE conditions', async () => {
+      mockCollection.countDocuments.mockResolvedValue(3);
+
+      const count = await atomClient.countAtoms({
+        where: {
+          age: {$gte: 18},
+          name: 'John',
+        },
+      });
+
+      expect(count).toBe(3);
+      expect(mockCollection.countDocuments).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return 0 when no documents match', async () => {
+      mockCollection.countDocuments.mockResolvedValue(0);
+
+      const count = await atomClient.countAtoms({where: {name: 'NonExistent'}});
+
+      expect(count).toBe(0);
+    });
+
+    it('should count atoms with $in operator', async () => {
+      mockCollection.countDocuments.mockResolvedValue(15);
+
+      const count = await atomClient.countAtoms({
+        where: {
+          name: {$in: ['John', 'Jane', 'Bob']},
+        },
+      });
+
+      expect(count).toBe(15);
+      expect(mockCollection.countDocuments).toHaveBeenCalledTimes(1);
+    });
+
+    it('should count atoms with $or operator', async () => {
+      mockCollection.countDocuments.mockResolvedValue(20);
+
+      const count = await atomClient.countAtoms({
+        where: {
+          $or: [{age: {$lt: 18}}, {age: {$gt: 65}}],
+        },
+      });
+
+      expect(count).toBe(20);
+      expect(mockCollection.countDocuments).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle large counts', async () => {
+      mockCollection.countDocuments.mockResolvedValue(1000000);
+
+      const count = await atomClient.countAtoms({});
+
+      expect(count).toBe(1000000);
+    });
+
+    it('should convert string _id to ObjectId', async () => {
+      const testId = '507f1f77bcf86cd799439011';
+      mockCollection.countDocuments.mockResolvedValue(1);
+
+      const count = await atomClient.countAtoms({
+        where: {_id: testId as any},
+      });
+
+      expect(count).toBe(1);
+      expect(mockCollection.countDocuments).toHaveBeenCalledTimes(1);
+      const callArgs = mockCollection.countDocuments.mock.calls[0][0];
+      expect(callArgs._id).toBeInstanceOf(ObjectId);
+      expect(callArgs._id.toString()).toBe(testId);
+    });
+
+    it('should handle ObjectId in nested where conditions', async () => {
+      const testId = '507f1f77bcf86cd799439011';
+      mockCollection.countDocuments.mockResolvedValue(5);
+
+      const count = await atomClient.countAtoms({
+        where: {
+          $or: [{_id: testId as any}, {name: 'John'}],
+        },
+      });
+
+      expect(count).toBe(5);
+      expect(mockCollection.countDocuments).toHaveBeenCalledTimes(1);
+    });
+
+    it('should count with empty where object', async () => {
+      mockCollection.countDocuments.mockResolvedValue(100);
+
+      const count = await atomClient.countAtoms({where: {}});
+
+      expect(count).toBe(100);
+      expect(mockCollection.countDocuments).toHaveBeenCalledWith({});
+    });
+  });
+});

package/.uranio/tests/unit/atom/mysql.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Unit tests for MySQL Atom Client
+ * Tests atom methods with mocked database connections
+ */
+
+import {MySQLAtomClient} from '../../../src/atom/mysql';
+import {MySQLClient} from '../../../src/client/mysql';
+
+type TestAtom = {
+  _id: string;
+  name: string;
+  age: number;
+  email: string;
+};
+
+describe('MySQLAtomClient', () => {
+  let mockClient: MySQLClient;
+  let atomClient: MySQLAtomClient<TestAtom>;
+
+  beforeEach(() => {
+    mockClient = {
+      exe: jest.fn(),
+    } as any;
+    atomClient = new MySQLAtomClient(mockClient, 'test_table');
+  });
+
+  describe('countAtoms', () => {
+    it('should count all atoms without WHERE clause', async () => {
+      const mockResult = [[{count: 42}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms();
+
+      expect(count).toBe(42);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+      const callArgs = (mockClient.exe as jest.Mock).mock.calls[0][0];
+      const {sql} = callArgs.mysql();
+      expect(sql).toContain('SELECT COUNT(*) as count');
+      expect(sql).toContain('FROM `test_table`');
+      expect(sql).not.toContain('WHERE');
+    });
+
+    it('should count atoms with simple WHERE clause', async () => {
+      const mockResult = [[{count: 10}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({age: 25});
+
+      expect(count).toBe(10);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+      const callArgs = (mockClient.exe as jest.Mock).mock.calls[0][0];
+      const {sql} = callArgs.mysql();
+      expect(sql).toContain('SELECT COUNT(*) as count');
+      expect(sql).toContain('WHERE');
+    });
+
+    it('should count atoms with comparison operators', async () => {
+      const mockResult = [[{count: 5}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({age: {$gte: 18}});
+
+      expect(count).toBe(5);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should count atoms with multiple WHERE conditions', async () => {
+      const mockResult = [[{count: 3}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({
+        age: {$gte: 18},
+        name: 'John',
+      });
+
+      expect(count).toBe(3);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return 0 when no rows match', async () => {
+      const mockResult = [[{count: 0}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({name: 'NonExistent'});
+
+      expect(count).toBe(0);
+    });
+
+    it('should return 0 when result is empty', async () => {
+      const mockResult = [[], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms();
+
+      expect(count).toBe(0);
+    });
+
+    it('should return 0 when count is null', async () => {
+      const mockResult = [[{count: null}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms();
+
+      expect(count).toBe(0);
+    });
+
+    it('should count atoms with $in operator', async () => {
+      const mockResult = [[{count: 15}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({
+        name: {$in: ['John', 'Jane', 'Bob']},
+      });
+
+      expect(count).toBe(15);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should count atoms with $or operator', async () => {
+      const mockResult = [[{count: 20}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({
+        $or: [{age: {$lt: 18}}, {age: {$gt: 65}}],
+      });
+
+      expect(count).toBe(20);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle large counts', async () => {
+      const mockResult = [[{count: 1000000}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms();
+
+      expect(count).toBe(1000000);
+    });
+  });
+});

package/.uranio/tests/unit/atom/postgresql.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Unit tests for PostgreSQL Atom Client
+ * Tests atom methods with mocked database connections
+ */
+
+import {PostgreSQLAtomClient} from '../../../src/atom/postgresql';
+import {PostgreSQLClient} from '../../../src/client/postgresql';
+
+type TestAtom = {
+  _id: string;
+  name: string;
+  age: number;
+  email: string;
+};
+
+describe('PostgreSQLAtomClient', () => {
+  let mockClient: PostgreSQLClient;
+  let atomClient: PostgreSQLAtomClient<TestAtom>;
+
+  beforeEach(() => {
+    mockClient = {
+      exe: jest.fn(),
+    } as any;
+    atomClient = new PostgreSQLAtomClient(mockClient, 'test_table');
+  });
+
+  describe('countAtoms', () => {
+    it('should count all atoms without WHERE clause', async () => {
+      const mockResult = [[{count: 42}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms();
+
+      expect(count).toBe(42);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+      const callArgs = (mockClient.exe as jest.Mock).mock.calls[0][0];
+      const {sql} = callArgs.postgres();
+      expect(sql).toContain('SELECT COUNT(*) as count');
+      expect(sql).toContain('FROM `test_table`');
+      expect(sql).not.toContain('WHERE');
+    });
+
+    it('should count atoms with simple WHERE clause', async () => {
+      const mockResult = [[{count: 10}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({age: 25});
+
+      expect(count).toBe(10);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+      const callArgs = (mockClient.exe as jest.Mock).mock.calls[0][0];
+      const {sql} = callArgs.postgres();
+      expect(sql).toContain('SELECT COUNT(*) as count');
+      expect(sql).toContain('WHERE');
+    });
+
+    it('should count atoms with comparison operators', async () => {
+      const mockResult = [[{count: 5}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({age: {$gte: 18}});
+
+      expect(count).toBe(5);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should count atoms with multiple WHERE conditions', async () => {
+      const mockResult = [[{count: 3}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({
+        age: {$gte: 18},
+        name: 'John',
+      });
+
+      expect(count).toBe(3);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return 0 when no rows match', async () => {
+      const mockResult = [[{count: 0}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({name: 'NonExistent'});
+
+      expect(count).toBe(0);
+    });
+
+    it('should return 0 when result is empty', async () => {
+      const mockResult = [[], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms();
+
+      expect(count).toBe(0);
+    });
+
+    it('should return 0 when count is null', async () => {
+      const mockResult = [[{count: null}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms();
+
+      expect(count).toBe(0);
+    });
+
+    it('should count atoms with $in operator', async () => {
+      const mockResult = [[{count: 15}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({
+        name: {$in: ['John', 'Jane', 'Bob']},
+      });
+
+      expect(count).toBe(15);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should count atoms with $or operator', async () => {
+      const mockResult = [[{count: 20}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms({
+        $or: [{age: {$lt: 18}}, {age: {$gt: 65}}],
+      });
+
+      expect(count).toBe(20);
+      expect(mockClient.exe).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle large counts', async () => {
+      const mockResult = [[{count: 1000000}], []];
+      (mockClient.exe as jest.Mock).mockResolvedValue(mockResult);
+
+      const count = await atomClient.countAtoms();
+
+      expect(count).toBe(1000000);
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uranio",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Uranio is a type-safe ODM for MongoDB",
   "main": "dist/index.js",
   "repository": {