taon-type-sql 21.0.23 → 21.0.25

package/lib-prod/builder/other/query-ordering.js

@@ -1,20 +1,14 @@
-class QueryOrdering {
-  _column;
-  _direction;
-  _nullsPosition;
-  constructor(column, direction) {
-    this._column = column;
-    this._direction = direction;
-  }
-  nullsFirst() {
-    this._nullsPosition = "FIRST";
-    return this;
-  }
-  nullsLast() {
-    this._nullsPosition = "LAST";
-    return this;
-  }
+export default class QueryOrdering {
+    constructor(column, direction) {
+        this._column = column;
+        this._direction = direction;
+    }
+    nullsFirst() {
+        this._nullsPosition = 'FIRST';
+        return this;
+    }
+    nullsLast() {
+        this._nullsPosition = 'LAST';
+        return this;
+    }
 }
-export {
-  QueryOrdering as default
-};

package/lib-prod/builder/query/select-query.js

@@ -1,51 +1,45 @@
-class SelectQuery {
-  constructor(_queryProcessor, _tables) {
-    this._queryProcessor = _queryProcessor;
-    this._tables = _tables;
-  }
-  _distinct = false;
-  _offset;
-  _limit;
-  _conditions = [];
-  _groupBy = [];
-  _having = [];
-  _orderings = [];
-  _columns = [];
-  _action;
-  offset(offset) {
-    this._offset = offset;
-    return this;
-  }
-  limit(limit) {
-    this._limit = limit;
-    return this;
-  }
-  distinct() {
-    this._distinct = true;
-    return this;
-  }
-  where(...conditions) {
-    this._conditions = conditions;
-    return this;
-  }
-  groupBy(...columns) {
-    this._groupBy = columns;
-    return this;
-  }
-  having(...conditions) {
-    this._having = conditions;
-    return this;
-  }
-  orderBy(...orderings) {
-    this._orderings = orderings;
-    return this;
-  }
-  select(...columns) {
-    this._columns = columns;
-    this._action = "select";
-    return this._queryProcessor(this);
-  }
+export default class SelectQuery {
+    constructor(_queryProcessor, _tables) {
+        this._queryProcessor = _queryProcessor;
+        this._tables = _tables;
+        this._distinct = false;
+        this._conditions = [];
+        this._groupBy = [];
+        this._having = [];
+        this._orderings = [];
+        this._columns = [];
+    }
+    offset(offset) {
+        this._offset = offset;
+        return this;
+    }
+    limit(limit) {
+        this._limit = limit;
+        return this;
+    }
+    distinct() {
+        this._distinct = true;
+        return this;
+    }
+    where(...conditions) {
+        this._conditions = conditions;
+        return this;
+    }
+    groupBy(...columns) {
+        this._groupBy = columns;
+        return this;
+    }
+    having(...conditions) {
+        this._having = conditions;
+        return this;
+    }
+    orderBy(...orderings) {
+        this._orderings = orderings;
+        return this;
+    }
+    select(...columns) {
+        this._columns = columns;
+        this._action = 'select';
+        return this._queryProcessor(this);
+    }
 }
-export {
-  SelectQuery as default
-};

package/lib-prod/builder/query/table-condition-query.js

@@ -1,27 +1,22 @@
-class TableConditionQuery {
-  constructor(_queryProcessor, _table, _conditions) {
-    this._queryProcessor = _queryProcessor;
-    this._table = _table;
-    this._conditions = _conditions;
-  }
-  _columns = [];
-  _action;
-  _entity;
-  update(entity) {
-    this._entity = entity;
-    this._action = "update";
-    return this._queryProcessor(this);
-  }
-  delete() {
-    this._action = "delete";
-    return this._queryProcessor(this);
-  }
-  count() {
-    this._columns = [this._table.$all.count()];
-    this._action = "select";
-    return this._queryProcessor(this).then((rows) => rows[0]);
-  }
+export default class TableConditionQuery {
+    constructor(_queryProcessor, _table, _conditions) {
+        this._queryProcessor = _queryProcessor;
+        this._table = _table;
+        this._conditions = _conditions;
+        this._columns = [];
+    }
+    update(entity) {
+        this._entity = entity;
+        this._action = 'update';
+        return this._queryProcessor(this);
+    }
+    delete() {
+        this._action = 'delete';
+        return this._queryProcessor(this);
+    }
+    count() {
+        this._columns = [this._table.$all.count()];
+        this._action = 'select';
+        return this._queryProcessor(this).then((rows) => rows[0]);
+    }
 }
-export {
-  TableConditionQuery as default
-};

package/lib-prod/builder/query/table-query.js

@@ -1,54 +1,52 @@
 import TableConditionQuery from "./table-condition-query";
 import ValueColumn from "../column/value-column";
-class TableQuery {
-  constructor(_queryProcessor, _table) {
-    this._queryProcessor = _queryProcessor;
-    this._table = _table;
-  }
-  _entity;
-  _action;
-  _columns = [];
-  where(...conditions) {
-    return new TableConditionQuery(this._queryProcessor, this._table, conditions);
-  }
-  insert(param) {
-    this._entity = param;
-    this._action = "insert";
-    return this._queryProcessor(this);
-  }
-  deleteAll() {
-    this._action = "delete";
-    return this._queryProcessor(this);
-  }
-  updateAll(entity) {
-    this._entity = entity;
-    this._action = "update";
-    return this._queryProcessor(this);
-  }
-  countAll() {
-    this._columns = [this._table.$all.count()];
-    this._action = "select";
-    return this._queryProcessor(this).then((rows) => rows[0]);
-  }
-  delete(id) {
-    return this._whereId(id).delete().then((count) => count > 0);
-  }
-  update(id, entity) {
-    return this._whereId(id).update(entity).then((count) => count > 0);
-  }
-  get(id) {
-    let query = this._whereId(id);
-    return this._queryProcessor({ _action: "select", ...query }).then((rows) => rows[0]);
-  }
-  _whereId(id) {
-    let $id = this._table.$id;
-    if ($id instanceof ValueColumn) {
-      return this.where($id.eq(id));
-    } else {
-      return this.where(...Object.keys($id).map((key) => this._table[key].eq(id[key])));
-    }
-  }
+export default class TableQuery {
+    constructor(_queryProcessor, _table) {
+        this._queryProcessor = _queryProcessor;
+        this._table = _table;
+        this._columns = [];
+    }
+    where(...conditions) {
+        return new TableConditionQuery(this._queryProcessor, this._table, conditions);
+    }
+    insert(param) {
+        this._entity = param;
+        this._action = 'insert';
+        return this._queryProcessor(this);
+    }
+    deleteAll() {
+        this._action = 'delete';
+        return this._queryProcessor(this);
+    }
+    updateAll(entity) {
+        this._entity = entity;
+        this._action = 'update';
+        return this._queryProcessor(this);
+    }
+    countAll() {
+        this._columns = [this._table.$all.count()];
+        this._action = 'select';
+        return this._queryProcessor(this).then((rows) => rows[0]);
+    }
+    delete(id) {
+        return this._whereId(id).delete().then(count => count > 0);
+    }
+    update(id, entity) {
+        return this._whereId(id).update(entity).then(count => count > 0);
+    }
+    get(id) {
+        let query = this._whereId(id);
+        return this._queryProcessor({ _action: 'select', ...query })
+            .then((rows) => rows[0]);
+    }
+    _whereId(id) {
+        // TODO remove assertions if $id typing is fixed
+        let $id = this._table.$id;
+        if ($id instanceof ValueColumn) {
+            return this.where($id.eq(id));
+        }
+        else {
+            return this.where(...Object.keys($id).map(key => this._table[key].eq(id[key])));
+        }
+    }
 }
-export {
-  TableQuery as default
-};

package/lib-prod/builder/query-source.js

@@ -1,18 +1,17 @@
-import SelectQuery from "./query/select-query";
+import SelectQuery from './query/select-query';
 import TableQuery from "./query/table-query";
-class QuerySource {
-  constructor(_queryProcessor) {
-    this._queryProcessor = _queryProcessor;
-  }
-  from(table1, table2, table3) {
-    if (table3 != null) return new SelectQuery(this._queryProcessor, [table1, table2, table3]);
-    else if (table2 != null) return new SelectQuery(this._queryProcessor, [table1, table2]);
-    return new SelectQuery(this._queryProcessor, [table1]);
-  }
-  table(table) {
-    return new TableQuery(this._queryProcessor, table);
-  }
+export default class QuerySource {
+    constructor(_queryProcessor) {
+        this._queryProcessor = _queryProcessor;
+    }
+    from(table1, table2, table3) {
+        if (table3 != null)
+            return new SelectQuery(this._queryProcessor, [table1, table2, table3]);
+        else if (table2 != null)
+            return new SelectQuery(this._queryProcessor, [table1, table2]);
+        return new SelectQuery(this._queryProcessor, [table1]);
+    }
+    table(table) {
+        return new TableQuery(this._queryProcessor, table);
+    }
 }
-export {
-  QuerySource as default
-};

package/lib-prod/builder/query-table.js

@@ -1,27 +1,22 @@
 import BasicColumn from "./column/basic-column";
 import JoinedTablesChain from "./join/joined-tables-chain";
 class QueryTable {
-  constructor(_$name) {
-    this._$name = _$name;
-  }
-  _$type;
-  _$idType;
-  // abstract readonly $id; // FIXME I got a dozen incomprehensible type errors
-  $all = new BasicColumn(this, "*");
-  innerJoin(table) {
-    return new JoinedTablesChain(table, "inner", this);
-  }
-  leftJoin(table) {
-    return new JoinedTablesChain(table, "left", this);
-  }
-  rightJoin(table) {
-    return new JoinedTablesChain(table, "right", this);
-  }
-  fullJoin(table) {
-    return new JoinedTablesChain(table, "full", this);
-  }
+    constructor(_$name) {
+        this._$name = _$name;
+        // abstract readonly $id; // FIXME I got a dozen incomprehensible type errors
+        this.$all = new BasicColumn(this, '*');
+    }
+    innerJoin(table) {
+        return new JoinedTablesChain(table, 'inner', this);
+    }
+    leftJoin(table) {
+        return new JoinedTablesChain(table, 'left', this);
+    }
+    rightJoin(table) {
+        return new JoinedTablesChain(table, 'right', this);
+    }
+    fullJoin(table) {
+        return new JoinedTablesChain(table, 'full', this);
+    }
 }
-var query_table_default = QueryTable;
-export {
-  query_table_default as default
-};
+export default QueryTable;

package/lib-prod/client/mysql.js

@@ -1,10 +1,7 @@
 import QuerySource from "../builder/query-source";
 import { createQueryProcessor } from "./query-processor";
-class MySqlQuerySource extends QuerySource {
-  constructor(client, options = {}) {
-    super(createQueryProcessor(client, options, "mysql"));
-  }
+export default class MySqlQuerySource extends QuerySource {
+    constructor(client, options = {}) {
+        super(createQueryProcessor(client, options, 'mysql'));
+    }
 }
-export {
-  MySqlQuerySource as default
-};

package/lib-prod/client/pg.js

@@ -1,10 +1,7 @@
 import QuerySource from "../builder/query-source";
 import { createQueryProcessor } from "./query-processor";
-class PgQuerySource extends QuerySource {
-  constructor(client, options = {}) {
-    super(createQueryProcessor(client, options, "pg"));
-  }
+export default class PgQuerySource extends QuerySource {
+    constructor(client, options = {}) {
+        super(createQueryProcessor(client, options, 'pg'));
+    }
 }
-export {
-  PgQuerySource as default
-};

package/lib-prod/client/query-processor.js

@@ -1,44 +1,69 @@
-import { Log } from "ng2-logger/lib-prod";
-import { convertQueryToParameterizedSQL } from "../converter/parameterized-converter";
-import { convertQueryToSQL } from "../converter/sql-converter";
-const log = Log.create(
-  "query processor"
-  // Level.__NOTHING
-);
+import { Log } from 'ng2-logger/lib-prod';
+import { convertQueryToParameterizedSQL } from '../converter/parameterized-converter';
+import { convertQueryToSQL } from '../converter/sql-converter';
+const log = Log.create('query processor');
 const DEFAULT_OPTIONS = {
-  lineBreaks: false,
-  parameterized: true,
-  logging: true,
-  identifierQuote: '"'
+    lineBreaks: false,
+    parameterized: true,
+    logging: true,
+    identifierQuote: '"'
 };
 function mySqlTypeCast(field, next) {
-  if (field.type == "TINY" && field.length == 1) {
-    let value = field.string();
-    if (value == "1") return true;
-    if (value == "0") return false;
-    return null;
-  } else if (field.type == "JSON") {
-    let value = field.string();
-    return value == null ? null : JSON.parse(value);
-  }
-  return next();
-}
-function createQueryProcessor(client, _options = {}, engine = "pg") {
-  let options = Object.assign({}, DEFAULT_OPTIONS, _options);
-  let queryOptions = {
-    lineBreak: options.lineBreaks ? "\n" : " ",
-    nameEscape: _options.identifierQuote || (engine === "mysql" ? "`" : '"')
-  };
-  return (query) => {
-    if (options.parameterized) {
-      let { sql, params } = convertQueryToParameterizedSQL(query, queryOptions, engine);
-      return client.query(sql, params);
-    } else {
-      let sql = convertQueryToSQL(query, queryOptions, engine);
-      return client.query(sql, void 0);
+    if (field.type == 'TINY' && field.length == 1) { // Boolean
+        let value = field.string();
+        if (value == '1')
+            return true;
+        if (value == '0')
+            return false;
+        return null;
+    }
+    else if (field.type == 'JSON') {
+        let value = field.string();
+        return value == null ? null : JSON.parse(value);
     }
-  };
+    return next();
+}
+export function createQueryProcessor(client, _options = {}, engine = 'pg') {
+    let options = Object.assign({}, DEFAULT_OPTIONS, _options);
+    let queryOptions = {
+        lineBreak: options.lineBreaks ? '\n' : ' ',
+        nameEscape: _options.identifierQuote || (engine === 'mysql' ? '`' : '"')
+    };
+    // function processSql(query: any, sql: string, params: any[] | undefined, callback: any): Promise<any> {
+    //   if (options.logging) log.i(sql);
+    //   if (options.logger) options.logger(sql, params);
+    //   return new Promise((resolve, reject) => {
+    //     callback(sql, params, (err: any, result: any) => {
+    //       if (err) reject(err);
+    //       else resolve(convertResult(query, result, engine));
+    //     });
+    //   });
+    // }
+    // function executeSql(sql: string, params: any[] | undefined, cb: any) {
+    //   if (engine === 'pg') {
+    //     client.query(sql, params || cb, params ? cb : undefined);
+    //   } else if (engine === 'mysql') {
+    //     client.query({
+    //       sql,
+    //       values: params,
+    //       typeCast: mySqlTypeCast
+    //     }, cb);
+    //   } else throw new Error('Unknown DB engine: ' + engine);
+    // }
+    return (query) => {
+        if (options.parameterized) {
+            let { sql, params } = convertQueryToParameterizedSQL(query, queryOptions, engine);
+            // if (Helpers.isWebSQL || Helpers.isNode) {
+            return client.query(sql, params);
+            // }
+            // return processSql(query, sql, params, (sql: string, params: any[], cb: any) => executeSql(sql, params, cb));
+        }
+        else {
+            let sql = convertQueryToSQL(query, queryOptions, engine);
+            // if (Helpers.isWebSQL || Helpers.isNode) {
+            return client.query(sql, undefined);
+            // }
+            // return processSql(query, sql, undefined, (sql: string, params: undefined, cb: any) => executeSql(sql, undefined, cb));
+        }
+    };
 }
-export {
-  createQueryProcessor
-};

package/lib-prod/converter/param-converter.js

@@ -1,23 +1,26 @@
-function convertSubstitutionParam(param) {
-  if (param == null) return "NULL";
-  if (typeof param === "string" || param instanceof String) {
-    return `'${String(param)}'`;
-  } else if (typeof param === "boolean" || param instanceof Boolean) {
-    return String(param).toUpperCase();
-  } else if (param instanceof Date) {
-    return `'${param.toISOString()}'`;
-  } else if (typeof param === "number" || param instanceof Number) {
-    return String(param);
-  }
-  return `'${JSON.stringify(param)}'`;
+export function convertSubstitutionParam(param) {
+    if (param == null)
+        return 'NULL';
+    if (typeof param === 'string' || param instanceof String) {
+        return `'${String(param)}'`;
+    }
+    else if (typeof param === 'boolean' || param instanceof Boolean) {
+        return String(param).toUpperCase();
+    }
+    else if (param instanceof Date) {
+        return `'${param.toISOString()}'`;
+    }
+    else if (typeof param === 'number' || param instanceof Number) {
+        return String(param);
+    }
+    return `'${JSON.stringify(param)}'`;
 }
-function convertEscapedParam(param) {
-  if (typeof param === "object" && !(param == null || param instanceof String || param instanceof Number || param instanceof Boolean || param instanceof Date)) {
-    return JSON.stringify(param);
-  }
-  return param;
+// node mysql doesn't have an typeCast equivalent solution for the other direction
+// node-postgres: https://github.com/brianc/node-postgres/issues/442
+export function convertEscapedParam(param) {
+    if (typeof param === 'object' && !(param == null || param instanceof String || param instanceof Number ||
+        param instanceof Boolean || param instanceof Date)) {
+        return JSON.stringify(param);
+    }
+    return param;
 }
-export {
-  convertEscapedParam,
-  convertSubstitutionParam
-};

package/lib-prod/converter/parameterized-converter.js

@@ -1,17 +1,14 @@
 import { createQueryConverter } from "./query-converter";
-import { convertEscapedParam } from "./param-converter";
-let pgParamConverter = (index) => "$" + index;
-let mySqlParamConverter = (index) => "?";
+import { convertEscapedParam } from './param-converter';
+let pgParamConverter = (index) => '$' + index;
+let mySqlParamConverter = (index) => '?';
 function convertSingleParam(param, params, paramConverter) {
-  params.push(convertEscapedParam(param));
-  return paramConverter(params.length);
+    params.push(convertEscapedParam(param));
+    return paramConverter(params.length);
 }
-function convertQueryToParameterizedSQL(query, options, engine) {
-  let params = [];
-  let paramConverter = engine === "mysql" ? mySqlParamConverter : pgParamConverter;
-  let sql = createQueryConverter((param) => convertSingleParam(param, params, paramConverter), options, engine)(query);
-  return { sql, params };
+export function convertQueryToParameterizedSQL(query, options, engine) {
+    let params = [];
+    let paramConverter = engine === 'mysql' ? mySqlParamConverter : pgParamConverter;
+    let sql = createQueryConverter((param) => convertSingleParam(param, params, paramConverter), options, engine)(query);
+    return { sql, params };
 }
-export {
-  convertQueryToParameterizedSQL
-};