@uql/core 0.4.80 → 0.4.83

package/querier/abstractQuerier-it.js

@@ -0,0 +1,410 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractQuerierIt = void 0;
+const entity_1 = require("@uql/core/entity");
+const test_1 = require("@uql/core/test");
+class AbstractQuerierIt {
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async beforeAll() {
+        this.querier = await this.pool.getQuerier();
+        await this.dropTables();
+        await this.createTables();
+        await this.querier.release();
+    }
+    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(test_1.User);
+        expect(repository).toBeDefined();
+    }
+    async shouldInsertMany() {
+        const ids = await this.querier.insertMany(test_1.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 shouldInsertOne() {
+        const creatorId = await this.querier.insertOne(test_1.User, {
+            name: 'Some Name C',
+            email: 'someemailc@example.com',
+            password: '123456789z!',
+        });
+        expect(creatorId).toBeDefined();
+        const companyId = await this.querier.insertOne(test_1.Company, {
+            name: 'Some Name C',
+            creatorId,
+        });
+        expect(companyId).toBeDefined();
+        const taxCategoryId = await this.querier.insertOne(test_1.TaxCategory, {
+            name: 'Some Name C',
+            description: 'Some Description Z',
+            creatorId,
+            companyId,
+        });
+        expect(taxCategoryId).toBeDefined();
+    }
+    async shouldInsertOneWithOnInsertId() {
+        const id1 = await this.querier.insertOne(test_1.TaxCategory, {
+            name: 'Some Name',
+        });
+        const id2 = await this.querier.insertOne(test_1.TaxCategory, {
+            pk: '123',
+            name: 'Some Name',
+        });
+        expect(id1).toBeDefined();
+        expect(id2).toBeDefined();
+    }
+    async shouldInsertManyWithSpecifiedIdsAndOnInsertIdAsDefault() {
+        const ids = await this.querier.insertMany(test_1.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(test_1.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(test_1.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(test_1.User, payload);
+        expect(id).toBeDefined();
+        const found = await this.querier.findOneById(test_1.User, id, { $project: ['profile'] });
+        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(test_1.MeasureUnit, payload);
+        expect(id).toBeDefined();
+        const found = await this.querier.findOneById(test_1.MeasureUnit, id, { $project: { category: true } });
+        expect(found).toMatchObject({ id, category: payload.category });
+    }
+    async shouldInsertOneAndCascadeOneToMany() {
+        const itemAdjustments = [{ buyPrice: 50 }, { buyPrice: 300 }];
+        const date = new Date();
+        const inventoryAdjustmentId = await this.querier.insertOne(test_1.InventoryAdjustment, {
+            description: 'some description',
+            date,
+            itemAdjustments,
+        });
+        expect(inventoryAdjustmentId).toBeDefined();
+        const inventoryAdjustmentFound = await this.querier.findOneById(test_1.InventoryAdjustment, inventoryAdjustmentId, {
+            $project: { itemAdjustments: true },
+        });
+        expect(inventoryAdjustmentFound).toMatchObject({
+            id: inventoryAdjustmentId,
+            itemAdjustments,
+        });
+        const itemAdjustmentsFound = await this.querier.findMany(test_1.ItemAdjustment, { $filter: { inventoryAdjustmentId } });
+        expect(itemAdjustmentsFound).toMatchObject(itemAdjustments);
+    }
+    async shouldInsertOneAndCascadeOneToManyWithSpecificFields() {
+        const itemAdjustments = [{ buyPrice: 50 }, { buyPrice: 300 }];
+        const inventoryAdjustmentId = await this.querier.insertOne(test_1.InventoryAdjustment, {
+            description: 'some description',
+            itemAdjustments: itemAdjustments.slice(),
+        });
+        expect(inventoryAdjustmentId).toBeDefined();
+        const inventoryAdjustmentFound = await this.querier.findOneById(test_1.InventoryAdjustment, inventoryAdjustmentId, {
+            $project: { itemAdjustments: ['buyPrice'] },
+        });
+        expect(inventoryAdjustmentFound).toMatchObject({
+            id: inventoryAdjustmentId,
+            itemAdjustments,
+        });
+        const itemAdjustmentsFound = await this.querier.findMany(test_1.ItemAdjustment, { $filter: { inventoryAdjustmentId } });
+        expect(itemAdjustmentsFound).toMatchObject(itemAdjustments);
+    }
+    async shouldUpdateOneAndCascadeOneToMany() {
+        const itemAdjustments = [{ buyPrice: 50 }, { buyPrice: 300 }];
+        const inventoryAdjustmentId = await this.querier.insertOne(test_1.InventoryAdjustment, {
+            description: 'some description',
+        });
+        expect(inventoryAdjustmentId).toBeDefined();
+        const changes = await this.querier.updateOneById(test_1.InventoryAdjustment, inventoryAdjustmentId, {
+            itemAdjustments,
+        });
+        expect(changes).toBe(1);
+        const inventoryAdjustmentFound = await this.querier.findOneById(test_1.InventoryAdjustment, inventoryAdjustmentId, {
+            $project: { itemAdjustments: ['buyPrice'] },
+        });
+        expect(inventoryAdjustmentFound).toMatchObject({
+            id: inventoryAdjustmentId,
+            itemAdjustments,
+        });
+        const itemAdjustmentsFound = await this.querier.findMany(test_1.ItemAdjustment, { $filter: { inventoryAdjustmentId } });
+        expect(itemAdjustmentsFound).toMatchObject(itemAdjustments);
+    }
+    async shouldUpdateOneByIdAndCascadeOneToManyNull() {
+        const id = await this.querier.insertOne(test_1.InventoryAdjustment, { itemAdjustments: [{}, {}] });
+        await expect(this.querier.count(test_1.ItemAdjustment)).resolves.toBe(2);
+        await this.querier.updateOneById(test_1.InventoryAdjustment, id, {
+            itemAdjustments: null,
+        });
+        await expect(this.querier.count(test_1.ItemAdjustment)).resolves.toBe(0);
+    }
+    async shouldUpdateManyAndCascadeOneToManyNull() {
+        await this.querier.insertOne(test_1.InventoryAdjustment, { itemAdjustments: [{}, {}] });
+        await expect(this.querier.count(test_1.ItemAdjustment)).resolves.toBe(2);
+        await this.querier.updateMany(test_1.InventoryAdjustment, { $filter: {} }, {
+            itemAdjustments: null,
+        });
+        await expect(this.querier.count(test_1.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(test_1.Item, payload);
+        expect(id).toBeDefined();
+        const foundItem = await this.querier.findOneById(test_1.Item, id, {
+            $project: { name: true, createdAt: true, tags: ['name', 'createdAt'] },
+        });
+        expect(foundItem).toMatchObject({
+            id,
+            ...payload,
+        });
+        const foundTags = await this.querier.findMany(test_1.Tag, {
+            $project: { 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(test_1.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(test_1.Item, id, payload);
+        const found = await this.querier.findOneById(test_1.Item, id, {
+            $project: { name: true, updatedAt: true, tags: true },
+        });
+        expect(found).toMatchObject({
+            id,
+            ...payload,
+        });
+    }
+    async shouldFindMany() {
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        const users = await this.querier.findMany(test_1.User, {
+            $project: ['name'],
+            $skip: 1,
+            $limit: 2,
+            $sort: {
+                name: 1,
+            },
+        });
+        expect(users).toMatchObject([
+            {
+                name: 'Some Name B',
+            },
+            {
+                name: 'Some Name C',
+            },
+        ]);
+    }
+    async shouldFindOne() {
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        const found = await this.querier.findOne(test_1.User, {
+            $project: ['id', 'name', 'email', 'password'],
+            $filter: {
+                email: 'someemaila@example.com',
+            },
+        });
+        expect(found).toMatchObject({
+            name: 'Some Name A',
+            email: 'someemaila@example.com',
+            password: '123456789a!',
+        });
+        const notFound = await this.querier.findOne(test_1.User, {
+            $filter: {
+                name: 'some name',
+            },
+        });
+        expect(notFound).toBeUndefined();
+    }
+    async shouldCount() {
+        await expect(this.querier.count(test_1.User, {})).resolves.toBe(0);
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        await expect(this.querier.count(test_1.User)).resolves.toBe(3);
+        await expect(this.querier.count(test_1.User, { $filter: { companyId: null } })).resolves.toBe(3);
+        await expect(this.querier.count(test_1.User, { $filter: { companyId: 1 } })).resolves.toBe(0);
+    }
+    async shouldUpdateMany() {
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        await expect(this.querier.updateMany(test_1.User, { $filter: { companyId: 1 } }, { companyId: null })).resolves.toBe(0);
+        await expect(this.querier.updateMany(test_1.User, { $filter: { companyId: null } }, { companyId: 1 })).resolves.toBe(3);
+        await expect(this.querier.updateMany(test_1.User, { $filter: { companyId: 1 } }, { companyId: null })).resolves.toBe(3);
+    }
+    async shouldThrowWhenRollbackTransactionWithoutBeginTransaction() {
+        await expect(this.querier.rollbackTransaction()).rejects.toThrow('not a pending transaction');
+    }
+    async shouldThrowIfUnknownComparisonOperator() {
+        await expect(this.querier.findMany(test_1.User, {
+            $filter: { name: { $someInvalidOperator: 'some' } },
+        })).rejects.toThrow('unknown operator: $someInvalidOperator');
+    }
+    async shouldCommit() {
+        await expect(this.querier.count(test_1.User)).resolves.toBe(0);
+        await this.querier.beginTransaction();
+        await this.querier.insertOne(test_1.User, {});
+        await expect(this.querier.count(test_1.User)).resolves.toBe(1);
+        await this.querier.commitTransaction();
+        await expect(this.querier.count(test_1.User)).resolves.toBe(1);
+    }
+    async shouldRollback() {
+        await expect(this.querier.count(test_1.User)).resolves.toBe(0);
+        await this.querier.beginTransaction();
+        await this.querier.insertOne(test_1.User, {});
+        await expect(this.querier.count(test_1.User)).resolves.toBe(1);
+        await this.querier.rollbackTransaction();
+        await expect(this.querier.count(test_1.User)).resolves.toBe(0);
+    }
+    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();
+    }
+    async shouldProjectOneToMany() {
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        const [user, company] = await Promise.all([
+            this.querier.findOne(test_1.User, { $project: ['id'] }),
+            this.querier.findOne(test_1.Company, { $project: ['id'] }),
+        ]);
+        const [firstItemId, secondItemId] = await this.querier.insertMany(test_1.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(test_1.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(test_1.InventoryAdjustment, inventoryAdjustmentId, {
+            $project: { itemAdjustments: true, creator: true },
+        });
+        expect(inventoryAdjustmentFound).toMatchObject({
+            id: inventoryAdjustmentId,
+            itemAdjustments: [
+                { buyPrice: 1000, itemId: firstItemId },
+                { buyPrice: 2000, itemId: secondItemId },
+            ],
+            creator: {
+                email: 'someemaila@example.com',
+                name: 'Some Name A',
+                password: '123456789a!',
+            },
+        });
+    }
+    async shouldDeleteMany() {
+        await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);
+        await expect(this.querier.deleteMany(test_1.User, { $filter: { companyId: 1 } })).resolves.toBe(0);
+        await expect(this.querier.deleteMany(test_1.User, { $filter: { companyId: null } })).resolves.toBe(3);
+    }
+    async shouldThrowWhenCommitTransactionWithoutBeginTransaction() {
+        await expect(this.querier.commitTransaction()).rejects.toThrow('not a pending transaction');
+    }
+    async clearTables() {
+        const entities = (0, entity_1.getEntities)();
+        await Promise.all(entities.map((entity) => this.querier.deleteMany(entity, {})));
+    }
+}
+exports.AbstractQuerierIt = AbstractQuerierIt;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractQuerier-it.js","sourceRoot":"","sources":["../../src/querier/abstractQuerier-it.ts"],"names":[],"mappings":";;;AACA,6CAA+C;AAC/C,yCAA8I;AAE9I,MAAsB,iBAAiB;IAGrC,YAAqB,IAAoB;QAApB,SAAI,GAAJ,IAAI,CAAgB;IAAG,CAAC;IAE7C,KAAK,CAAC,SAAS;QACb,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QAC5C,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;QACxB,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;QAC1B,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QAC5C,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,SAAS;QACb,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;IACxB,CAAC;IAED,mBAAmB;QACjB,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,WAAI,CAAC,CAAC;QACpD,MAAM,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,WAAI,EAAE;YAC9C;gBACE,IAAI,EAAE,aAAa;gBACnB,KAAK,EAAE,wBAAwB;gBAC/B,QAAQ,EAAE,aAAa;aACxB;YACD;gBACE,IAAI,EAAE,aAAa;gBACnB,KAAK,EAAE,wBAAwB;gBAC/B,QAAQ,EAAE,aAAa;aACxB;SACF,CAAC,CAAC;QACH,MAAM,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC5B,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;YACpB,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;SAC1B;IACH,CAAC;IAED,KAAK,CAAC,eAAe;QACnB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,WAAI,EAAE;YACnD,IAAI,EAAE,aAAa;YACnB,KAAK,EAAE,wBAAwB;YAC/B,QAAQ,EAAE,aAAa;SACxB,CAAC,CAAC;QACH,MAAM,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;QAEhC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,cAAO,EAAE;YACtD,IAAI,EAAE,aAAa;YACnB,SAAS;SACV,CAAC,CAAC;QACH,MAAM,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;QAEhC,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,kBAAW,EAAE;YAC9D,IAAI,EAAE,aAAa;YACnB,WAAW,EAAE,oBAAoB;YACjC,SAAS;YACT,SAAS;SACV,CAAC,CAAC;QACH,MAAM,CAAC,aAAa,CAAC,CAAC,WAAW,EAAE,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,6BAA6B;QACjC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,kBAAW,EAAE;YACpD,IAAI,EAAE,WAAW;SAClB,CAAC,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,kBAAW,EAAE;YACpD,EAAE,EAAE,KAAK;YACT,IAAI,EAAE,WAAW;SAClB,CAAC,CAAC;QACH,MAAM,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;QAC1B,MAAM,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,sDAAsD;QAC1D,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,kBAAW,EAAE;YACrD;gBACE,IAAI,EAAE,aAAa;aACpB;YACD;gBACE,EAAE,EAAE,IAAI;gBACR,IAAI,EAAE,aAAa;aACpB;YACD;gBACE,IAAI,EAAE,aAAa;aACpB;YACD;gBACE,EAAE,EAAE,IAAI;gBACR,IAAI,EAAE,aAAa;aACpB;SACF,CAAC,CAAC;QACH,MAAM,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC5B,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;YACpB,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;SAC1B;IACH,CAAC;IAED,KAAK,CAAC,4CAA4C;QAChD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,oBAAa,EAAE;YACvD;gBACE,IAAI,EAAE,aAAa;aACpB;YACD;gBACE,IAAI,EAAE,aAAa;aACpB;YACD;gBACE,IAAI,EAAE,aAAa;aACpB;SACF,CAAC,CAAC;QACH,MAAM,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC5B,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;YACpB,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;SAC1B;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,oBAAa,EAAE,EAAE,CAAC,CAAC;QAC9D,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAClD,CAAC;IAED,KAAK,CAAC,iCAAiC;QACrC,MAAM,OAAO,GAAS;YACpB,IAAI,EAAE,aAAa;YACnB,SAAS,EAAE,GAAG;YACd,OAAO,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE;SAC5C,CAAC;QACF,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,WAAI,EAAE,OAAO,CAAC,CAAC;QACvD,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,WAAI,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAClF,MAAM,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAChE,CAAC;IAED,KAAK,CAAC,kCAAkC;QACtC,MAAM,OAAO,GAAgB;YAC3B,IAAI,EAAE,YAAY;YAClB,SAAS,EAAE,GAAG;YACd,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,EAAE;SAC7C,CAAC;QAEF,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,kBAAW,EAAE,OAAO,CAAC,CAAC;QAE9D,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QAEzB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,kBAAW,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;QAEhG,MAAM,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAClE,CAAC;IAED,KAAK,CAAC,kCAAkC;QACtC,MAAM,eAAe,GAAqB,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC;QAEhF,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAExB,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,0BAAmB,EAAE;YAC9E,WAAW,EAAE,kBAAkB;YAC/B,IAAI;YACJ,eAAe;SAChB,CAAC,CAAC;QAEH,MAAM,CAAC,qBAAqB,CAAC,CAAC,WAAW,EAAE,CAAC;QAE5C,MAAM,wBAAwB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,0BAAmB,EAAE,qBAAqB,EAAE;YAC1G,QAAQ,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE;SACpC,CAAC,CAAC;QAEH,MAAM,CAAC,wBAAwB,CAAC,CAAC,aAAa,CAAC;YAC7C,EAAE,EAAE,qBAAqB;YACzB,eAAe;SAChB,CAAC,CAAC;QAEH,MAAM,oBAAoB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,qBAAc,EAAE,EAAE,OAAO,EAAE,EAAE,qBAAqB,EAAE,EAAE,CAAC,CAAC;QAEjH,MAAM,CAAC,oBAAoB,CAAC,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,oDAAoD;QACxD,MAAM,eAAe,GAAqB,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC;QAEhF,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,0BAAmB,EAAE;YAC9E,WAAW,EAAE,kBAAkB;YAC/B,eAAe,EAAE,eAAe,CAAC,KAAK,EAAE;SACzC,CAAC,CAAC;QAEH,MAAM,CAAC,qBAAqB,CAAC,CAAC,WAAW,EAAE,CAAC;QAE5C,MAAM,wBAAwB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,0BAAmB,EAAE,qBAAqB,EAAE;YAC1G,QAAQ,EAAE,EAAE,eAAe,EAAE,CAAC,UAAU,CAAC,EAAE;SAC5C,CAAC,CAAC;QAEH,MAAM,CAAC,wBAAwB,CAAC,CAAC,aAAa,CAAC;YAC7C,EAAE,EAAE,qBAAqB;YACzB,eAAe;SAChB,CAAC,CAAC;QAEH,MAAM,oBAAoB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,qBAAc,EAAE,EAAE,OAAO,EAAE,EAAE,qBAAqB,EAAE,EAAE,CAAC,CAAC;QAEjH,MAAM,CAAC,oBAAoB,CAAC,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,kCAAkC;QACtC,MAAM,eAAe,GAAqB,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC;QAEhF,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,0BAAmB,EAAE;YAC9E,WAAW,EAAE,kBAAkB;SAChC,CAAC,CAAC;QAEH,MAAM,CAAC,qBAAqB,CAAC,CAAC,WAAW,EAAE,CAAC;QAE5C,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,0BAAmB,EAAE,qBAAqB,EAAE;YAC3F,eAAe;SAChB,CAAC,CAAC;QAEH,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAExB,MAAM,wBAAwB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,0BAAmB,EAAE,qBAAqB,EAAE;YAC1G,QAAQ,EAAE,EAAE,eAAe,EAAE,CAAC,UAAU,CAAC,EAAE;SAC5C,CAAC,CAAC;QAEH,MAAM,CAAC,wBAAwB,CAAC,CAAC,aAAa,CAAC;YAC7C,EAAE,EAAE,qBAAqB;YACzB,eAAe;SAChB,CAAC,CAAC;QAEH,MAAM,oBAAoB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,qBAAc,EAAE,EAAE,OAAO,EAAE,EAAE,qBAAqB,EAAE,EAAE,CAAC,CAAC;QAEjH,MAAM,CAAC,oBAAoB,CAAC,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,0CAA0C;QAC9C,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,0BAAmB,EAAE,EAAE,eAAe,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;QAE5F,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAc,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAElE,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,0BAAmB,EAAE,EAAE,EAAE;YACxD,eAAe,EAAE,IAAI;SACtB,CAAC,CAAC;QAEH,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAc,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,KAAK,CAAC,uCAAuC;QAC3C,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,0BAAmB,EAAE,EAAE,eAAe,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;QAEjF,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAc,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAElE,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAC3B,0BAAmB,EACnB,EAAE,OAAO,EAAE,EAAE,EAAE,EACf;YACE,eAAe,EAAE,IAAI;SACtB,CACF,CAAC;QAEF,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAc,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,KAAK,CAAC,mCAAmC;QACvC,MAAM,OAAO,GAAS;YACpB,IAAI,EAAE,UAAU;YAChB,SAAS,EAAE,CAAC;YACZ,IAAI,EAAE;gBACJ;oBACE,IAAI,EAAE,SAAS;oBACf,SAAS,EAAE,CAAC;iBACb;gBACD;oBACE,IAAI,EAAE,SAAS;oBACf,SAAS,EAAE,CAAC;iBACb;aACF;SACF,CAAC;QAEF,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,WAAI,EAAE,OAAO,CAAC,CAAC;QAEvD,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;QAEzB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,WAAI,EAAE,EAAE,EAAE;YACzD,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE;SACvE,CAAC,CAAC;QAEH,MAAM,CAAC,SAAS,CAAC,CAAC,aAAa,CAAC;YAC9B,EAAE;YACF,GAAG,OAAO;SACX,CAAC,CAAC;QAEH,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAG,EAAE;YACjD,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE;SACxE,CAAC,CAAC;QAEH,OAAO,SAAS,CAAC,IAAI,CAAC;QAEtB,MAAM,CAAC,SAAS,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,KAAK,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC/F,CAAC;IAED,KAAK,CAAC,mCAAmC;QACvC,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,WAAI,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;QAChE,MAAM,OAAO,GAAS;YACpB,IAAI,EAAE,UAAU;YAChB,SAAS,EAAE,CAAC;YACZ,IAAI,EAAE;gBACJ;oBACE,IAAI,EAAE,SAAS;oBACf,SAAS,EAAE,CAAC;iBACb;gBACD;oBACE,IAAI,EAAE,SAAS;oBACf,SAAS,EAAE,CAAC;iBACb;aACF;SACF,CAAC;QAEF,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,WAAI,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC;QAEpD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,WAAI,EAAE,EAAE,EAAE;YACrD,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;SACtD,CAAC,CAAC;QAEH,MAAM,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC;YAC1B,EAAE;YACF,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,cAAc;QAClB,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QAErE,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAI,EAAE;YAC9C,QAAQ,EAAE,CAAC,MAAM,CAAC;YAClB,KAAK,EAAE,CAAC;YACR,MAAM,EAAE,CAAC;YACT,KAAK,EAAE;gBACL,IAAI,EAAE,CAAC;aACR;SACF,CAAC,CAAC;QAEH,MAAM,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC;YAC1B;gBACE,IAAI,EAAE,aAAa;aACpB;YACD;gBACE,IAAI,EAAE,aAAa;aACpB;SACF,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,aAAa;QACjB,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QAErE,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAI,EAAE;YAC7C,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC;YAC7C,OAAO,EAAE;gBACP,KAAK,EAAE,wBAAwB;aAChC;SACF,CAAC,CAAC;QAEH,MAAM,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC;YAC1B,IAAI,EAAE,aAAa;YACnB,KAAK,EAAE,wBAAwB;YAC/B,QAAQ,EAAE,aAAa;SACxB,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAI,EAAE;YAChD,OAAO,EAAE;gBACP,IAAI,EAAE,WAAW;aAClB;SACF,CAAC,CAAC;QAEH,MAAM,CAAC,QAAQ,CAAC,CAAC,aAAa,EAAE,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,WAAW;QACf,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAE5D,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QAErE,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,EAAE,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC1F,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,EAAE,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACzF,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QAErE,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,WAAI,EAAE,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACjH,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,WAAI,EAAE,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACjH,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,WAAI,EAAE,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACnH,CAAC;IAED,KAAK,CAAC,yDAAyD;QAC7D,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAChG,CAAC;IAED,KAAK,CAAC,sCAAsC;QAC1C,MAAM,MAAM,CACV,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAI,EAAE;YAC1B,OAAO,EAAE,EAAE,IAAI,EAAE,EAAE,oBAAoB,EAAE,MAAM,EAAS,EAAE;SAC3D,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,wCAAwC,CAAC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,YAAY;QAChB,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;QACtC,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,WAAI,EAAE,EAAE,CAAC,CAAC;QACvC,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC;QACvC,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC1D,CAAC;IAED,KAAK,CAAC,cAAc;QAClB,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;QACtC,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,WAAI,EAAE,EAAE,CAAC,CAAC;QACvC,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC;QACzC,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC1D,CAAC;IAED,KAAK,CAAC,oDAAoD;QACxD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,SAAS,EAAE,CAAC;QACpD,MAAM,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;QACtC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnD,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;QACrF,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;QAC5E,MAAM,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAC3C,CAAC;IAED,KAAK,CAAC,sBAAsB;QAC1B,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QAErE,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACxC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAChD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,cAAO,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;SACpD,CAAC,CAAC;QAEH,MAAM,CAAC,WAAW,EAAE,YAAY,CAAC,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,WAAI,EAAE;YACtE;gBACE,IAAI,EAAE,kBAAkB;gBACxB,SAAS,EAAE,IAAI,CAAC,EAAE;gBAClB,SAAS,EAAE,OAAO,CAAC,EAAE;aACtB;YACD;gBACE,IAAI,EAAE,kBAAkB;gBACxB,SAAS,EAAE,IAAI,CAAC,EAAE;gBAClB,SAAS,EAAE,OAAO,CAAC,EAAE;aACtB;SACF,CAAC,CAAC;QAEH,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,0BAAmB,EAAE;YAC9E,WAAW,EAAE,2BAA2B;YACxC,SAAS,EAAE,IAAI,CAAC,EAAE;YAClB,SAAS,EAAE,OAAO,CAAC,EAAE;YACrB,eAAe,EAAE;gBACf,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE;gBACvC,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE;aACzC;SACF,CAAC,CAAC;QAEH,MAAM,wBAAwB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,0BAAmB,EAAE,qBAAqB,EAAE;YAC1G,QAAQ,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE;SACnD,CAAC,CAAC;QAEH,MAAM,CAAC,wBAAwB,CAAC,CAAC,aAAa,CAAC;YAC7C,EAAE,EAAE,qBAAqB;YACzB,eAAe,EAAE;gBACf,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE;gBACvC,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE;aACzC;YACD,OAAO,EAAE;gBACP,KAAK,EAAE,wBAAwB;gBAC/B,IAAI,EAAE,aAAa;gBACnB,QAAQ,EAAE,aAAa;aACxB;SACF,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,gBAAgB;QACpB,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QACrE,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,WAAI,EAAE,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC5F,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,WAAI,EAAE,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACjG,CAAC;IAED,KAAK,CAAC,uDAAuD;QAC3D,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAC9F,CAAC;IAED,KAAK,CAAC,WAAW;QACf,MAAM,QAAQ,GAAG,IAAA,oBAAW,GAAE,CAAC;QAC/B,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IACnF,CAAC;CAKF;AArfD,8CAqfC","sourcesContent":["import { Querier, QuerierPool } from '@uql/core/type';\nimport { getEntities } from '@uql/core/entity';\nimport { Company, InventoryAdjustment, Item, ItemAdjustment, LedgerAccount, MeasureUnit, Spec, Tag, TaxCategory, User } from '@uql/core/test';\n\nexport abstract class AbstractQuerierIt<Q extends Querier> implements Spec {\n  querier: Q;\n\n  constructor(readonly pool: QuerierPool<Q>) {}\n\n  async beforeAll() {\n    this.querier = await this.pool.getQuerier();\n    await this.dropTables();\n    await this.createTables();\n    await this.querier.release();\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 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: User = {\n      name: 'Some Name D',\n      createdAt: 123,\n      profile: { picture: 'abc', createdAt: 123 },\n    };\n    const id = await this.querier.insertOne(User, payload);\n    expect(id).toBeDefined();\n    const found = await this.querier.findOneById(User, id, { $project: ['profile'] });\n    expect(found).toMatchObject({ id, profile: payload.profile });\n  }\n\n  async shouldInsertOneAndCascadeManyToOne() {\n    const payload: MeasureUnit = {\n      name: 'Centimeter',\n      createdAt: 123,\n      category: { name: 'Metric', 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, { $project: { category: true } });\n\n    expect(found).toMatchObject({ id, category: payload.category });\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      $project: { itemAdjustments: true },\n    });\n\n    expect(inventoryAdjustmentFound).toMatchObject({\n      id: inventoryAdjustmentId,\n      itemAdjustments,\n    });\n\n    const itemAdjustmentsFound = await this.querier.findMany(ItemAdjustment, { $filter: { 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      $project: { itemAdjustments: ['buyPrice'] },\n    });\n\n    expect(inventoryAdjustmentFound).toMatchObject({\n      id: inventoryAdjustmentId,\n      itemAdjustments,\n    });\n\n    const itemAdjustmentsFound = await this.querier.findMany(ItemAdjustment, { $filter: { 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      $project: { itemAdjustments: ['buyPrice'] },\n    });\n\n    expect(inventoryAdjustmentFound).toMatchObject({\n      id: inventoryAdjustmentId,\n      itemAdjustments,\n    });\n\n    const itemAdjustmentsFound = await this.querier.findMany(ItemAdjustment, { $filter: { 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      { $filter: {} },\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      $project: { 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      $project: { 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      $project: { name: true, updatedAt: true, tags: true },\n    });\n\n    expect(found).toMatchObject({\n      id,\n      ...payload,\n    });\n  }\n\n  async shouldFindMany() {\n    await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);\n\n    const users = await this.querier.findMany(User, {\n      $project: ['name'],\n      $skip: 1,\n      $limit: 2,\n      $sort: {\n        name: 1,\n      },\n    });\n\n    expect(users).toMatchObject([\n      {\n        name: 'Some Name B',\n      },\n      {\n        name: 'Some Name C',\n      },\n    ]);\n  }\n\n  async shouldFindOne() {\n    await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);\n\n    const found = await this.querier.findOne(User, {\n      $project: ['id', 'name', 'email', 'password'],\n      $filter: {\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      $filter: {\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, { $filter: { companyId: null } })).resolves.toBe(3);\n    await expect(this.querier.count(User, { $filter: { 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, { $filter: { companyId: 1 } }, { companyId: null })).resolves.toBe(0);\n    await expect(this.querier.updateMany(User, { $filter: { companyId: null } }, { companyId: 1 })).resolves.toBe(3);\n    await expect(this.querier.updateMany(User, { $filter: { companyId: 1 } }, { companyId: null })).resolves.toBe(3);\n  }\n\n  async shouldThrowWhenRollbackTransactionWithoutBeginTransaction() {\n    await expect(this.querier.rollbackTransaction()).rejects.toThrow('not a pending transaction');\n  }\n\n  async shouldThrowIfUnknownComparisonOperator() {\n    await expect(\n      this.querier.findMany(User, {\n        $filter: { name: { $someInvalidOperator: 'some' } as any },\n      })\n    ).rejects.toThrow('unknown operator: $someInvalidOperator');\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  }\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  }\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  }\n\n  async shouldProjectOneToMany() {\n    await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);\n\n    const [user, company] = await Promise.all([\n      this.querier.findOne(User, { $project: ['id'] }),\n      this.querier.findOne(Company, { $project: ['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      $project: { 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: 'someemaila@example.com',\n        name: 'Some Name A',\n        password: '123456789a!',\n      },\n    });\n  }\n\n  async shouldDeleteMany() {\n    await Promise.all([this.shouldInsertMany(), this.shouldInsertOne()]);\n    await expect(this.querier.deleteMany(User, { $filter: { companyId: 1 } })).resolves.toBe(0);\n    await expect(this.querier.deleteMany(User, { $filter: { companyId: null } })).resolves.toBe(3);\n  }\n\n  async shouldThrowWhenCommitTransactionWithoutBeginTransaction() {\n    await expect(this.querier.commitTransaction()).rejects.toThrow('not a pending transaction');\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/querier/abstractSqlQuerier-it.d.ts

@@ -0,0 +1,9 @@
+import { QuerierPool } from '@uql/core/type';
+import { AbstractQuerierIt } from './abstractQuerier-it';
+import { AbstractSqlQuerier } from './abstractSqlQuerier';
+export declare abstract class AbstractSqlQuerierIt extends AbstractQuerierIt<AbstractSqlQuerier> {
+    readonly idType: string;
+    constructor(pool: QuerierPool<AbstractSqlQuerier>, idType: string);
+    createTables(): Promise<void>;
+    dropTables(): Promise<void>;
+}

package/querier/abstractSqlQuerier-it.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSqlQuerierIt = void 0;
+const test_1 = require("@uql/core/test");
+const abstractQuerier_it_1 = require("./abstractQuerier-it");
+class AbstractSqlQuerierIt extends abstractQuerier_it_1.AbstractQuerierIt {
+    constructor(pool, idType) {
+        super(pool);
+        this.idType = idType;
+    }
+    createTables() {
+        return (0, test_1.createTables)(this.querier, this.idType);
+    }
+    dropTables() {
+        return (0, test_1.dropTables)(this.querier);
+    }
+}
+exports.AbstractSqlQuerierIt = AbstractSqlQuerierIt;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3RTcWxRdWVyaWVyLWl0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3F1ZXJpZXIvYWJzdHJhY3RTcWxRdWVyaWVyLWl0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLHlDQUEwRDtBQUMxRCw2REFBeUQ7QUFHekQsTUFBc0Isb0JBQXFCLFNBQVEsc0NBQXFDO0lBQ3RGLFlBQVksSUFBcUMsRUFBVyxNQUFjO1FBQ3hFLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUQ4QyxXQUFNLEdBQU4sTUFBTSxDQUFRO0lBRTFFLENBQUM7SUFFUSxZQUFZO1FBQ25CLE9BQU8sSUFBQSxtQkFBWSxFQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2pELENBQUM7SUFFUSxVQUFVO1FBQ2pCLE9BQU8sSUFBQSxpQkFBVSxFQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNsQyxDQUFDO0NBQ0Y7QUFaRCxvREFZQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFF1ZXJpZXJQb29sIH0gZnJvbSAnQHVxbC9jb3JlL3R5cGUnO1xuaW1wb3J0IHsgY3JlYXRlVGFibGVzLCBkcm9wVGFibGVzIH0gZnJvbSAnQHVxbC9jb3JlL3Rlc3QnO1xuaW1wb3J0IHsgQWJzdHJhY3RRdWVyaWVySXQgfSBmcm9tICcuL2Fic3RyYWN0UXVlcmllci1pdCc7XG5pbXBvcnQgeyBBYnN0cmFjdFNxbFF1ZXJpZXIgfSBmcm9tICcuL2Fic3RyYWN0U3FsUXVlcmllcic7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdFNxbFF1ZXJpZXJJdCBleHRlbmRzIEFic3RyYWN0UXVlcmllckl0PEFic3RyYWN0U3FsUXVlcmllcj4ge1xuICBjb25zdHJ1Y3Rvcihwb29sOiBRdWVyaWVyUG9vbDxBYnN0cmFjdFNxbFF1ZXJpZXI+LCByZWFkb25seSBpZFR5cGU6IHN0cmluZykge1xuICAgIHN1cGVyKHBvb2wpO1xuICB9XG5cbiAgb3ZlcnJpZGUgY3JlYXRlVGFibGVzKCkge1xuICAgIHJldHVybiBjcmVhdGVUYWJsZXModGhpcy5xdWVyaWVyLCB0aGlzLmlkVHlwZSk7XG4gIH1cblxuICBvdmVycmlkZSBkcm9wVGFibGVzKCkge1xuICAgIHJldHVybiBkcm9wVGFibGVzKHRoaXMucXVlcmllcik7XG4gIH1cbn1cbiJdfQ==

package/querier/abstractSqlQuerier-spec.d.ts

@@ -0,0 +1,53 @@
+import { Spec } from '@uql/core/test';
+import { QuerierPool } from '@uql/core/type';
+import { AbstractSqlQuerier } from './abstractSqlQuerier';
+export declare abstract class AbstractSqlQuerierSpec implements Spec {
+    readonly pool: QuerierPool<AbstractSqlQuerier>;
+    readonly idType: string;
+    querier: AbstractSqlQuerier;
+    constructor(pool: QuerierPool<AbstractSqlQuerier>, idType: string);
+    beforeAll(): Promise<void>;
+    beforeEach(): Promise<void>;
+    afterEach(): Promise<void>;
+    afterAll(): Promise<void>;
+    shouldFindOneById(): Promise<void>;
+    shouldFindOne(): Promise<void>;
+    shouldFindOneAndProjectOneToMany(): Promise<void>;
+    shouldFindAndProjectRaw(): Promise<void>;
+    shouldVirtualField(): Promise<void>;
+    shouldFind$exists(): Promise<void>;
+    shouldFind$nexists(): Promise<void>;
+    shouldFindOneAndProjectOneToManyOnly(): Promise<void>;
+    shouldFindOneAndProjectOneToManyWithSpecifiedFields(): Promise<void>;
+    shouldFindManyAndProjectOneToMany(): Promise<void>;
+    shouldFindOneAndProjectManyToMany(): Promise<void>;
+    shouldFindOneByIdAndProjectManyToMany(): Promise<void>;
+    shouldFindMany(): Promise<void>;
+    shouldFindManyAndCount(): Promise<void>;
+    shouldInsertOne(): Promise<void>;
+    shouldInsertOneAndCascadeOneToOne(): Promise<void>;
+    shouldInsertOneAndCascadeManyToOne(): Promise<void>;
+    shouldInsertOneAndCascadeOneToMany(): Promise<void>;
+    shouldUpdateMany(): Promise<void>;
+    shouldUpdateOneById(): Promise<void>;
+    shouldUpdateOneByIdAndCascadeOneToOne(): Promise<void>;
+    shouldUpdateOneByIdAndCascadeOneToOneNull(): Promise<void>;
+    shouldUpdateOneByIdAndCascadeOneToMany(): Promise<void>;
+    shouldUpdateOneByIdAndCascadeOneToManyNull(): Promise<void>;
+    shouldUpdateManyAndCascadeOneToManyNull(): Promise<void>;
+    shouldInsertOneAndCascadeManyToManyInserts(): Promise<void>;
+    shouldUpdateAndCascadeManyToManyInserts(): Promise<void>;
+    shouldUpdateAndCascadeManyToManyLinks(): Promise<void>;
+    shouldDeleteOneAndCascadeManyToManyDeletes(): Promise<void>;
+    shouldDeleteOneAndNoCascadeManyToManyDeletes(): Promise<void>;
+    shouldDeleteOneById(): Promise<void>;
+    shouldDeleteMany(): Promise<void>;
+    shouldCount(): Promise<void>;
+    shouldUseTransaction(): Promise<void>;
+    shouldUseTransactionCallback(): Promise<void>;
+    shouldThrowIfRollbackIfErrorInCallback(): Promise<void>;
+    shouldThrowIfTransactionIsPending(): Promise<void>;
+    shouldThrowIfCommitWithNoPendingTransaction(): Promise<void>;
+    shouldThrowIfRollbackWithNoPendingTransaction(): Promise<void>;
+    shouldThrowIfReleaseWithPendingTransaction(): Promise<void>;
+}