@ts-awesome/orm 1.5.0 → 1.5.2

package/tests/builder.spec.ts

@@ -535,6 +535,99 @@ describe('Select', () => {
       // ignore
     }
   });
+
+  it ('union operator', () => {
+    const query = Select(Person)
+      .columns(['name'])
+      .union(true, Select(Person)
+        .columns(['name'])
+        .where(x => x.age.lt(18))
+      )
+      .where(x => x.age.gte(18))
+      .orderBy(['name']);
+
+    expect(query._operators).toStrictEqual([{
+      _operator: 'UNION',
+      _distinct: true,
+      _operand: {
+        "_type": "SELECT",
+        "_table": Person[TableMetadataSymbol],
+        "_alias": null,
+        "_distinct": false,
+        "_for": undefined,
+        "_columns": [{"_column": {"table": "Person", "name": "name"}}],
+        "_where": [{
+          "_operator": "<",
+          "_operands": [
+            {"_column": {"table": "Person", "name": "age"}},
+            18
+          ]
+        }]
+      }
+    }])
+  })
+
+  it ('intersect operator', () => {
+    const query = Select(Person)
+      .columns(['name'])
+      .intersect(Select(Person)
+        .columns(['name'])
+        .where(x => x.age.lt(18))
+      )
+      .where(x => x.age.gte(18))
+      .orderBy(['name']);
+
+    expect(query._operators).toStrictEqual([{
+      _operator: 'INTERSECT',
+      _distinct: false,
+      _operand: {
+        "_type": "SELECT",
+        "_table": Person[TableMetadataSymbol],
+        "_alias": null,
+        "_distinct": false,
+        "_for": undefined,
+        "_columns": [{"_column": {"table": "Person", "name": "name"}}],
+        "_where": [{
+          "_operator": "<",
+          "_operands": [
+            {"_column": {"table": "Person", "name": "age"}},
+            18
+          ]
+        }]
+      }
+    }])
+  })
+
+  it ('except operator', () => {
+    const query = Select(Person)
+      .columns(['name'])
+      .except(Select(Person)
+        .columns(['name'])
+        .where(x => x.age.lt(18))
+      )
+      .where(x => x.age.gte(18))
+      .orderBy(['name']);
+
+    expect(query._operators).toStrictEqual([{
+      _operator: 'EXCEPT',
+      _distinct: false,
+      _operand: {
+        "_type": "SELECT",
+        "_table": Person[TableMetadataSymbol],
+        "_alias": null,
+        "_distinct": false,
+        "_for": undefined,
+        "_columns": [{"_column": {"table": "Person", "name": "name"}}],
+        "_where": [{
+          "_operator": "<",
+          "_operands": [
+            {"_column": {"table": "Person", "name": "age"}},
+            18
+          ]
+        }]
+      }
+    }])
+  })
 });
 
 describe('Insert', () => {

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({});
+    }));
+});

package/tests/models.js

@@ -0,0 +1,112 @@
+"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 });
+exports.Employee = exports.TagPerson = exports.Tag = exports.Person = void 0;
+const src_1 = require("../src");
+const UUID = {};
+let Person = class Person {
+};
+__decorate([
+    (0, src_1.dbField)({
+        primaryKey: true,
+        autoIncrement: true
+    }),
+    __metadata("design:type", Number)
+], Person.prototype, "id", void 0);
+__decorate([
+    (0, src_1.dbField)({
+        kind: UUID
+    }),
+    __metadata("design:type", String)
+], Person.prototype, "uid", void 0);
+__decorate([
+    src_1.dbField,
+    __metadata("design:type", String)
+], Person.prototype, "name", void 0);
+__decorate([
+    src_1.dbField,
+    __metadata("design:type", Number)
+], Person.prototype, "age", void 0);
+__decorate([
+    src_1.dbField,
+    __metadata("design:type", String)
+], Person.prototype, "city", void 0);
+__decorate([
+    (0, src_1.dbFilterField)({
+        table: 'employee',
+        keyField: 'person',
+        valueField: 'title',
+    }),
+    __metadata("design:type", Array)
+], Person.prototype, "profiles", void 0);
+__decorate([
+    (0, src_1.dbFilterField)(primary => (0, src_1.Select)(Tag)
+        .columns((x) => [x.name])
+        .join(TagPerson, (a, b) => (0, src_1.and)(a.id.eq(b.tag), b.person.eq(primary)))),
+    __metadata("design:type", Array)
+], Person.prototype, "tags", void 0);
+Person = __decorate([
+    (0, src_1.dbTable)('Person', [{ name: 'idx', fields: ['id'] }])
+], Person);
+exports.Person = Person;
+let Tag = class Tag {
+};
+__decorate([
+    (0, src_1.dbField)({
+        primaryKey: true,
+        autoIncrement: true
+    }),
+    __metadata("design:type", Number)
+], Tag.prototype, "id", void 0);
+__decorate([
+    src_1.dbField,
+    __metadata("design:type", String)
+], Tag.prototype, "name", void 0);
+Tag = __decorate([
+    (0, src_1.dbTable)('Tag')
+], Tag);
+exports.Tag = Tag;
+let TagPerson = class TagPerson {
+};
+__decorate([
+    (0, src_1.dbField)({
+        primaryKey: true,
+    }),
+    __metadata("design:type", Number)
+], TagPerson.prototype, "person", void 0);
+__decorate([
+    (0, src_1.dbField)({
+        primaryKey: true,
+    }),
+    __metadata("design:type", Number)
+], TagPerson.prototype, "tag", void 0);
+TagPerson = __decorate([
+    (0, src_1.dbTable)('TagPerson')
+], TagPerson);
+exports.TagPerson = TagPerson;
+let Employee = class Employee {
+};
+__decorate([
+    src_1.dbField,
+    __metadata("design:type", Number)
+], Employee.prototype, "personId", void 0);
+__decorate([
+    src_1.dbField,
+    __metadata("design:type", String)
+], Employee.prototype, "company", void 0);
+__decorate([
+    src_1.dbField,
+    __metadata("design:type", Number)
+], Employee.prototype, "salary", void 0);
+Employee = __decorate([
+    (0, src_1.dbTable)('Employee')
+], Employee);
+exports.Employee = Employee;

