@onchaindb/sdk 2.3.0 → 4.0.0

package/src/tests/model.test.ts

@@ -0,0 +1,885 @@
+/**
+ * ModelDelegate vs QueryBuilder — getQueryRequest() parity
+ *
+ * Each test runs both code paths (Prisma-like facade and raw QueryBuilder)
+ * through a CapturingHttpClient that records the request body sent to the server.
+ * We then assert they are identical.
+ */
+
+import { ModelDelegate } from '../model';
+import { QueryBuilder, FieldConditionBuilder, LogicalOperator } from '../query-sdk';
+import { OnDBClient } from '../client';
+
+const APP = 'test_app';
+const URL = 'http://localhost:9092';
+const COLLECTION = 'users';
+
+// ── Capturing HTTP client ─────────────────────────────────────────────────────
+
+class CapturingHttpClient {
+    lastRequest: any = null;
+
+    async post(_url: string, data: any, _headers?: any) {
+        this.lastRequest = data;
+        return { status: 200, data: { records: [], total: 0, page: 0, limit: 10 } };
+    }
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeSetup(collection = COLLECTION) {
+    const http = new CapturingHttpClient();
+
+    // Minimal OnDBClient mock — only what ModelDelegate needs
+    const client = {
+        queryBuilder: () => new QueryBuilder(http, URL, APP),
+        store: jest.fn(),
+    } as unknown as OnDBClient;
+
+    const delegate = new ModelDelegate(client, collection);
+
+    // Convenience: raw QB bound to the same http client + collection
+    const qb = () => new QueryBuilder(http, URL, APP).collection(collection);
+
+    return { http, delegate, qb };
+}
+
+// ── findMany ──────────────────────────────────────────────────────────────────
+
+describe('findMany where operators', () => {
+
+    test('shorthand equality: { field: value }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { name: 'Alice' } });
+        const prismaReq = http.lastRequest;
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('name').equals('Alice'))
+            .getQueryRequest();
+
+        expect(prismaReq).toEqual(qbReq);
+    });
+
+    test('{ field: { equals } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { name: { equals: 'Alice' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('name').equals('Alice'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { not } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { status: { not: 'banned' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('status').notEquals('banned'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { gt } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { age: { gt: 18 } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('age').greaterThan(18))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { gte } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { age: { gte: 18 } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('age').greaterThanOrEqual(18))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { lt } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { score: { lt: 100 } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('score').lessThan(100))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { lte } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { score: { lte: 100 } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('score').lessThanOrEqual(100))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { contains } }', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ where: { title: { contains: 'typescript' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('title').contains('typescript'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { startsWith } }', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ where: { slug: { startsWith: 'hello' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('slug').startsWith('hello'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { endsWith } }', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ where: { slug: { endsWith: 'world' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('slug').endsWith('world'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { in } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { status: { in: ['active', 'pending'] } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('status').in(['active', 'pending']))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { notIn } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { status: { notIn: ['banned', 'deleted'] } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('status').notIn(['banned', 'deleted']))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { isNotNull: true } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { deletedAt: { isNotNull: true } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('deletedAt').isNotNull())
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { exists: true } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { avatar: { exists: true } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('avatar').exists())
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { exists: false } } → notExists', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { avatar: { exists: false } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('avatar').notExists())
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { between } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { age: { between: { from: 18, to: 65 } } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('age').between(18, 65))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { inDataset } } (case-sensitive)', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { role: { inDataset: ['Admin', 'SuperUser'] } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('role').inDataset(['Admin', 'SuperUser']))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { containsCaseInsensitive } }', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ where: { title: { containsCaseInsensitive: 'rust' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('title').includesCaseInsensitive('rust'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { startsWithCaseInsensitive } }', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ where: { slug: { startsWithCaseInsensitive: 'Hello' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('slug').startsWithCaseInsensitive('Hello'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { endsWithCaseInsensitive } }', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ where: { slug: { endsWithCaseInsensitive: 'World' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('slug').endsWithCaseInsensitive('World'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { regex } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { email: { regex: '^admin@' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('email').regExpMatches('^admin@'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { isLocalIp: true } }', async () => {
+        const { http, delegate, qb } = makeSetup('logs');
+
+        await delegate.findMany({ where: { ip: { isLocalIp: true } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('ip').isLocalIp())
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { isExternalIp: true } }', async () => {
+        const { http, delegate, qb } = makeSetup('logs');
+
+        await delegate.findMany({ where: { ip: { isExternalIp: true } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('ip').isExternalIp())
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { inCountry } }', async () => {
+        const { http, delegate, qb } = makeSetup('logs');
+
+        await delegate.findMany({ where: { ip: { inCountry: 'US' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('ip').inCountry('US'))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { cidr } }', async () => {
+        const { http, delegate, qb } = makeSetup('logs');
+
+        await delegate.findMany({ where: { ip: { cidr: ['10.0.0.0/8', '192.168.0.0/16'] } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('ip').cidr(['10.0.0.0/8', '192.168.0.0/16']))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { keywords } }', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ where: { content: { keywords: ['blockchain', 'celestia'] } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('content').keywords(['blockchain', 'celestia']))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: { b64 } }', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { payload: { b64: 'aGVsbG8=' } } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('payload').b64('aGVsbG8='))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('{ field: null } → isNull', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { deletedAt: null } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('deletedAt').isNull())
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+});
+
+// ── findMany — logical operators ──────────────────────────────────────────────
+
+describe('findMany logical operators', () => {
+
+    test('multiple top-level fields → implicit AND', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { active: true, role: 'admin' } });
+
+        const qbReq = qb()
+            .find(() => LogicalOperator.And([
+                new FieldConditionBuilder('active').equals(true),
+                new FieldConditionBuilder('role').equals('admin'),
+            ]))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('AND: [...]', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({
+            where: { AND: [{ age: { gte: 18 } }, { age: { lt: 65 } }] },
+        });
+
+        const qbReq = qb()
+            .find(() => LogicalOperator.And([
+                new FieldConditionBuilder('age').greaterThanOrEqual(18),
+                new FieldConditionBuilder('age').lessThan(65),
+            ]))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('OR: [...]', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({
+            where: { OR: [{ role: 'admin' }, { role: 'superuser' }] },
+        });
+
+        const qbReq = qb()
+            .find(() => LogicalOperator.Or([
+                new FieldConditionBuilder('role').equals('admin'),
+                new FieldConditionBuilder('role').equals('superuser'),
+            ]))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('NOT: [...]', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({
+            where: { NOT: [{ status: 'banned' }] },
+        });
+
+        const qbReq = qb()
+            .find(() => LogicalOperator.Not([
+                new FieldConditionBuilder('status').equals('banned'),
+            ]))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+});
+
+// ── findMany — pagination + sorting ──────────────────────────────────────────
+
+describe('findMany pagination and sorting', () => {
+
+    test('take + skip → limit + offset', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ take: 20, skip: 40 });
+
+        const qbReq = qb().limit(20).offset(40).getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('orderBy asc', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ orderBy: { createdAt: 'asc' } });
+
+        const qbReq = qb().sortBy('createdAt', 'asc').getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('orderBy desc', async () => {
+        const { http, delegate, qb } = makeSetup('posts');
+
+        await delegate.findMany({ orderBy: { createdAt: 'desc' } });
+
+        const qbReq = qb().sortBy('createdAt', 'desc').getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('where + take + skip + orderBy combined', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({
+            where: { active: true },
+            orderBy: { name: 'asc' },
+            take: 10,
+            skip: 5,
+        });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('active').equals(true))
+            .sortBy('name', 'asc')
+            .limit(10)
+            .offset(5)
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+});
+
+// ── findMany — select ─────────────────────────────────────────────────────────
+
+describe('findMany select', () => {
+
+    test('select specific fields', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ select: { id: true, name: true, email: true } });
+
+        const qbReq = qb().selectFields(['id', 'name', 'email']).getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+});
+
+// ── findFirst ─────────────────────────────────────────────────────────────────
+
+describe('findFirst', () => {
+
+    test('findFirst = findMany with take: 1', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findFirst({ where: { email: 'alice@example.com' } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('email').equals('alice@example.com'))
+            .limit(1)
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+});
+
+// ── findUnique ────────────────────────────────────────────────────────────────
+
+describe('findUnique', () => {
+
+    test('findUnique = findFirst (take: 1)', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findUnique({ where: { id: 'user-123' } });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('id').equals('user-123'))
+            .limit(1)
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+});
+
+// ── excludeDeleted ────────────────────────────────────────────────────────────
+
+describe('excludeDeleted', () => {
+
+    test('true → ANDs notExists("deletedAt") with where conditions', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { active: true }, excludeDeleted: true });
+
+        const qbReq = qb()
+            .find(() => LogicalOperator.And([
+                new FieldConditionBuilder('active').equals(true),
+                new FieldConditionBuilder('deletedAt').notExists(),
+            ]))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('custom string key → notExists(key)', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { active: true }, excludeDeleted: 'removedAt' });
+
+        const qbReq = qb()
+            .find(() => LogicalOperator.And([
+                new FieldConditionBuilder('active').equals(true),
+                new FieldConditionBuilder('removedAt').notExists(),
+            ]))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('with no where — only notExists condition', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ excludeDeleted: true });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('deletedAt').notExists())
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('false / undefined → no deleted filter applied', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findMany({ where: { active: true }, excludeDeleted: false });
+
+        const qbReq = qb()
+            .find(() => new FieldConditionBuilder('active').equals(true))
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('propagates to findFirst via take: 1', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findFirst({ where: { email: 'a@b.com' }, excludeDeleted: true });
+
+        const qbReq = qb()
+            .find(() => LogicalOperator.And([
+                new FieldConditionBuilder('email').equals('a@b.com'),
+                new FieldConditionBuilder('deletedAt').notExists(),
+            ]))
+            .limit(1)
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+
+    test('propagates to findUnique via findFirst', async () => {
+        const { http, delegate, qb } = makeSetup();
+
+        await delegate.findUnique({ where: { id: 'user-1' }, excludeDeleted: true } as any);
+
+        const qbReq = qb()
+            .find(() => LogicalOperator.And([
+                new FieldConditionBuilder('id').equals('user-1'),
+                new FieldConditionBuilder('deletedAt').notExists(),
+            ]))
+            .limit(1)
+            .getQueryRequest();
+
+        expect(http.lastRequest).toEqual(qbReq);
+    });
+});
+
+// ── updateDocument ────────────────────────────────────────────────────────────
+
+describe('updateDocument', () => {
+    function makeUpdateSetup(existingDoc: Record<string, any>) {
+        const storeMock = jest.fn().mockResolvedValue({ id: 'tx-1' });
+        const client = {
+            queryBuilder: () => new QueryBuilder(
+                {
+                    post: jest.fn().mockResolvedValue({
+                        status: 200,
+                        data: { records: [existingDoc], total: 1, page: 0, limit: 1 },
+                    }),
+                } as any,
+                URL,
+                APP
+            ),
+            store: storeMock,
+        } as unknown as OnDBClient;
+        return { delegate: new ModelDelegate(client, COLLECTION), storeMock };
+    }
+
+    test('merges patch on top of existing document', async () => {
+        const existing = { id: 'user-1', name: 'Alice', age: 30, active: true };
+        const { delegate, storeMock } = makeUpdateSetup(existing);
+
+        await delegate.updateDocument({ id: 'user-1' }, { name: 'Bob' });
+
+        expect(storeMock).toHaveBeenCalledWith({
+            collection: COLLECTION,
+            data: [{ id: 'user-1', name: 'Bob', age: 30, active: true }],
+        });
+    });
+
+    test('patch fields overwrite existing, non-patched fields are preserved', async () => {
+        const existing = { id: 'user-1', name: 'Alice', email: 'alice@example.com', role: 'user' };
+        const { delegate, storeMock } = makeUpdateSetup(existing);
+
+        await delegate.updateDocument({ id: 'user-1' }, { role: 'admin' });
+
+        expect(storeMock).toHaveBeenCalledWith({
+            collection: COLLECTION,
+            data: [{ id: 'user-1', name: 'Alice', email: 'alice@example.com', role: 'admin' }],
+        });
+    });
+
+    test('throws if no document matches identifierFind', async () => {
+        const storeMock = jest.fn();
+        const client = {
+            queryBuilder: () => new QueryBuilder(
+                {
+                    post: jest.fn().mockResolvedValue({
+                        status: 200,
+                        data: { records: [], total: 0, page: 0, limit: 1 },
+                    }),
+                } as any,
+                URL,
+                APP
+            ),
+            store: storeMock,
+        } as unknown as OnDBClient;
+
+        const delegate = new ModelDelegate(client, COLLECTION);
+        await expect(delegate.updateDocument({ id: 'ghost' }, { name: 'X' }))
+            .rejects.toThrow('updateDocument: no document found matching the identifier');
+        expect(storeMock).not.toHaveBeenCalled();
+    });
+});
+
+// ── deleteDocument ────────────────────────────────────────────────────────────
+
+describe('deleteDocument', () => {
+    function makeDeleteSetup(existingDoc: Record<string, any>) {
+        const storeMock = jest.fn().mockResolvedValue({ id: 'tx-1' });
+        const client = {
+            queryBuilder: () => new QueryBuilder(
+                {
+                    post: jest.fn().mockResolvedValue({
+                        status: 200,
+                        data: { records: [existingDoc], total: 1, page: 0, limit: 1 },
+                    }),
+                } as any,
+                URL,
+                APP
+            ),
+            store: storeMock,
+        } as unknown as OnDBClient;
+        return { delegate: new ModelDelegate(client, COLLECTION), storeMock };
+    }
+
+    test('stores document with deletedAt set to a timestamp', async () => {
+        const existing = { id: 'user-1', name: 'Alice', active: true };
+        const { delegate, storeMock } = makeDeleteSetup(existing);
+
+        const before = Date.now();
+        await delegate.deleteDocument({ id: 'user-1' });
+        const after = Date.now();
+
+        expect(storeMock).toHaveBeenCalledTimes(1);
+        const stored = storeMock.mock.calls[0][0].data[0];
+        expect(stored.id).toBe('user-1');
+        expect(stored.name).toBe('Alice');
+        expect(stored.active).toBe(true);
+        expect(stored.deletedAt).toBeGreaterThanOrEqual(before);
+        expect(stored.deletedAt).toBeLessThanOrEqual(after);
+    });
+
+    test('optional patch is merged after deletedAt', async () => {
+        const existing = { id: 'user-1', name: 'Alice', active: true };
+        const { delegate, storeMock } = makeDeleteSetup(existing);
+
+        await delegate.deleteDocument({ id: 'user-1' }, { active: false, reason: 'violation' });
+
+        const stored = storeMock.mock.calls[0][0].data[0];
+        expect(stored.active).toBe(false);
+        expect(stored.reason).toBe('violation');
+        expect(stored.deletedAt).toBeDefined();
+    });
+
+    test('throws if no document matches identifierFind', async () => {
+        const storeMock = jest.fn();
+        const client = {
+            queryBuilder: () => new QueryBuilder(
+                {
+                    post: jest.fn().mockResolvedValue({
+                        status: 200,
+                        data: { records: [], total: 0, page: 0, limit: 1 },
+                    }),
+                } as any,
+                URL,
+                APP
+            ),
+            store: storeMock,
+        } as unknown as OnDBClient;
+
+        const delegate = new ModelDelegate(client, COLLECTION);
+        await expect(delegate.deleteDocument({ id: 'ghost' }))
+            .rejects.toThrow('deleteDocument: no document found matching the identifier');
+        expect(storeMock).not.toHaveBeenCalled();
+    });
+});
+
+// ── count ─────────────────────────────────────────────────────────────────────
+
+describe('count', () => {
+
+    test('count({ where }) sends same request as qb.count()', async () => {
+        // Run via ModelDelegate
+        const { http: http1, delegate } = makeSetup();
+        await delegate.count({ where: { active: true } });
+        const prismaReq = http1.lastRequest;
+
+        // Run via raw QueryBuilder
+        const http2 = new CapturingHttpClient();
+        const refQb = new QueryBuilder(http2, URL, APP)
+            .collection(COLLECTION)
+            .find(() => new FieldConditionBuilder('active').equals(true));
+        await refQb.count();
+        const qbReq = http2.lastRequest;
+
+        expect(prismaReq).toEqual(qbReq);
+    });
+});
+
+// ── aggregate ─────────────────────────────────────────────────────────────────
+
+describe('aggregate', () => {
+
+    test('_count: true matches qb.runAggregate', async () => {
+        const { http: http1, delegate } = makeSetup();
+        await delegate.aggregate({ where: { active: true }, _count: true });
+        const prismaReq = http1.lastRequest;
+
+        const http2 = new CapturingHttpClient();
+        await new QueryBuilder(http2, URL, APP)
+            .collection(COLLECTION)
+            .find(() => new FieldConditionBuilder('active').equals(true))
+            .runAggregate({ _count: { '$count': '*' } });
+        const qbReq = http2.lastRequest;
+
+        expect(prismaReq).toEqual(qbReq);
+    });
+
+    test('_sum + _avg matches qb.runAggregate', async () => {
+        const { http: http1, delegate } = makeSetup();
+        await delegate.aggregate({
+            where: { active: true },
+            _sum: { balance: true },
+            _avg: { age: true },
+        });
+        const prismaReq = http1.lastRequest;
+
+        const http2 = new CapturingHttpClient();
+        await new QueryBuilder(http2, URL, APP)
+            .collection(COLLECTION)
+            .find(() => new FieldConditionBuilder('active').equals(true))
+            .runAggregate({
+                _sum_balance: { '$sum': 'balance' },
+                _avg_age:     { '$avg': 'age' },
+            });
+        const qbReq = http2.lastRequest;
+
+        expect(prismaReq).toEqual(qbReq);
+    });
+
+    test('_count + _sum + _avg + _min + _max all together', async () => {
+        const { http: http1, delegate } = makeSetup();
+        await delegate.aggregate({
+            _count: true,
+            _sum: { balance: true },
+            _avg: { age: true },
+            _min: { age: true },
+            _max: { balance: true },
+        });
+        const prismaReq = http1.lastRequest;
+
+        const http2 = new CapturingHttpClient();
+        await new QueryBuilder(http2, URL, APP)
+            .collection(COLLECTION)
+            .runAggregate({
+                _count:       { '$count': '*' },
+                _sum_balance: { '$sum': 'balance' },
+                _avg_age:     { '$avg': 'age' },
+                _min_age:     { '$min': 'age' },
+                _max_balance: { '$max': 'balance' },
+            });
+        const qbReq = http2.lastRequest;
+
+        expect(prismaReq).toEqual(qbReq);
+    });
+});