@ts-awesome/orm 1.5.0 → 1.5.1

package/tests/builder.spec.js

@@ -0,0 +1,604 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dist_1 = require("../dist");
+const models_1 = require("./models");
+const builder_1 = require("../dist/builder");
+const dist_2 = require("../dist");
+const tableInfo = (0, builder_1.readModelMeta)(models_1.Person);
+const tableName = tableInfo.tableName;
+const person = { id: 1, name: 'Name', age: 18, city: 'City', profiles: ["profile-a"] };
+describe('Select', () => {
+    it('Check query info', () => {
+        const query = (0, dist_1.Select)(models_1.Person);
+        expect(query._type).toBe('SELECT');
+        expect(query._table).toStrictEqual(tableInfo);
+    });
+    it('Columns through array list', () => {
+        const nameAlias = 'PersonName';
+        const coefficient = 2;
+        const columnsThroughList = (0, dist_1.Select)(models_1.Person).columns(['name', 'age']);
+        const columnsThroughBuilder = (0, dist_1.Select)(models_1.Person).columns(({ name, age }) => [name, age]);
+        const columnsWithAlias = (0, dist_1.Select)(models_1.Person).columns(({ name }) => [(0, dist_1.alias)(name, nameAlias)]);
+        const columnsWithOf = (0, dist_1.Select)(models_1.Person).columns(() => [(0, dist_1.of)(models_1.Employee, 'company')]);
+        const columnsWithExpression = (0, dist_1.Select)(models_1.Person).columns(({ age }) => [age.mul(coefficient), (0, dist_1.max)(age)]);
+        const expectation = {
+            default: [
+                { _column: { table: tableName, name: 'name' } },
+                { _column: { table: tableName, name: 'age' } }
+            ],
+            alias: [
+                { _alias: nameAlias, _operands: [{ _column: { table: tableName, name: 'name' } }] }
+            ],
+            of: [
+                { _column: { table: (0, builder_1.readModelMeta)(models_1.Employee).tableName, name: 'company' } }
+            ],
+            expression: [
+                { _operator: '*', _operands: [{ _column: { table: tableName, name: 'age' } }, coefficient] },
+                { _func: 'MAX', _args: [{ _column: { table: tableName, name: 'age' } }] }
+            ]
+        };
+        expect(columnsThroughList._columns).toStrictEqual(expectation.default);
+        expect(columnsThroughBuilder._columns).toStrictEqual(expectation.default);
+        expect(columnsWithAlias._columns).toStrictEqual(expectation.alias);
+        expect(columnsWithOf._columns).toStrictEqual(expectation.of);
+        expect(columnsWithExpression._columns).toStrictEqual(expectation.expression);
+    });
+    it('Joins', () => {
+        const employeeTableInfo = (0, builder_1.readModelMeta)(models_1.Employee);
+        const innerJoin = (0, dist_1.Select)(models_1.Person).join(models_1.Employee, ({ id }, { personId }) => id.eq(personId));
+        const leftJoin = (0, dist_1.Select)(models_1.Person).joinLeft(models_1.Employee, ({ id }, { personId }) => id.eq(personId));
+        const rightJoin = (0, dist_1.Select)(models_1.Person).joinRight(models_1.Employee, ({ id }, { personId }) => id.eq(personId));
+        const fullJoin = (0, dist_1.Select)(models_1.Person).joinFull(models_1.Employee, ({ id }, { personId }) => id.eq(personId));
+        const innerJoinExpectation = [{
+                _tableName: employeeTableInfo.tableName,
+                _alias: undefined,
+                _type: "INNER" /* joinTypes.inner */,
+                _condition: {
+                    _operands: [{ _column: { table: tableName, name: 'id' } }, { _column: { table: employeeTableInfo.tableName, name: `personId` } }],
+                    _operator: '='
+                }
+            }];
+        const leftJoinExpectation = [{
+                _tableName: employeeTableInfo.tableName,
+                _alias: undefined,
+                _type: "LEFT" /* joinTypes.left */,
+                _condition: {
+                    _operands: [{ _column: { table: tableName, name: 'id' } }, { _column: { table: employeeTableInfo.tableName, name: `personId` } }],
+                    _operator: '='
+                }
+            }];
+        const rightJoinExpectation = [{
+                _tableName: employeeTableInfo.tableName,
+                _alias: undefined,
+                _type: "RIGHT" /* joinTypes.right */,
+                _condition: {
+                    _operands: [{ _column: { table: tableName, name: 'id' } }, { _column: { table: employeeTableInfo.tableName, name: `personId` } }],
+                    _operator: '='
+                }
+            }];
+        const fullJoinExpectation = [{
+                _tableName: employeeTableInfo.tableName,
+                _alias: undefined,
+                _type: "FULL OUTER" /* joinTypes.full */,
+                _condition: {
+                    _operands: [{ _column: { table: tableName, name: 'id' } }, { _column: { table: employeeTableInfo.tableName, name: `personId` } }],
+                    _operator: '='
+                }
+            }];
+        expect(innerJoin._joins).toStrictEqual(innerJoinExpectation);
+        expect(leftJoin._joins).toStrictEqual(leftJoinExpectation);
+        expect(rightJoin._joins).toStrictEqual(rightJoinExpectation);
+        expect(fullJoin._joins).toStrictEqual(fullJoinExpectation);
+    });
+    it('Joins with alias', () => {
+        const tableRef = new builder_1.TableRef(models_1.Employee);
+        const employeeTableInfo = (0, builder_1.readModelMeta)(models_1.Employee);
+        const innerJoin = (0, dist_1.Select)(models_1.Person).join(models_1.Employee, tableRef, ({ id }, { personId }) => id.eq(personId));
+        const leftJoin = (0, dist_1.Select)(models_1.Person).joinLeft(models_1.Employee, tableRef, ({ id }, { personId }) => id.eq(personId));
+        const rightJoin = (0, dist_1.Select)(models_1.Person).joinRight(models_1.Employee, tableRef, ({ id }, { personId }) => id.eq(personId));
+        const fullJoin = (0, dist_1.Select)(models_1.Person).joinFull(models_1.Employee, tableRef, ({ id }, { personId }) => id.eq(personId));
+        const innerJoinExpectation = [{
+                _tableName: employeeTableInfo.tableName,
+                _alias: tableRef.tableName,
+                _type: "INNER" /* joinTypes.inner */,
+                _condition: {
+                    _operands: [{ _column: { table: tableName, name: 'id' } }, { _column: { table: tableRef.tableName, name: `personId` } }],
+                    _operator: '='
+                }
+            }];
+        const leftJoinExpectation = [{
+                _tableName: employeeTableInfo.tableName,
+                _alias: tableRef.tableName,
+                _type: "LEFT" /* joinTypes.left */,
+                _condition: {
+                    _operands: [{ _column: { table: tableName, name: 'id' } }, { _column: { table: tableRef.tableName, name: `personId` } }],
+                    _operator: '='
+                }
+            }];
+        const rightJoinExpectation = [{
+                _tableName: employeeTableInfo.tableName,
+                _alias: tableRef.tableName,
+                _type: "RIGHT" /* joinTypes.right */,
+                _condition: {
+                    _operands: [{ _column: { table: tableName, name: 'id' } }, { _column: { table: tableRef.tableName, name: `personId` } }],
+                    _operator: '='
+                }
+            }];
+        const fullJoinExpectation = [{
+                _tableName: employeeTableInfo.tableName,
+                _alias: tableRef.tableName,
+                _type: "FULL OUTER" /* joinTypes.full */,
+                _condition: {
+                    _operands: [{ _column: { table: tableName, name: 'id' } }, { _column: { table: tableRef.tableName, name: `personId` } }],
+                    _operator: '='
+                }
+            }];
+        expect(innerJoin._joins).toStrictEqual(innerJoinExpectation);
+        expect(leftJoin._joins).toStrictEqual(leftJoinExpectation);
+        expect(rightJoin._joins).toStrictEqual(rightJoinExpectation);
+        expect(fullJoin._joins).toStrictEqual(fullJoinExpectation);
+    });
+    it('Where', () => {
+        const query = (0, dist_1.Select)(models_1.Person).where(({ age, name }) => (0, dist_1.and)(age.eq(person.age), name.like(person.name)));
+        const expectation = [{
+                _operator: 'AND',
+                _operands: [
+                    { _operator: '=', _operands: [{ _column: { table: tableName, name: 'age' } }, person.age] },
+                    { _operator: 'LIKE', _operands: [{ _column: { table: tableName, name: 'name' } }, person.name] },
+                ]
+            }];
+        expect(query._where).toStrictEqual(expectation);
+    });
+    describe('Where filter fields', () => {
+        it('simple many to many', () => {
+            const query = (0, dist_1.Select)(models_1.Person).where(({ profiles }) => profiles.has('test'));
+            const expectation = [{
+                    _operands: [
+                        "test",
+                        {
+                            _operator: 'SUBQUERY',
+                            _operands: [
+                                {
+                                    _columns: [{ _column: { table: "employee", name: "title" } }],
+                                    _table: { fields: null, tableName: "employee" },
+                                    _type: "SELECT",
+                                    _where: [
+                                        {
+                                            _operands: [
+                                                { _column: { table: "employee", name: "person" } },
+                                                { _column: { table: tableName, name: "id" } }
+                                            ],
+                                            _operator: "="
+                                        }
+                                    ],
+                                }
+                            ]
+                        },
+                    ],
+                    _operator: "IN",
+                }];
+            expect(query._where).toStrictEqual(expectation);
+        });
+        it('with builder', () => {
+            const query = (0, dist_1.Select)(models_1.Person).where(({ tags }) => tags.has('tag'));
+            const expectation = [{
+                    _operands: [
+                        "tag",
+                        {
+                            _operator: 'SUBQUERY',
+                            _operands: [
+                                {
+                                    _columns: [{ _column: { table: "Tag", name: "name" } }],
+                                    _table: (0, builder_1.readModelMeta)(models_1.Tag),
+                                    _alias: null,
+                                    _type: "SELECT",
+                                    _distinct: false,
+                                    "_for": undefined,
+                                    _joins: [
+                                        {
+                                            _alias: undefined,
+                                            _tableName: "TagPerson",
+                                            _type: "INNER",
+                                            _condition: {
+                                                _operands: [
+                                                    {
+                                                        _operands: [
+                                                            {
+                                                                _column: {
+                                                                    name: 'id',
+                                                                    table: "Tag",
+                                                                }
+                                                            },
+                                                            {
+                                                                _column: {
+                                                                    name: 'tag',
+                                                                    table: "TagPerson",
+                                                                }
+                                                            }
+                                                        ],
+                                                        _operator: '='
+                                                    },
+                                                    {
+                                                        _operands: [
+                                                            {
+                                                                _column: {
+                                                                    name: 'person',
+                                                                    table: "TagPerson",
+                                                                }
+                                                            },
+                                                            {
+                                                                _column: {
+                                                                    name: 'id',
+                                                                    table: "Person",
+                                                                }
+                                                            }
+                                                        ],
+                                                        _operator: '='
+                                                    },
+                                                ],
+                                                _operator: 'AND'
+                                            }
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                    ],
+                    _operator: "IN",
+                }];
+            expect(query._where).toStrictEqual(expectation);
+        });
+    });
+    it('Having', () => {
+        const employeeTableName = (0, builder_1.readModelMeta)(models_1.Employee).tableName;
+        const salaryRate = 2000;
+        const query = (0, dist_1.Select)(models_1.Employee)
+            .columns(({ salary }) => [(0, dist_1.sum)(salary)])
+            .groupBy(['company'])
+            .having(({ salary }) => (0, dist_1.sum)(salary).gt(salaryRate));
+        const expectation = {
+            _columns: [{ _func: 'SUM', _args: [{ _column: { table: employeeTableName, name: 'salary' } }] }],
+            _groupBy: [{ _column: { table: employeeTableName, name: 'company' } }],
+            _having: [{
+                    _operator: '>',
+                    _operands: [{
+                            _func: 'SUM',
+                            _args: [{ _column: { table: employeeTableName, name: 'salary' } }]
+                        }, salaryRate]
+                }]
+        };
+        expect(query._columns).toStrictEqual(expectation._columns);
+        expect(query._groupBy).toStrictEqual(expectation._groupBy);
+        expect(query._having).toStrictEqual(expectation._having);
+    });
+    it('Group by', () => {
+        const queryThroughList = (0, dist_1.Select)(models_1.Person).groupBy(['city']);
+        const queryThroughBuilder = (0, dist_1.Select)(models_1.Person).groupBy(({ city }) => [city]);
+        const expectation = [{ _column: { table: tableName, name: 'city' } }];
+        expect(queryThroughList._groupBy).toStrictEqual(expectation);
+        expect(queryThroughBuilder._groupBy).toStrictEqual(expectation);
+    });
+    it('Order By', () => {
+        const orderByThroughList = (0, dist_1.Select)(models_1.Person).orderBy(['city']);
+        const defaultOrder = (0, dist_1.Select)(models_1.Person).orderBy(({ city }) => [city]);
+        const ascOrder = (0, dist_1.Select)(models_1.Person).orderBy(({ city }) => [(0, dist_1.asc)(city)]);
+        const descOrder = (0, dist_1.Select)(models_1.Person).orderBy(({ city }) => [(0, dist_1.desc)(city)]);
+        const numberedOrder = (0, dist_1.Select)(models_1.Person).orderBy(() => [(0, dist_1.asc)(0), (0, dist_1.desc)(1)]);
+        const expectation = {
+            default: [{ _column: { table: tableName, name: 'city' } }],
+            asc: [{ _column: { table: tableName, name: 'city' }, _order: 'ASC' }],
+            desc: [{ _column: { table: tableName, name: 'city' }, _order: 'DESC' }],
+            numbered: [{ _column: 0, _order: 'ASC' }, { _column: 1, _order: 'DESC' }],
+        };
+        expect(orderByThroughList._orderBy).toStrictEqual(expectation.default);
+        expect(defaultOrder._orderBy).toStrictEqual(expectation.default);
+        expect(ascOrder._orderBy).toStrictEqual(expectation.asc);
+        expect(descOrder._orderBy).toStrictEqual(expectation.desc);
+        expect(numberedOrder._orderBy).toStrictEqual(expectation.numbered);
+    });
+    it('Limit', () => {
+        const limit = 10;
+        const query = (0, dist_1.Select)(models_1.Person).limit(limit);
+        expect(query._limit).toBe(limit);
+    });
+    it('Offset', () => {
+        const offset = 3;
+        const query = (0, dist_1.Select)(models_1.Person).offset(offset);
+        expect(query._offset).toBe(offset);
+    });
+    it('subquery on self', () => {
+        const query = (0, dist_1.Select)(models_1.Person).where(({ id }) => (0, dist_2.exists)((0, dist_1.Select)((0, dist_1.alias)(models_1.Person, 'person_filter')).where(({ id: _ }) => _.eq(id))));
+        const expectation = {
+            _where: [{
+                    "_operands": [{
+                            "_alias": "person_filter",
+                            "_columns": [
+                                { "_column": { name: 'id', table: 'person_filter' } },
+                                { "_column": { name: 'uid', table: 'person_filter' } },
+                                { "_column": { name: 'name', table: 'person_filter' } },
+                                { "_column": { name: 'age', table: 'person_filter' } },
+                                { "_column": { name: 'city', table: 'person_filter' } },
+                            ],
+                            "_distinct": false,
+                            "_for": undefined,
+                            "_table": models_1.Person[dist_1.TableMetadataSymbol],
+                            "_type": "SELECT",
+                            "_where": [{
+                                    "_operands": [{
+                                            "_column": { "name": "id", "table": "person_filter", },
+                                        }, {
+                                            "_column": { "name": "id", "table": "Person", },
+                                        }],
+                                    "_operator": "=",
+                                }]
+                        }],
+                    "_operator": "EXISTS",
+                }]
+        };
+        expect(query._where).toStrictEqual(expectation._where);
+    });
+    it('sum of subqueries', () => {
+        let PersonAction = class PersonAction {
+        };
+        __decorate([
+            dist_2.dbField,
+            __metadata("design:type", Number)
+        ], PersonAction.prototype, "personId", void 0);
+        __decorate([
+            dist_2.dbField,
+            __metadata("design:type", String)
+        ], PersonAction.prototype, "action", void 0);
+        __decorate([
+            dist_2.dbField,
+            __metadata("design:type", Date)
+        ], PersonAction.prototype, "created", void 0);
+        PersonAction = __decorate([
+            (0, dist_2.dbTable)('actions')
+        ], PersonAction);
+        const ts = new Date(Date.now() - 3600);
+        const query = (0, dist_1.Select)(models_1.Person)
+            .columns(({ uid }) => [
+            uid,
+            (0, dist_1.alias)((0, dist_1.Select)(PersonAction)
+                .columns(() => [(0, dist_2.count)()])
+                .where(({ personId, action, created }) => (0, dist_1.and)(personId.eq((0, dist_1.of)(models_1.Person, 'id')), action.eq('a'), created.gte(ts)))
+                .asScalar()
+                .mul(1).add((0, dist_1.Select)(PersonAction)
+                .columns(() => [(0, dist_2.count)()])
+                .where(({ personId, action, created }) => (0, dist_1.and)(personId.eq((0, dist_1.of)(models_1.Person, 'id')), action.eq('b'), created.gte(ts)))
+                .asScalar().mul(100)).add((0, dist_1.Select)(PersonAction)
+                .columns(() => [(0, dist_2.count)()])
+                .where(({ personId, action, created }) => (0, dist_1.and)(personId.eq((0, dist_1.of)(models_1.Person, 'id')), action.eq('c'), created.gte(ts)))
+                .asScalar().mul(100)), 'score')
+        ]).orderBy(() => [(0, dist_1.desc)((0, dist_1.of)(null, 'score'))]);
+        const expected = [{ "_column": { "table": "Person", "name": "uid" } }, {
+                "_alias": "score", "_operands": [{
+                        "_operator": "+", "_operands": [{
+                                "_operator": "+",
+                                "_operands": [{
+                                        "_operator": "*",
+                                        "_operands": [{
+                                                "_operator": "SUBQUERY",
+                                                "_operands": [{
+                                                        "_type": "SELECT",
+                                                        "_table": PersonAction[dist_1.TableMetadataSymbol],
+                                                        "_alias": null,
+                                                        "_distinct": false,
+                                                        "_for": undefined,
+                                                        "_columns": [{ "_func": "COUNT", "_args": ["*"] }],
+                                                        "_where": [{
+                                                                "_operator": "AND",
+                                                                "_operands": [{
+                                                                        "_operator": "=",
+                                                                        "_operands": [{ "_column": { "table": "actions", "name": "personId" } }, {
+                                                                                "_column": {
+                                                                                    "table": "Person",
+                                                                                    "name": "id"
+                                                                                }
+                                                                            }]
+                                                                    }, {
+                                                                        "_operator": "=",
+                                                                        "_operands": [{ "_column": { "table": "actions", "name": "action" } }, "a"]
+                                                                    }, {
+                                                                        "_operator": ">=",
+                                                                        "_operands": [{ "_column": { "table": "actions", "name": "created" } }, ts]
+                                                                    }]
+                                                            }]
+                                                    }]
+                                            }, 1]
+                                    }, {
+                                        "_operator": "*",
+                                        "_operands": [{
+                                                "_operator": "SUBQUERY",
+                                                "_operands": [{
+                                                        "_type": "SELECT",
+                                                        "_table": PersonAction[dist_1.TableMetadataSymbol],
+                                                        "_alias": null,
+                                                        "_distinct": false,
+                                                        "_for": undefined,
+                                                        "_columns": [{ "_func": "COUNT", "_args": ["*"] }],
+                                                        "_where": [{
+                                                                "_operator": "AND",
+                                                                "_operands": [{
+                                                                        "_operator": "=",
+                                                                        "_operands": [{ "_column": { "table": "actions", "name": "personId" } }, {
+                                                                                "_column": {
+                                                                                    "table": "Person",
+                                                                                    "name": "id"
+                                                                                }
+                                                                            }]
+                                                                    }, {
+                                                                        "_operator": "=",
+                                                                        "_operands": [{ "_column": { "table": "actions", "name": "action" } }, "b"]
+                                                                    }, {
+                                                                        "_operator": ">=",
+                                                                        "_operands": [{ "_column": { "table": "actions", "name": "created" } }, ts]
+                                                                    }]
+                                                            }]
+                                                    }]
+                                            }, 100]
+                                    }]
+                            }, {
+                                "_operator": "*",
+                                "_operands": [{
+                                        "_operator": "SUBQUERY",
+                                        "_operands": [{
+                                                "_type": "SELECT",
+                                                "_table": PersonAction[dist_1.TableMetadataSymbol],
+                                                "_alias": null,
+                                                "_distinct": false,
+                                                "_for": undefined,
+                                                "_columns": [{ "_func": "COUNT", "_args": ["*"] }],
+                                                "_where": [{
+                                                        "_operator": "AND",
+                                                        "_operands": [{
+                                                                "_operator": "=",
+                                                                "_operands": [{ "_column": { "table": "actions", "name": "personId" } }, {
+                                                                        "_column": {
+                                                                            "table": "Person",
+                                                                            "name": "id"
+                                                                        }
+                                                                    }]
+                                                            }, {
+                                                                "_operator": "=",
+                                                                "_operands": [{ "_column": { "table": "actions", "name": "action" } }, "c"]
+                                                            }, {
+                                                                "_operator": ">=",
+                                                                "_operands": [{ "_column": { "table": "actions", "name": "created" } }, ts]
+                                                            }]
+                                                    }]
+                                            }]
+                                    }, 100]
+                            }]
+                    }]
+            }];
+        expect(query._columns).toStrictEqual(expected);
+        expect(query._orderBy).toStrictEqual([{
+                _column: {
+                    name: 'score',
+                },
+                _order: "DESC"
+            }]);
+    });
+    it('invalid sub queries', () => {
+        try {
+            (0, dist_1.Select)(models_1.Person).columns(['age', 'uid']).asScalar();
+            fail('expected to throw');
+        }
+        catch (e) {
+            // ignore
+        }
+    });
+});
+describe('Insert', () => {
+    it('Check query info', () => {
+        const query = (0, dist_1.Insert)(models_1.Person);
+        expect(query._type).toBe('INSERT');
+        expect(query._table).toStrictEqual(tableInfo);
+    });
+    it('Insert record', () => {
+        const query = (0, dist_1.Insert)(models_1.Person).values(person);
+        const expectation = {
+            id: person.id,
+            name: person.name,
+            age: person.age,
+            city: person.city,
+        };
+        expect(query._values).toStrictEqual(expectation);
+        (0, dist_1.Insert)(models_1.Person).values(Object.assign(Object.assign({}, person), { uid: 'a80ec30e-791c-4499-a243-70af8b2bf7ba' }));
+    });
+});
+describe('Upsert', () => {
+    const infoMock = {
+        [dist_1.TableMetadataSymbol]: {}
+    };
+    it('Check query info', () => {
+        const query = (0, dist_1.Upsert)(models_1.Person);
+        expect(query._type).toBe('UPSERT');
+        expect(query._table).toStrictEqual(tableInfo);
+    });
+    it('Upsert record', () => {
+        const defaultUpsert = (0, dist_1.Upsert)(models_1.Person).values(person);
+        const withConflict = (0, dist_1.Upsert)(models_1.Person).values(person).conflict('idx');
+        const expectation = {
+            values: {
+                id: person.id,
+                name: person.name,
+                age: person.age,
+                city: person.city,
+            },
+            conflictExp: { _columns: ['id'], _where: undefined }
+        };
+        expect(defaultUpsert._values).toStrictEqual(expectation.values);
+        expect(defaultUpsert._conflictExp).toBeUndefined();
+        expect(withConflict._values).toStrictEqual(expectation.values);
+        expect(withConflict._conflictExp).toStrictEqual(expectation.conflictExp);
+    });
+    it('Should fail if table has no primary key', () => {
+        expect(() => {
+            (0, dist_1.Upsert)(infoMock).conflict();
+        }).toThrowError('Current table has no primary key. Please provide unique index for upsert');
+    });
+    it('Should fail if table indexes meta is empty', () => {
+        expect(() => {
+            (0, dist_1.Upsert)(infoMock).conflict('id');
+        }).toThrowError('Table indexes meta is empty');
+    });
+    it('Should fail if index is not declared', () => {
+        expect(() => {
+            (0, dist_1.Upsert)(models_1.Person).conflict('name');
+        }).toThrowError(`Index name is not declared for table ${tableName}`);
+    });
+});
+describe('Update', () => {
+    it('Check query info', () => {
+        const query = (0, dist_1.Update)(models_1.Person);
+        expect(query._type).toBe('UPDATE');
+        expect(query._table).toStrictEqual(tableInfo);
+    });
+    it('Update record', () => {
+        const limit = 10;
+        const query = (0, dist_1.Update)(models_1.Person).values(person).where(({ id }) => id.eq(person.id)).limit(limit);
+        const expectation = {
+            values: {
+                id: person.id,
+                name: person.name,
+                age: person.age,
+                city: person.city,
+            },
+            where: [{
+                    _operator: '=',
+                    _operands: [{ _column: { table: tableName, name: 'id' } }, person.id]
+                }]
+        };
+        expect(query._values).toStrictEqual(expectation.values);
+        expect(query._where).toStrictEqual(expectation.where);
+        expect(query._limit).toBe(limit);
+    });
+});
+describe('Delete', () => {
+    it('Check query info', () => {
+        const query = (0, dist_1.Delete)(models_1.Person);
+        expect(query._type).toBe('DELETE');
+        expect(query._table).toStrictEqual(tableInfo);
+    });
+    it('Delete record', () => {
+        const limit = 10;
+        const query = (0, dist_1.Delete)(models_1.Person).where(({ id }) => id.eq(person.id)).limit(limit);
+        const expectation = [{
+                _operator: '=',
+                _operands: [{ _column: { table: tableName, name: 'id' } }, person.id]
+            }];
+        expect(query._where).toStrictEqual(expectation);
+        expect(query._limit).toBe(limit);
+    });
+});

package/tests/executor.spec.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const wrappers_1 = require("../src/wrappers");
+const test_driver_1 = require("../src/test-driver");
+describe('BaseExecutor', () => {
+    it('named params', () => __awaiter(void 0, void 0, void 0, function* () {
+        const sqlName = 'test';
+        const namedParam = new wrappers_1.NamedParameter(sqlName);
+        const executor = new test_driver_1.TestExecutor();
+        executor.mapper = (query) => {
+            expect(query).toBeDefined();
+            expect(query.params).toBeDefined();
+            expect(query.params[sqlName]).toBe(123);
+            return [];
+        };
+        executor.setNamedParameter(namedParam, 123);
+        yield executor.execute({});
+    }));
+});