package/tests/reader.spec.js

@@ -0,0 +1,128 @@
+"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 DB_JSON = {
+    reader(raw) {
+        return typeof raw === 'string' ? JSON.parse(raw) : raw;
+    },
+    writer(value) {
+        return JSON.stringify(value);
+    }
+};
+function generatePersons(quantity) {
+    const res = [];
+    for (let i = 1; i <= quantity; i++) {
+        const person = new models_1.Person();
+        person['id'] = i;
+        person['city'] = `TestCity${i}`;
+        person['age'] = 18;
+        person['name'] = `TestName${i}`;
+        person['uid'] = `uid${i}`;
+        // person['profiles'] = ['profile-a'];
+        res.push(person);
+    }
+    return res;
+}
+describe('DbReader', () => {
+    const persons = generatePersons(5);
+    it('read raw', () => {
+        const result = (0, dist_1.reader)(persons);
+        expect(result).toStrictEqual(persons);
+        result.map(person => {
+            expect(person).toBeInstanceOf(models_1.Person);
+            expect(person).toStrictEqual(persons.find(p => p.id === person.id));
+        });
+    });
+    it('read Model', () => {
+        let Model = class Model {
+            constructor(id, raw, personal) {
+                this.id = id;
+                this.value = raw;
+                this.personal = personal;
+            }
+        };
+        __decorate([
+            dist_1.dbField,
+            __metadata("design:type", Number)
+        ], Model.prototype, "id", void 0);
+        __decorate([
+            (0, dist_1.dbField)('raw'),
+            __metadata("design:type", String)
+        ], Model.prototype, "value", void 0);
+        __decorate([
+            (0, dist_1.dbField)({ kind: DB_JSON, model: [models_1.Person] }),
+            __metadata("design:type", Array)
+        ], Model.prototype, "personal", void 0);
+        Model = __decorate([
+            dist_1.dbTable,
+            __metadata("design:paramtypes", [Object, Object, Object])
+        ], Model);
+        const model = {
+            id: "5",
+            raw: false,
+            personal: JSON.stringify(persons)
+        };
+        const expected = new Model(5, 'false', persons);
+        const results = (0, dist_1.reader)([model], Model);
+        expect(results.length).toBe(1);
+        const [result] = results;
+        expect(result).toBeInstanceOf(Model);
+        expect(result).toEqual(expected);
+    });
+    it('read Model from no data', () => {
+        let Model = class Model {
+            constructor(id, raw, personal) {
+                this.id = id;
+                this.value = raw;
+                this.personal = personal;
+            }
+        };
+        __decorate([
+            dist_1.dbField,
+            __metadata("design:type", Number)
+        ], Model.prototype, "id", void 0);
+        __decorate([
+            (0, dist_1.dbField)('raw'),
+            __metadata("design:type", String)
+        ], Model.prototype, "value", void 0);
+        __decorate([
+            (0, dist_1.dbField)({ kind: DB_JSON, model: [models_1.Person] }),
+            __metadata("design:type", Array)
+        ], Model.prototype, "personal", void 0);
+        Model = __decorate([
+            dist_1.dbTable,
+            __metadata("design:paramtypes", [Object, Object, Object])
+        ], Model);
+        const results = (0, dist_1.reader)([], Model);
+        expect(results.length).toBe(0);
+    });
+    it('read scalar', () => {
+        const count = 10;
+        const correctResult = (0, dist_1.reader)([{ field: count }], true);
+        expect(correctResult).toBe(count);
+    });
+    it('read scalar from no data', () => {
+        const fieldValue = 'string';
+        const emptyData = (0, dist_1.reader)([], true);
+        expect(emptyData).toBe(0);
+        expect(() => {
+            (0, dist_1.reader)([{ field: fieldValue }], true);
+        }).toThrowError(`Invalid scalar "${fieldValue}", number expected.`);
+    });
+    it('read scalar from invalid data', () => {
+        const fieldValue = 'string';
+        expect(() => {
+            (0, dist_1.reader)([{ field: fieldValue }], true);
+        }).toThrowError(`Invalid scalar "${fieldValue}", number expected.`);
+    });
+});