@ts-awesome/orm 1.8.0-rc.0 → 2.0.0-alpha.1

package/tests/executor.spec.ts

@@ -1,24 +0,0 @@
-import {NamedParameter} from "../src/wrappers";
-import {TestExecutor} from "../src/test-driver";
-
-describe('BaseExecutor', () => {
-
-  it('named params', async () => {
-    const sqlName = 'test';
-    const namedParam = new NamedParameter(sqlName);
-
-    const executor = new TestExecutor();
-
-    executor.mapper = (query) => {
-      expect(query).toBeDefined()
-      expect(query.params).toBeDefined()
-      expect(query.params[sqlName]).toBe(123)
-      return []
-    }
-
-    executor.setNamedParameter(namedParam, 123)
-
-    await executor.execute({});
-  });
-
-})

package/tests/function-operators.spec.js

@@ -1,172 +0,0 @@
-const {SupportedOperations, Operandable, FunctionCall, ColumnWrapper} = require("../dist/wrappers");
-const {and, or, not, all, any, exists, avg, sum, count, max, min, asc, desc, of, alias} = require('../dist/operators');
-
-describe('Operators should return correct intermediate query', () => {
-    const operandable = SupportedOperations.eq.call([1, 2, 3], 5);
-    const testTable = {
-        tableName: 'table_name',
-        fields: new Map([
-            ['test_field', {name: 'test_field'}],
-            ['another_field', {name: 'another_field'}]
-        ])
-    };
-
-    it('Asc operator', () => {
-        const result = asc(operandable);
-        expect(result).toStrictEqual({...operandable, _order: 'ASC', _nulls: undefined});
-    });
-
-    it('Asc operator', () => {
-        const result = asc(operandable, 'LAST');
-        expect(result).toStrictEqual({...operandable, _order: 'ASC', _nulls: 'LAST'});
-    });
-
-    it('Desc operator', () => {
-        const result = desc(operandable);
-        expect(result).toStrictEqual({...operandable, _order: 'DESC', _nulls: undefined});
-    });
-
-    it('Desc operator', () => {
-        const result = desc(operandable, 'FIRST');
-        expect(result).toStrictEqual({...operandable, _order: 'DESC', _nulls: 'FIRST'});
-    });
-
-    it('Of operator', () => {
-        const field = 'test_field';
-        const result = of(testTable, field);
-
-        expect(result).toBeInstanceOf(ColumnWrapper);
-        expect(result._column).toStrictEqual({table: testTable.tableName, name: 'test_field'})
-    });
-
-    it('Of operator should throw error if given filed does not exists', () => {
-        const field = 'nonexistent_field';
-
-        expect(() => {
-            of(testTable, field);
-        }).toThrowError(`Field '${field}' should be annotated with @dbField() or @dbManyField()`);
-    });
-
-    it('Alias operator', () => {
-        const name = 'some_name';
-        const result = alias(operandable, name);
-
-        expect(result._alias).toBe(name);
-        expect(result._operands).toStrictEqual([operandable]);
-    });
-});
-
-describe('Operators should return correct Operandable intermediate query', () => {
-
-    const firstOperand = true;
-    const secondOperand = false;
-    const subquery = {
-        _type: 'SELECT',
-        _table: {
-            tableName: 'test_table',
-            fields: new Map([['test_field', 'test value']])
-        }
-    };
-
-    it('And operator', () => {
-        const result = and(firstOperand, secondOperand);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('AND');
-        expect(result._operands).toStrictEqual([firstOperand, secondOperand]);
-    });
-
-    it('Or operator', () => {
-        const result = or(firstOperand, secondOperand);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('OR');
-        expect(result._operands).toStrictEqual([firstOperand, secondOperand]);
-    });
-
-    it('Not operator', () => {
-        const condition = false;
-        const result = not(condition);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('NOT');
-        expect(result._operands).toStrictEqual([condition]);
-    });
-
-    it('All operator', () => {
-        const result = all(subquery);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('ALL');
-        expect(result._operands).toStrictEqual([subquery]);
-    });
-
-    it('Any operator', () => {
-        const result = any(subquery);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('ANY');
-        expect(result._operands).toStrictEqual([subquery]);
-    });
-
-    it('Exists operator', () => {
-        const result = exists(subquery);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('EXISTS');
-        expect(result._operands).toStrictEqual([subquery]);
-    });
-});
-
-describe('Operands should return correct FunctionalCall intermediate query', ()=> {
-
-    const operandable = SupportedOperations.eq.call([1, 2, 3], 5);
-
-    it('Avg operator', () => {
-        const result = avg(operandable);
-
-        expect(result).toBeInstanceOf(FunctionCall);
-        expect(result._func).toBe('AVG');
-        expect(result._args).toStrictEqual([operandable]);
-    });
-
-    it('Sum operator', () => {
-        const result = sum(operandable);
-
-        expect(result).toBeInstanceOf(FunctionCall);
-        expect(result._func).toBe('SUM');
-        expect(result._args).toStrictEqual([operandable]);
-    });
-
-    it('Count operator', () => {
-        const result = count(operandable);
-
-        expect(result).toBeInstanceOf(FunctionCall);
-        expect(result._func).toBe('COUNT');
-        expect(result._args).toStrictEqual([operandable]);
-    });
-
-    it('Count operator should return * if value was not provided', () => {
-        const result = count();
-
-        expect(result).toBeInstanceOf(FunctionCall);
-        expect(result._func).toBe('COUNT');
-        expect(result._args).toStrictEqual(['*']);
-    });
-
-    it('Max operator', () => {
-        const result = max(operandable);
-
-        expect(result).toBeInstanceOf(FunctionCall);
-        expect(result._func).toBe('MAX');
-        expect(result._args).toStrictEqual([operandable]);
-    });
-
-    it('Min operator', () => {
-        const result = min(operandable);
-
-        expect(result).toBeInstanceOf(FunctionCall);
-        expect(result._func).toBe('MIN');
-        expect(result._args).toStrictEqual([operandable]);
-    });
-});

