@uql/core 1.0.12 → 3.1.0

package/dist/querier/abstractQuerier-test.js

@@ -0,0 +1,461 @@
+import { expect } from 'bun:test';
+import { getEntities } from '../entity/index.js';
+import { Company, InventoryAdjustment, Item, ItemAdjustment, LedgerAccount, MeasureUnit, Tag, TaxCategory, User, } from '../test/index.js';
+export class AbstractQuerierIt {
+    pool;
+    querier;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async beforeAll() {
+        const querier = await this.pool.getQuerier();
+        try {
+            this.querier = querier;
+            await this.dropTables();
+            await this.createTables();
+        }
+        finally {
+            await querier.release();
+            this.querier = undefined;
+        }
+    }
+    async beforeEach() {
+        this.querier = await this.pool.getQuerier();
+        await this.clearTables();
+    }
+    async afterEach() {
+        await this.querier.release();
+    }
+    async afterAll() {
+        await this.pool.end();
+    }
+    shouldGetRepository() {
+        const repository = this.querier.getRepository(User);
+        expect(repository).toBeDefined();
+    }
+    async shouldInsertMany() {
+        const ids = await this.querier.insertMany(User, [
+            {
+                name: 'Some Name A',
+                email: 'someemaila@example.com',
+                password: '123456789a!',
+            },
+            {
+                name: 'Some Name B',
+                email: 'someemailb@example.com',
+                password: '123456789b!',
+            },
+        ]);
+        expect(ids).toHaveLength(2);
+        for (const id of ids) {
+            expect(id).toBeDefined();
+        }
+    }
+    async shouldInsertManyEmpty() {
+        const ids = await this.querier.insertMany(User, []);
+        expect(ids).toEqual([]);
+    }
+    async shouldInsertOne() {
+        const creatorId = await this.querier.insertOne(User, {
+            name: 'Some Name C',
+            email: 'someemailc@example.com',
+            password: '123456789z!',
+        });
+        expect(creatorId).toBeDefined();
+        const companyId = await this.querier.insertOne(Company, {
+            name: 'Some Name C',
+            creatorId,
+        });
+        expect(companyId).toBeDefined();
+        const taxCategoryId = await this.querier.insertOne(TaxCategory, {
+            name: 'Some Name C',
+            description: 'Some Description Z',
+            creatorId,
+            companyId,
+        });
+        expect(taxCategoryId).toBeDefined();
+    }
+    async shouldInsertOneWithOnInsertId() {
+        const id1 = await this.querier.insertOne(TaxCategory, {
+            name: 'Some Name',
+        });
+        const id2 = await this.querier.insertOne(TaxCategory, {
+            pk: '123',
+            name: 'Some Name',
+        });
+        expect(id1).toBeDefined();
+        expect(id2).toBeDefined();
+    }
+    async shouldInsertManyWithSpecifiedIdsAndOnInsertIdAsDefault() {
+        const ids = await this.querier.insertMany(TaxCategory, [
+            {
+                name: 'Some Name A',
+            },
+            {
+                pk: '50',
+                name: 'Some Name B',
+            },
+            {
+                name: 'Some Name C',
+            },
+            {
+                pk: '70',
+                name: 'Some Name D',
+            },
+        ]);
+        expect(ids).toHaveLength(4);
+        for (const id of ids) {
+            expect(id).toBeDefined();
+        }
+    }
+    async shouldInsertManyWithAutoIncrementIdAsDefault() {
+        const ids = await this.querier.insertMany(LedgerAccount, [
+            {
+                name: 'Some Name A',
+            },
+            {
+                name: 'Some Name B',
+            },
+            {
+                name: 'Some Name C',
+            },
+        ]);
+        expect(ids).toHaveLength(3);
+        for (const id of ids) {
+            expect(id).toBeDefined();
+        }
+        const founds = await this.querier.findMany(LedgerAccount, {});
+        expect(founds.map(({ id }) => id)).toEqual(ids);
+    }
+    async shouldInsertOneAndCascadeOneToOne() {
+        const payload = {
+            name: 'Some Name D',
+            createdAt: 123,
+            profile: { picture: 'abc', createdAt: 123 },
+        };
+        const id = await this.querier.insertOne(User, payload);
+        expect(id).toBeDefined();
+        const found = await this.querier.findOneById(User, id, { $select: { profile: true } });
+        expect(found).toMatchObject({ id, profile: payload.profile });
+    }
+    async shouldInsertOneAndCascadeManyToOne() {
+        const payload = {
+            name: 'Centimeter',
+            createdAt: 123,
+            category: { name: 'Metric', createdAt: 123 },
+        };
+        const id = await this.querier.insertOne(MeasureUnit, payload);
+        expect(id).toBeDefined();
+        const found = await this.querier.findOneById(MeasureUnit, id, { $select: { category: true } });
+        expect(found).toMatchObject({ id, category: payload.category });
+    }
+    async shouldInsertSpecialChars() {
+        const payload = {
+            name: `I'm Cielo! How are you doing today? It's been a while since we last talked`,
+            createdAt: 123,
+        };
+        const id = await this.querier.insertOne(MeasureUnit, payload);
+        expect(id).toBeDefined();
+        const found = await this.querier.findOneById(MeasureUnit, id);
+        expect(found).toMatchObject(payload);
+    }
+    async shouldInsertOneAndCascadeOneToMany() {
+        const itemAdjustments = [{ buyPrice: 50 }, { buyPrice: 300 }];
+        const date = new Date();
+        const inventoryAdjustmentId = await this.querier.insertOne(InventoryAdjustment, {
+            description: 'some description',
+            date,
+            itemAdjustments,
+        });
+        expect(inventoryAdjustmentId).toBeDefined();
+        const inventoryAdjustmentFound = await this.querier.findOneById(InventoryAdjustment, inventoryAdjustmentId, {
+            $select: { itemAdjustments: true },
+        });
+        expect(inventoryAdjustmentFound).toMatchObject({
+            id: inventoryAdjustmentId,
+            itemAdjustments,
+        });
+        const itemAdjustmentsFound = await this.querier.findMany(ItemAdjustment, { $where: { inventoryAdjustmentId } });
+        expect(itemAdjustmentsFound).toMatchObject(itemAdjustments);
+    }
+    async shouldInsertOneAndCascadeOneToManyWithSpecificFields() {
+        const itemAdjustments = [{ buyPrice: 50 }, { buyPrice: 300 }];
+        const inventoryAdjustmentId = await this.querier.insertOne(InventoryAdjustment, {
+            description: 'some description',
+            itemAdjustments: itemAdjustments.slice(),
+        });
+        expect(inventoryAdjustmentId).toBeDefined();
+        const inventoryAdjustmentFound = await this.querier.findOneById(InventoryAdjustment, inventoryAdjustmentId, {
+            $select: { itemAdjustments: ['buyPrice'] },
+        });
+        expect(inventoryAdjustmentFound).toMatchObject({
+            id: inventoryAdjustmentId,
+            itemAdjustments,
+        });
+        const itemAdjustmentsFound = await this.querier.findMany(ItemAdjustment, { $where: { inventoryAdjustmentId } });
+        expect(itemAdjustmentsFound).toMatchObject(itemAdjustments);
+    }
+    async shouldUpdateOneAndCascadeOneToMany() {
+        const itemAdjustments = [{ buyPrice: 50 }, { buyPrice: 300 }];
+        const inventoryAdjustmentId = await this.querier.insertOne(InventoryAdjustment, {
+            description: 'some description',
+        });
+        expect(inventoryAdjustmentId).toBeDefined();
+        const changes = await this.querier.updateOneById(InventoryAdjustment, inventoryAdjustmentId, {
+            itemAdjustments,
+        });
+        expect(changes).toBe(1);
+        const inventoryAdjustmentFound = await this.querier.findOneById(InventoryAdjustment, inventoryAdjustmentId, {
+            $select: { itemAdjustments: ['buyPrice'] },
+        });
+        expect(inventoryAdjustmentFound).toMatchObject({
+            id: inventoryAdjustmentId,
+            itemAdjustments,
+        });
+        const itemAdjustmentsFound = await this.querier.findMany(ItemAdjustment, { $where: { inventoryAdjustmentId } });
+        expect(itemAdjustmentsFound).toMatchObject(itemAdjustments);
+    }
+    async shouldUpdateOneByIdAndCascadeOneToManyNull() {
+        const id = await this.querier.insertOne(InventoryAdjustment, { itemAdjustments: [{}, {}] });
+        await expect(this.querier.count(ItemAdjustment, {})).resolves.toBe(2);
+        await this.querier.updateOneById(InventoryAdjustment, id, {
+            itemAdjustments: null,
+        });
+        await expect(this.querier.count(ItemAdjustment, {})).resolves.toBe(0);
+    }
+    async shouldUpdateManyAndCascadeOneToManyNull() {
+        await this.querier.insertOne(InventoryAdjustment, { itemAdjustments: [{}, {}] });
+        await expect(this.querier.count(ItemAdjustment, {})).resolves.toBe(2);
+        await this.querier.updateMany(InventoryAdjustment, { $where: {} }, {
+            itemAdjustments: null,
+        });
+        await expect(this.querier.count(ItemAdjustment, {})).resolves.toBe(0);
+    }
+    async shouldInsertOneAndCascadeManyToMany() {
+        const payload = {
+            name: 'item one',
+            createdAt: 1,
+            tags: [
+                {
+                    name: 'tag one',
+                    createdAt: 1,
+                },
+                {
+                    name: 'tag two',
+                    createdAt: 1,
+                },
+            ],
+        };
+        const id = await this.querier.insertOne(Item, payload);
+        expect(id).toBeDefined();
+        const foundItem = await this.querier.findOneById(Item, id, {
+            $select: { name: true, createdAt: true, tags: ['name', 'createdAt'] },
+        });
+        expect(foundItem).toMatchObject({
+            id,
+            ...payload,
+        });
+        const foundTags = await this.querier.findMany(Tag, {
+            $select: { name: true, createdAt: true, items: ['name', 'createdAt'] },
+        });
+        delete foundItem.tags;
+        expect(foundTags).toMatchObject(payload.tags.map((tag) => ({ ...tag, items: [foundItem] })));
+    }
+    async shouldUpdateOneAndCascadeManyToMany() {
+        const id = await this.querier.insertOne(Item, { createdAt: 1 });
+        const payload = {
+            name: 'item one',
+            updatedAt: 1,
+            tags: [
+                {
+                    name: 'tag one',
+                    createdAt: 1,
+                },
+                {
+                    name: 'tag two',
+                    createdAt: 1,
+                },
+            ],
+        };
+        await this.querier.updateOneById(Item, id, payload);
+        const found = await this.querier.findOneById(Item, id, {
+            $select: { name: true, updatedAt: true, tags: true },
+        });
+        expect(found).toMatchObject({
+            id,
+            ...payload,
+        });
+    }
+    async shouldUpsertOne() {
+        const pk = '507f1f77bcf86cd799439011';
+        const record1 = await this.querier.findOne(TaxCategory, {
+            $select: ['name'],
+            $where: { pk },
+        });
+        expect(record1).toBeUndefined();
+        await this.querier.upsertOne(TaxCategory, { pk: true }, {
+            pk,
+            name: 'Some Name C',
+        });
+        const record2 = await this.querier.findOne(TaxCategory, {
+            $select: ['name'],
+            $where: { pk },
+        });
+        expect(record2).toMatchObject({
+            name: 'Some Name C',
+        });
+        await this.querier.upsertOne(TaxCategory, { pk: true }, {
+            pk,
+            name: 'Some Name D',
+        });
+        const record3 = await this.querier.findOne(TaxCategory, {
+            $select: ['name'],
+            $where: { pk },
+        });
+        expect(record3).toMatchObject({
+            name: 'Some Name D',
+        });
+    }
+    async shouldFindOne() {
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        const found = await this.querier.findOne(User, {
+            $select: ['id', 'name', 'email', 'password'],
+            $where: {
+                email: 'someemaila@example.com',
+            },
+        });
+        expect(found).toMatchObject({
+            name: 'Some Name A',
+            email: 'someemaila@example.com',
+            password: '123456789a!',
+        });
+        const notFound = await this.querier.findOne(User, {
+            $where: {
+                name: 'some name',
+            },
+        });
+        expect(notFound).toBeUndefined();
+    }
+    async shouldCount() {
+        await expect(this.querier.count(User, {})).resolves.toBe(0);
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        await expect(this.querier.count(User, {})).resolves.toBe(3);
+        await expect(this.querier.count(User, { $where: { companyId: null } })).resolves.toBe(3);
+        await expect(this.querier.count(User, { $where: { companyId: 1 } })).resolves.toBe(0);
+    }
+    async shouldUpdateMany() {
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        await expect(this.querier.updateMany(User, { $where: { companyId: 1 } }, { companyId: null })).resolves.toBe(0);
+        await expect(this.querier.updateMany(User, { $where: { companyId: null } }, { companyId: 1 })).resolves.toBe(3);
+        await expect(this.querier.updateMany(User, { $where: { companyId: 1 } }, { companyId: null })).resolves.toBe(3);
+    }
+    async shouldThrowIfUnknownComparisonOperator() {
+        await expect(this.querier.findMany(User, {
+            $where: { name: { $someInvalidOperator: 'some' } },
+        })).rejects.toThrow('unknown operator: $someInvalidOperator');
+    }
+    async shouldThrowWhenRollbackTransactionWithoutBeginTransaction() {
+        await expect(this.querier.rollbackTransaction()).rejects.toThrow('not a pending transaction');
+    }
+    async shouldCommit() {
+        await expect(this.querier.count(User, {})).resolves.toBe(0);
+        await this.querier.beginTransaction();
+        await this.querier.insertOne(User, {});
+        await expect(this.querier.count(User, {})).resolves.toBe(1);
+        await this.querier.commitTransaction();
+        await expect(this.querier.count(User, {})).resolves.toBe(1);
+        await this.querier.release();
+    }
+    async shouldRollback() {
+        await expect(this.querier.count(User, {})).resolves.toBe(0);
+        await this.querier.beginTransaction();
+        await this.querier.insertOne(User, {});
+        await expect(this.querier.count(User, {})).resolves.toBe(1);
+        await this.querier.rollbackTransaction();
+        await expect(this.querier.count(User, {})).resolves.toBe(0);
+        await this.querier.release();
+    }
+    async shouldThrowWhenBeginTransactionAfterBeginTransaction() {
+        expect(this.querier.hasOpenTransaction).toBeFalsy();
+        await this.querier.beginTransaction();
+        expect(this.querier.hasOpenTransaction).toBe(true);
+        await expect(this.querier.beginTransaction()).rejects.toThrow('pending transaction');
+        await expect(this.querier.release()).rejects.toThrow('pending transaction');
+        await this.querier.rollbackTransaction();
+        await this.querier.release();
+    }
+    async shouldReturnTransactionValue() {
+        const affectedRows = await this.querier.transaction(async () => {
+            await this.shouldInsertMany();
+            const count = await this.querier.count(User, {});
+            await this.querier.deleteMany(User, {});
+            return count;
+        });
+        expect(affectedRows).toBe(2);
+    }
+    async shouldThrowWhenCommitTransactionWithoutBeginTransaction() {
+        await expect(this.querier.commitTransaction()).rejects.toThrow('not a pending transaction');
+    }
+    async shouldSelectOneToManyEmpty() {
+        const inventoryAdjustment = await this.querier.findOneById(InventoryAdjustment, -1, {
+            $select: { itemAdjustments: true, creator: true },
+        });
+        expect(inventoryAdjustment).toBeUndefined();
+        const inventoryAdjustments = await this.querier.findMany(InventoryAdjustment, {
+            $select: { itemAdjustments: true },
+        });
+        expect(inventoryAdjustments).toHaveLength(0);
+    }
+    async shouldSelectOneToMany() {
+        await this.shouldInsertOne();
+        const [user, company] = await Promise.all([
+            this.querier.findOne(User, { $select: ['id'] }),
+            this.querier.findOne(Company, { $select: ['id'] }),
+        ]);
+        const [firstItemId, secondItemId] = await this.querier.insertMany(Item, [
+            {
+                name: 'some item name a',
+                creatorId: user.id,
+                companyId: company.id,
+            },
+            {
+                name: 'some item name b',
+                creatorId: user.id,
+                companyId: company.id,
+            },
+        ]);
+        const inventoryAdjustmentId = await this.querier.insertOne(InventoryAdjustment, {
+            description: 'some inventory adjustment',
+            creatorId: user.id,
+            companyId: company.id,
+            itemAdjustments: [
+                { buyPrice: 1000, itemId: firstItemId },
+                { buyPrice: 2000, itemId: secondItemId },
+            ],
+        });
+        const inventoryAdjustmentFound = await this.querier.findOneById(InventoryAdjustment, inventoryAdjustmentId, {
+            $select: { itemAdjustments: true, creator: true },
+        });
+        expect(inventoryAdjustmentFound).toMatchObject({
+            id: inventoryAdjustmentId,
+            itemAdjustments: [
+                { buyPrice: 1000, itemId: firstItemId },
+                { buyPrice: 2000, itemId: secondItemId },
+            ],
+            creator: {
+                email: 'someemailc@example.com',
+                name: 'Some Name C',
+            },
+        });
+    }
+    async shouldDeleteMany() {
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        await expect(this.querier.deleteMany(User, { $where: { companyId: 1 } })).resolves.toBe(0);
+        await expect(this.querier.deleteMany(User, { $where: { companyId: null } })).resolves.toBe(3);
+    }
+    async clearTables() {
+        const entities = getEntities();
+        await Promise.all(entities.map((entity) => this.querier.deleteMany(entity, {})));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractQuerier-test.js","sourceRoot":"","sources":["../../src/querier/abstractQuerier-test.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect } from 'bun:test';\nimport { getEntities } from '../entity/index.js';\nimport {\n  Company,\n  InventoryAdjustment,\n  Item,\n  ItemAdjustment,\n  LedgerAccount,\n  MeasureUnit,\n  type Spec,\n  Tag,\n  TaxCategory,\n  User,\n} from '../test/index.js';\nimport type { Querier, QuerierPool } from '../type/index.js';\n\nexport abstract class AbstractQuerierIt<Q extends Querier> implements Spec {\n  querier: Q;\n\n  constructor(protected pool: QuerierPool<Q>) {}\n\n  async beforeAll() {\n    const querier = await this.pool.getQuerier();\n    try {\n      this.querier = querier;\n      await this.dropTables();\n      await this.createTables();\n    } finally {\n      await querier.release();\n      this.querier = undefined;\n    }\n  }\n\n  async beforeEach() {\n    this.querier = await this.pool.getQuerier();\n    await this.clearTables();\n  }\n\n  async afterEach() {\n    await this.querier.release();\n  }\n\n  async afterAll() {\n    await this.pool.end();\n  }\n\n  shouldGetRepository() {\n    const repository = this.querier.getRepository(User);\n    expect(repository).toBeDefined();\n  }\n\n  async shouldInsertMany() {\n    const ids = await this.querier.insertMany(User, [\n      {\n        name: 'Some Name A',\n        email: 'someemaila@example.com',\n        password: '123456789a!',\n      },\n      {\n        name: 'Some Name B',\n        email: 'someemailb@example.com',\n        password: '123456789b!',\n      },\n    ]);\n    expect(ids).toHaveLength(2);\n    for (const id of ids) {\n      expect(id).toBeDefined();\n    }\n  }\n\n  async shouldInsertManyEmpty() {\n    const ids = await this.querier.insertMany(User, []);\n    expect(ids).toEqual([]);\n  }\n\n  async shouldInsertOne() {\n    const creatorId = await this.querier.insertOne(User, {\n      name: 'Some Name C',\n      email: 'someemailc@example.com',\n      password: '123456789z!',\n    });\n    expect(creatorId).toBeDefined();\n\n    const companyId = await this.querier.insertOne(Company, {\n      name: 'Some Name C',\n      creatorId,\n    });\n    expect(companyId).toBeDefined();\n\n    const taxCategoryId = await this.querier.insertOne(TaxCategory, {\n      name: 'Some Name C',\n      description: 'Some Description Z',\n      creatorId,\n      companyId,\n    });\n    expect(taxCategoryId).toBeDefined();\n  }\n\n  async shouldInsertOneWithOnInsertId() {\n    const id1 = await this.querier.insertOne(TaxCategory, {\n      name: 'Some Name',\n    });\n    const id2 = await this.querier.insertOne(TaxCategory, {\n      pk: '123',\n      name: 'Some Name',\n    });\n    expect(id1).toBeDefined();\n    expect(id2).toBeDefined();\n  }\n\n  async shouldInsertManyWithSpecifiedIdsAndOnInsertIdAsDefault() {\n    const ids = await this.querier.insertMany(TaxCategory, [\n      {\n        name: 'Some Name A',\n      },\n      {\n        pk: '50',\n        name: 'Some Name B',\n      },\n      {\n        name: 'Some Name C',\n      },\n      {\n        pk: '70',\n        name: 'Some Name D',\n      },\n    ]);\n    expect(ids).toHaveLength(4);\n    for (const id of ids) {\n      expect(id).toBeDefined();\n    }\n  }\n\n  async shouldInsertManyWithAutoIncrementIdAsDefault() {\n    const ids = await this.querier.insertMany(LedgerAccount, [\n      {\n        name: 'Some Name A',\n      },\n      {\n        name: 'Some Name B',\n      },\n      {\n        name: 'Some Name C',\n      },\n    ]);\n    expect(ids).toHaveLength(3);\n    for (const id of ids) {\n      expect(id).toBeDefined();\n    }\n    const founds = await this.querier.findMany(LedgerAccount, {});\n    expect(founds.map(({ id }) => id)).toEqual(ids);\n  }\n\n  async shouldInsertOneAndCascadeOneToOne() {\n    const payload = {\n      name: 'Some Name D',\n      createdAt: 123,\n      profile: { picture: 'abc', createdAt: 123 },\n    } satisfies User;\n    const id = await this.querier.insertOne(User, payload);\n    expect(id).toBeDefined();\n    const found = await this.querier.findOneById(User, id, { $select: { profile: true } });\n    expect(found).toMatchObject({ id, profile: payload.profile });\n  }\n\n  async shouldInsertOneAndCascadeManyToOne() {\n    const payload = {\n      name: 'Centimeter',\n      createdAt: 123,\n      category: { name: 'Metric', createdAt: 123 },\n    } satisfies MeasureUnit;\n\n    const id = await this.querier.insertOne(MeasureUnit, payload);\n\n    expect(id).toBeDefined();\n\n    const found = await this.querier.findOneById(MeasureUnit, id, { $select: { category: true } });\n\n    expect(found).toMatchObject({ id, category: payload.category });\n  }\n\n  async shouldInsertSpecialChars() {\n    const payload: MeasureUnit = {\n      name: `I'm Cielo! How are you doing today? It's been a while since we last talked`,\n      createdAt: 123,\n    };\n\n    const id = await this.querier.insertOne(MeasureUnit, payload);\n\n    expect(id).toBeDefined();\n\n    const found = await this.querier.findOneById(MeasureUnit, id);\n\n    expect(found).toMatchObject(payload);\n  }\n\n  async shouldInsertOneAndCascadeOneToMany() {\n    const itemAdjustments: ItemAdjustment[] = [{ buyPrice: 50 }, { buyPrice: 300 }];\n\n    const date = new Date();\n\n    const inventoryAdjustmentId = await this.querier.insertOne(InventoryAdjustment, {\n      description: 'some description',\n      date,\n      itemAdjustments,\n    });\n\n    expect(inventoryAdjustmentId).toBeDefined();\n\n    const inventoryAdjustmentFound = await this.querier.findOneById(InventoryAdjustment, inventoryAdjustmentId, {\n      $select: { itemAdjustments: true },\n    });\n\n    expect(inventoryAdjustmentFound).toMatchObject({\n      id: inventoryAdjustmentId,\n      itemAdjustments,\n    });\n\n    const itemAdjustmentsFound = await this.querier.findMany(ItemAdjustment, { $where: { inventoryAdjustmentId } });\n\n    expect(itemAdjustmentsFound).toMatchObject(itemAdjustments);\n  }\n\n  async shouldInsertOneAndCascadeOneToManyWithSpecificFields() {\n    const itemAdjustments: ItemAdjustment[] = [{ buyPrice: 50 }, { buyPrice: 300 }];\n\n    const inventoryAdjustmentId = await this.querier.insertOne(InventoryAdjustment, {\n      description: 'some description',\n      itemAdjustments: itemAdjustments.slice(),\n    });\n\n    expect(inventoryAdjustmentId).toBeDefined();\n\n    const inventoryAdjustmentFound = await this.querier.findOneById(InventoryAdjustment, inventoryAdjustmentId, {\n      $select: { itemAdjustments: ['buyPrice'] },\n    });\n\n    expect(inventoryAdjustmentFound).toMatchObject({\n      id: inventoryAdjustmentId,\n      itemAdjustments,\n    });\n\n    const itemAdjustmentsFound = await this.querier.findMany(ItemAdjustment, { $where: { inventoryAdjustmentId } });\n\n    expect(itemAdjustmentsFound).toMatchObject(itemAdjustments);\n  }\n\n  async shouldUpdateOneAndCascadeOneToMany() {\n    const itemAdjustments: ItemAdjustment[] = [{ buyPrice: 50 }, { buyPrice: 300 }];\n\n    const inventoryAdjustmentId = await this.querier.insertOne(InventoryAdjustment, {\n      description: 'some description',\n    });\n\n    expect(inventoryAdjustmentId).toBeDefined();\n\n    const changes = await this.querier.updateOneById(InventoryAdjustment, inventoryAdjustmentId, {\n      itemAdjustments,\n    });\n\n    expect(changes).toBe(1);\n\n    const inventoryAdjustmentFound = await this.querier.findOneById(InventoryAdjustment, inventoryAdjustmentId, {\n      $select: { itemAdjustments: ['buyPrice'] },\n    });\n\n    expect(inventoryAdjustmentFound).toMatchObject({\n      id: inventoryAdjustmentId,\n      itemAdjustments,\n    });\n\n    const itemAdjustmentsFound = await this.querier.findMany(ItemAdjustment, { $where: { inventoryAdjustmentId } });\n\n    expect(itemAdjustmentsFound).toMatchObject(itemAdjustments);\n  }\n\n  async shouldUpdateOneByIdAndCascadeOneToManyNull() {\n    const id = await this.querier.insertOne(InventoryAdjustment, { itemAdjustments: [{}, {}] });\n\n    await expect(this.querier.count(ItemAdjustment, {})).resolves.toBe(2);\n\n    await this.querier.updateOneById(InventoryAdjustment, id, {\n      itemAdjustments: null,\n    });\n\n    await expect(this.querier.count(ItemAdjustment, {})).resolves.toBe(0);\n  }\n\n  async shouldUpdateManyAndCascadeOneToManyNull() {\n    await this.querier.insertOne(InventoryAdjustment, { itemAdjustments: [{}, {}] });\n\n    await expect(this.querier.count(ItemAdjustment, {})).resolves.toBe(2);\n\n    await this.querier.updateMany(\n      InventoryAdjustment,\n      { $where: {} },\n      {\n        itemAdjustments: null,\n      },\n    );\n\n    await expect(this.querier.count(ItemAdjustment, {})).resolves.toBe(0);\n  }\n\n  async shouldInsertOneAndCascadeManyToMany() {\n    const payload: Item = {\n      name: 'item one',\n      createdAt: 1,\n      tags: [\n        {\n          name: 'tag one',\n          createdAt: 1,\n        },\n        {\n          name: 'tag two',\n          createdAt: 1,\n        },\n      ],\n    };\n\n    const id = await this.querier.insertOne(Item, payload);\n\n    expect(id).toBeDefined();\n\n    const foundItem = await this.querier.findOneById(Item, id, {\n      $select: { name: true, createdAt: true, tags: ['name', 'createdAt'] },\n    });\n\n    expect(foundItem).toMatchObject({\n      id,\n      ...payload,\n    });\n\n    const foundTags = await this.querier.findMany(Tag, {\n      $select: { name: true, createdAt: true, items: ['name', 'createdAt'] },\n    });\n\n    delete foundItem.tags;\n\n    expect(foundTags).toMatchObject(payload.tags.map((tag) => ({ ...tag, items: [foundItem] })));\n  }\n\n  async shouldUpdateOneAndCascadeManyToMany() {\n    const id = await this.querier.insertOne(Item, { createdAt: 1 });\n    const payload: Item = {\n      name: 'item one',\n      updatedAt: 1,\n      tags: [\n        {\n          name: 'tag one',\n          createdAt: 1,\n        },\n        {\n          name: 'tag two',\n          createdAt: 1,\n        },\n      ],\n    };\n\n    await this.querier.updateOneById(Item, id, payload);\n\n    const found = await this.querier.findOneById(Item, id, {\n      $select: { name: true, updatedAt: true, tags: true },\n    });\n\n    expect(found).toMatchObject({\n      id,\n      ...payload,\n    });\n  }\n\n  async shouldUpsertOne() {\n    const pk = '507f1f77bcf86cd799439011';\n    const record1 = await this.querier.findOne(TaxCategory, {\n      $select: ['name'],\n      $where: { pk },\n    });\n    expect(record1).toBeUndefined();\n    await this.querier.upsertOne(\n      TaxCategory,\n      { pk: true },\n      {\n        pk,\n        name: 'Some Name C',\n      },\n    );\n    const record2 = await this.querier.findOne(TaxCategory, {\n      $select: ['name'],\n      $where: { pk },\n    });\n    expect(record2).toMatchObject({\n      name: 'Some Name C',\n    });\n    await this.querier.upsertOne(\n      TaxCategory,\n      { pk: true },\n      {\n        pk,\n        name: 'Some Name D',\n      },\n    );\n    const record3 = await this.querier.findOne(TaxCategory, {\n      $select: ['name'],\n      $where: { pk },\n    });\n    expect(record3).toMatchObject({\n      name: 'Some Name D',\n    });\n  }\n\n  async shouldFindOne() {\n    await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);\n\n    const found = await this.querier.findOne(User, {\n      $select: ['id', 'name', 'email', 'password'],\n      $where: {\n        email: 'someemaila@example.com',\n      },\n    });\n\n    expect(found).toMatchObject({\n      name: 'Some Name A',\n      email: 'someemaila@example.com',\n      password: '123456789a!',\n    });\n\n    const notFound = await this.querier.findOne(User, {\n      $where: {\n        name: 'some name',\n      },\n    });\n\n    expect(notFound).toBeUndefined();\n  }\n\n  async shouldCount() {\n    await expect(this.querier.count(User, {})).resolves.toBe(0);\n\n    await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);\n\n    await expect(this.querier.count(User, {})).resolves.toBe(3);\n    await expect(this.querier.count(User, { $where: { companyId: null } })).resolves.toBe(3);\n    await expect(this.querier.count(User, { $where: { companyId: 1 } })).resolves.toBe(0);\n  }\n\n  async shouldUpdateMany() {\n    await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);\n\n    await expect(this.querier.updateMany(User, { $where: { companyId: 1 } }, { companyId: null })).resolves.toBe(0);\n    await expect(this.querier.updateMany(User, { $where: { companyId: null } }, { companyId: 1 })).resolves.toBe(3);\n    await expect(this.querier.updateMany(User, { $where: { companyId: 1 } }, { companyId: null })).resolves.toBe(3);\n  }\n\n  async shouldThrowIfUnknownComparisonOperator() {\n    await expect(\n      this.querier.findMany(User, {\n        $where: { name: { $someInvalidOperator: 'some' } as any },\n      }),\n    ).rejects.toThrow('unknown operator: $someInvalidOperator');\n  }\n\n  async shouldThrowWhenRollbackTransactionWithoutBeginTransaction() {\n    await expect(this.querier.rollbackTransaction()).rejects.toThrow('not a pending transaction');\n  }\n\n  async shouldCommit() {\n    await expect(this.querier.count(User, {})).resolves.toBe(0);\n    await this.querier.beginTransaction();\n    await this.querier.insertOne(User, {});\n    await expect(this.querier.count(User, {})).resolves.toBe(1);\n    await this.querier.commitTransaction();\n    await expect(this.querier.count(User, {})).resolves.toBe(1);\n    await this.querier.release();\n  }\n\n  async shouldRollback() {\n    await expect(this.querier.count(User, {})).resolves.toBe(0);\n    await this.querier.beginTransaction();\n    await this.querier.insertOne(User, {});\n    await expect(this.querier.count(User, {})).resolves.toBe(1);\n    await this.querier.rollbackTransaction();\n    await expect(this.querier.count(User, {})).resolves.toBe(0);\n    await this.querier.release();\n  }\n\n  async shouldThrowWhenBeginTransactionAfterBeginTransaction() {\n    expect(this.querier.hasOpenTransaction).toBeFalsy();\n    await this.querier.beginTransaction();\n    expect(this.querier.hasOpenTransaction).toBe(true);\n    await expect(this.querier.beginTransaction()).rejects.toThrow('pending transaction');\n    await expect(this.querier.release()).rejects.toThrow('pending transaction');\n    await this.querier.rollbackTransaction();\n    await this.querier.release();\n  }\n\n  async shouldReturnTransactionValue() {\n    const affectedRows = await this.querier.transaction(async () => {\n      await this.shouldInsertMany();\n      const count = await this.querier.count(User, {});\n      await this.querier.deleteMany(User, {});\n      return count;\n    });\n    expect(affectedRows).toBe(2);\n  }\n\n  async shouldThrowWhenCommitTransactionWithoutBeginTransaction() {\n    await expect(this.querier.commitTransaction()).rejects.toThrow('not a pending transaction');\n  }\n\n  async shouldSelectOneToManyEmpty() {\n    const inventoryAdjustment = await this.querier.findOneById(InventoryAdjustment, -1, {\n      $select: { itemAdjustments: true, creator: true },\n    });\n    expect(inventoryAdjustment).toBeUndefined();\n\n    const inventoryAdjustments = await this.querier.findMany(InventoryAdjustment, {\n      $select: { itemAdjustments: true },\n    });\n    expect(inventoryAdjustments).toHaveLength(0);\n  }\n\n  async shouldSelectOneToMany() {\n    await this.shouldInsertOne();\n\n    const [user, company] = await Promise.all([\n      this.querier.findOne(User, { $select: ['id'] }),\n      this.querier.findOne(Company, { $select: ['id'] }),\n    ]);\n\n    const [firstItemId, secondItemId] = await this.querier.insertMany(Item, [\n      {\n        name: 'some item name a',\n        creatorId: user.id,\n        companyId: company.id,\n      },\n      {\n        name: 'some item name b',\n        creatorId: user.id,\n        companyId: company.id,\n      },\n    ]);\n\n    const inventoryAdjustmentId = await this.querier.insertOne(InventoryAdjustment, {\n      description: 'some inventory adjustment',\n      creatorId: user.id,\n      companyId: company.id,\n      itemAdjustments: [\n        { buyPrice: 1000, itemId: firstItemId },\n        { buyPrice: 2000, itemId: secondItemId },\n      ],\n    });\n\n    const inventoryAdjustmentFound = await this.querier.findOneById(InventoryAdjustment, inventoryAdjustmentId, {\n      $select: { itemAdjustments: true, creator: true },\n    });\n\n    expect(inventoryAdjustmentFound).toMatchObject({\n      id: inventoryAdjustmentId,\n      itemAdjustments: [\n        { buyPrice: 1000, itemId: firstItemId },\n        { buyPrice: 2000, itemId: secondItemId },\n      ],\n      creator: {\n        email: 'someemailc@example.com',\n        name: 'Some Name C',\n      },\n    });\n  }\n\n  async shouldDeleteMany() {\n    await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);\n    await expect(this.querier.deleteMany(User, { $where: { companyId: 1 } })).resolves.toBe(0);\n    await expect(this.querier.deleteMany(User, { $where: { companyId: null } })).resolves.toBe(3);\n  }\n\n  async clearTables() {\n    const entities = getEntities();\n    await Promise.all(entities.map((entity) => this.querier.deleteMany(entity, {})));\n  }\n\n  abstract createTables(): Promise<void>;\n\n  abstract dropTables(): Promise<void>;\n}\n"]}