package/tests/models.ts

@@ -1,100 +0,0 @@
-import {dbField, dbTable, IDbField, dbFilterField, and, Select, DbValueType,
-  IOperandable, cast, FunctionCall, Branded} from '../src';
-
-const UUID: IDbField = {}
-
-export type PersonId = Branded<number, 'PersonId'>;
-export type PersonUid = Branded<string, 'PersonUid'>;
-
-@dbTable('Person', [{name: 'idx', fields: ['id']}])
-export class Person {
-  @dbField({
-    primaryKey: true,
-    autoIncrement: true
-  })
-  id!: PersonId;
-
-  @dbField({
-    kind: UUID
-  })
-  uid?: PersonUid;
-
-  @dbField name!: string;
-  @dbField age!: number;
-  @dbField city!: string;
-
-  @dbField({sensitive: true, nullable: true})
-  password?: string;
-
-  @dbFilterField({
-    table: 'employee',
-    keyField: 'person',
-    valueField: 'title',
-  })
-  profiles?: string[];
-
-  @dbFilterField(primary => Select(Tag)
-      .columns((x) => [x.name])
-      .join(TagPerson, (a ,b) => and(a.id.eq(b.tag), b.person.eq(primary)))
-  )
-  tags?: string[];
-}
-
-export type TagId = Branded<number, 'TagId'>;
-
-@dbTable('Tag')
-export class Tag {
-  @dbField({
-    primaryKey: true,
-    autoIncrement: true
-  })
-  public id!: TagId;
-
-  @dbField public name!: string;
-}
-
-@dbTable('TagPerson')
-export class TagPerson {
-  @dbField({
-    primaryKey: true,
-  })
-  public person!: PersonId;
-  @dbField({
-    primaryKey: true,
-  })
-  public tag!: TagId;
-}
-
-@dbTable('Employee')
-export class Employee {
-  @dbField personId!: PersonId;
-  @dbField company!: string;
-  @dbField salary!: number;
-}
-
-export const EMAIL: IDbField = {
-  reader(value: DbValueType) {
-    return typeof value === 'string' ? value.toLowerCase() : value
-  },
-  writer(value): DbValueType {
-    return typeof value === 'string' ? value.toLowerCase() : value
-  },
-  readQuery(name: IOperandable<string>): IOperandable<string> {
-    return cast(name as never, 'Email');
-  },
-  writeQuery(name: IOperandable<string>): IOperandable<string> {
-    return cast(name as never, 'Email');
-  }
-}
-
-export type MailingListId = Branded<number, 'MailingListId'>;
-
-export class MailingList {
-  @dbField({
-    primaryKey: true,
-    autoIncrement: true
-  })
-  public id!: MailingListId;
-  @dbField public name!: string;
-  @dbField({kind: EMAIL}) email!: string;
-}

package/tests/prototype-operations.spec.js

@@ -1,346 +0,0 @@
-const {SupportedOperations, Operandable} = require("../src/wrappers");
-
-describe('Operations should return correct intermediate query', () => {
-
-    const thisData = [1, 2, 3, 4, 5];
-    const givenValue = 5;
-
-    it('Equal operation', () => {
-        const result = SupportedOperations.eq.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('=');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('Not equal operation', () => {
-        const result = SupportedOperations.neq.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('<>');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('LIKE operation', () => {
-        const result = SupportedOperations.like.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('LIKE');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('IN operation', () => {
-        const result = SupportedOperations.in.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('IN');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('HAS operation', () => {
-        const result = SupportedOperations.has.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('IN');
-        expect(result._operands).toStrictEqual([givenValue, thisData]);
-    });
-
-    it('BETWEEN operation', () => {
-        const lowerGivenValue = 5;
-        const highGivenValue = 10;
-        const result = SupportedOperations.between.call(thisData, lowerGivenValue, highGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('BETWEEN');
-        expect(result._operands).toStrictEqual([thisData, lowerGivenValue, highGivenValue]);
-    });
-
-    it('GREATER THAN operation', () => {
-        const result = SupportedOperations.gt.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('>');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('GREATER THAN EQUAL operation', () => {
-        const result = SupportedOperations.gte.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('>=');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('LOWER THAN operation', () => {
-        const result = SupportedOperations.lt.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('<');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('LOWER THAN EQUAL operation', () => {
-        const result = SupportedOperations.lte.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('<=');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('ADD operation', () => {
-        const result = SupportedOperations.add.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('+');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('SUBTRACTION operation', () => {
-        const result = SupportedOperations.sub.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('-');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('MULTIPLY operation', () => {
-        const result = SupportedOperations.mul.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('*');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('DIVISION operation', () => {
-        const result = SupportedOperations.div.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('/');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('MODULO operation', () => {
-        const result = SupportedOperations.mod.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('%');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('AND operation', () => {
-        const result = SupportedOperations.and.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('&');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('OR operation', () => {
-        const result = SupportedOperations.or.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('|');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-
-    it('XOR operation', () => {
-        const result = SupportedOperations.xor.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('^');
-        expect(result._operands).toStrictEqual([thisData, givenValue]);
-    });
-});
-
-describe('Operations should return correct intermediate query if given value is subquery', () => {
-
-    const thisData = [1, 2, 3, 4, 5];
-    const givenValue = 5;
-    const subQueryGivenValue = SupportedOperations.eq.call(thisData, givenValue);
-
-    it('Equal operation', () => {
-        const result = SupportedOperations.eq.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('=');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('Not equal operation', () => {
-        const result = SupportedOperations.eq.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('=');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('LIKE operation', () => {
-        const result = SupportedOperations.like.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('LIKE');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('IN operation', () => {
-        const result = SupportedOperations.in.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('IN');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('HAS operation', () => {
-        const result = SupportedOperations.has.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('IN');
-        expect(result._operands[0]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([subQueryGivenValue, thisData]);
-    });
-
-    it('BETWEEN operation', () => {
-        const result = SupportedOperations.between.call(thisData, subQueryGivenValue, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('BETWEEN');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands[2]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue, subQueryGivenValue]);
-    });
-
-    it('GREATER THAN operation', () => {
-        const result = SupportedOperations.gt.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('>');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('GREATER THAN EQUAL operation', () => {
-        const result = SupportedOperations.gte.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('>=');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('LOWER THAN operation', () => {
-        const result = SupportedOperations.lt.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('<');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('LOWER THAN EQUAL operation', () => {
-        const result = SupportedOperations.lte.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('<=');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('ADD operation', () => {
-        const result = SupportedOperations.add.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('+');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('SUBTRACTION operation', () => {
-        const result = SupportedOperations.sub.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('-');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('MULTIPLY operation', () => {
-        const result = SupportedOperations.mul.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('*');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('DIVISION operation', () => {
-        const result = SupportedOperations.div.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('/');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('MODULO operation', () => {
-        const result = SupportedOperations.mod.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('%');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('AND operation', () => {
-        const result = SupportedOperations.and.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('&');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('OR operation', () => {
-        const result = SupportedOperations.or.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('|');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-
-    it('XOR operation', () => {
-        const result = SupportedOperations.xor.call(thisData, subQueryGivenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('^');
-        expect(result._operands[1]).toBeInstanceOf(Operandable);
-        expect(result._operands).toStrictEqual([thisData, subQueryGivenValue]);
-    });
-});
-
-describe('Operations should correct process null value', () => {
-
-    const thisData = [1, 2, 3, 4, 5];
-
-    it('Equal operation', () => {
-        const givenValue = null;
-        const result = SupportedOperations.eq.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('IS');
-        expect(result._operands).toStrictEqual([thisData, 'NULL']);
-    });
-
-    it('A non-equal operation', () => {
-        const givenValue = null;
-        const result = SupportedOperations.neq.call(thisData, givenValue);
-
-        expect(result).toBeInstanceOf(Operandable);
-        expect(result._operator).toBe('IS NOT');
-        expect(result._operands).toStrictEqual([thisData, 'NULL']);
-    });
-});