package/dist/querier/abstractQuerier.d.ts

@@ -0,0 +1,50 @@
+import type { IdValue, Querier, Query, QueryConflictPaths, QueryOne, QueryOptions, QuerySearch, QuerySelect, QueryUpdateResult, RelationKey, Repository, Type } from '../type/index.js';
+/**
+ * Base class for all database queriers.
+ * It provides a standardized way to execute tasks serially to prevent race conditions on database connections.
+ */
+export declare abstract class AbstractQuerier implements Querier {
+    /**
+     * Internal promise used to queue database operations.
+     * This ensures that each operation is executed serially, preventing race conditions
+     * and ensuring that the database connection is used safely across concurrent calls.
+     */
+    private taskQueue;
+    findOneById<E>(entity: Type<E>, id: IdValue<E>, q?: QueryOne<E>): Promise<E>;
+    findOne<E>(entity: Type<E>, q: QueryOne<E>): Promise<E>;
+    abstract findMany<E>(entity: Type<E>, q: Query<E>): Promise<E[]>;
+    findManyAndCount<E>(entity: Type<E>, q: Query<E>): Promise<[E[], number]>;
+    abstract count<E>(entity: Type<E>, q: QuerySearch<E>): Promise<number>;
+    insertOne<E>(entity: Type<E>, payload: E): Promise<IdValue<E>>;
+    abstract insertMany<E>(entity: Type<E>, payload: E[]): Promise<IdValue<E>[]>;
+    updateOneById<E>(entity: Type<E>, id: IdValue<E>, payload: E): Promise<number>;
+    abstract updateMany<E>(entity: Type<E>, q: QuerySearch<E>, payload: E): Promise<number>;
+    abstract upsertOne<E>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): Promise<QueryUpdateResult>;
+    deleteOneById<E>(entity: Type<E>, id: IdValue<E>, opts?: QueryOptions): Promise<number>;
+    abstract deleteMany<E>(entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
+    saveOne<E>(entity: Type<E>, payload: E): Promise<IdValue<E> | E[import("../type/entity.js").IdKey<E>]>;
+    saveMany<E>(entity: Type<E>, payload: E[]): Promise<(Awaited<IdValue<E>> | Awaited<E[import("../type/entity.js").IdKey<E>]>)[]>;
+    protected fillToManyRelations<E>(entity: Type<E>, payload: E[], select: QuerySelect<E>): Promise<void>;
+    protected putChildrenInParents<E>(parents: E[], children: E[], parentIdKey: string, referenceKey: string, relKey: string): void;
+    protected insertRelations<E>(entity: Type<E>, payload: E[]): Promise<void>;
+    protected updateRelations<E>(entity: Type<E>, q: QuerySearch<E>, payload: E): Promise<void>;
+    protected deleteRelations<E>(entity: Type<E>, ids: IdValue<E>[], opts?: QueryOptions): Promise<void>;
+    protected saveRelation<E>(entity: Type<E>, payload: E, relKey: RelationKey<E>, isUpdate?: boolean): Promise<void>;
+    getRepository<E>(entity: Type<E>): Repository<E>;
+    abstract readonly hasOpenTransaction: boolean;
+    transaction<T>(callback: () => Promise<T>): Promise<T>;
+    releaseIfFree(): Promise<void>;
+    /**
+     * Schedules a task to be executed serially in the querier instance.
+     * This is used by the @Serialized decorator to protect database-level operations.
+     *
+     * @param task - The async task to execute.
+     * @returns A promise that resolves with the task's result.
+     */
+    protected serialize<T>(task: () => Promise<T>): Promise<T>;
+    abstract beginTransaction(): Promise<void>;
+    abstract commitTransaction(): Promise<void>;
+    abstract rollbackTransaction(): Promise<void>;
+    protected abstract internalRelease(): Promise<void>;
+    release(): Promise<void>;
+}