taon-type-sql 21.0.22 → 21.0.24

package/browser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon-type-sql/browser",
-  "version": "21.0.22",
+  "version": "21.0.24",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/browser-prod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon-type-sql/browser-prod",
-  "version": "21.0.22",
+  "version": "21.0.24",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/lib/build-info._auto-generated_.d.ts

@@ -21,4 +21,4 @@ export declare const CURRENT_PACKAGE_TAON_VERSION = "v21";
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-export declare const CURRENT_PACKAGE_VERSION = "21.0.22";
+export declare const CURRENT_PACKAGE_VERSION = "21.0.24";

package/lib/build-info._auto-generated_.js

@@ -25,6 +25,6 @@ exports.CURRENT_PACKAGE_TAON_VERSION = 'v21';
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-exports.CURRENT_PACKAGE_VERSION = '21.0.22';
+exports.CURRENT_PACKAGE_VERSION = '21.0.24';
 // THIS FILE IS GENERATED - DO NOT MODIFY
 //# sourceMappingURL=build-info._auto-generated_.js.map

package/lib/package.json

@@ -1,4 +1,4 @@
 {
   "name": "taon-type-sql/lib",
-  "version": "21.0.22"
+  "version": "21.0.24"
 }

package/lib-prod/{build-info._auto-generated_.ts → build-info._auto-generated_.js}

@@ -22,6 +22,5 @@ export const CURRENT_PACKAGE_TAON_VERSION = 'v21';
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-export const CURRENT_PACKAGE_VERSION = '21.0.22';
+export const CURRENT_PACKAGE_VERSION = '21.0.24';
 // THIS FILE IS GENERATED - DO NOT MODIFY
-      

package/lib-prod/builder/column/{basic-column.ts → basic-column.js}

@@ -1,17 +1,11 @@
-import QueryTable from "../query-table";
 import QueryColumn from "./query-column";
 import NumberColumn from "./number-column";
-import {ColumnModifier, ColumnName} from "../helpers/internal-types";
-
 // This file is only needed because the QueryColumn can't implement its count method b. of circular dependencies
-
-export default class BasicColumn<Table extends QueryTable<any, any>, T> extends QueryColumn<Table, T> {
-
-    constructor(table: Table, name: ColumnName, modifiers: ColumnModifier[] = []) {
+export default class BasicColumn extends QueryColumn {
+    constructor(table, name, modifiers = []) {
         super(table, name, modifiers);
     }
-
-    count(): NumberColumn<Table> {
+    count() {
         return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
     }
-}
+}

package/lib-prod/builder/column/boolean-column.js

@@ -0,0 +1,11 @@
+import NumberColumn from "./number-column";
+import ValueColumn from "./value-column";
+export default class BooleanColumn extends ValueColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+        this._type = 'boolean';
+    }
+    count() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+}

package/lib-prod/builder/column/comparable-column.js

@@ -0,0 +1,39 @@
+import QueryColumnCondition from "../condition/query-column-condition";
+import ValueColumn from "./value-column";
+class ComparableColumn extends ValueColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+    }
+    lt(value) {
+        return new QueryColumnCondition(this, 'lt', value);
+    }
+    gt(value) {
+        return new QueryColumnCondition(this, 'gt', value);
+    }
+    lte(value) {
+        return new QueryColumnCondition(this, 'lte', value);
+    }
+    gte(value) {
+        return new QueryColumnCondition(this, 'gte', value);
+    }
+    in(values) {
+        return new QueryColumnCondition(this, 'in', ...values);
+    }
+    notIn(values) {
+        return new QueryColumnCondition(this, 'not-in', ...values);
+    }
+    between(value1, value2) {
+        return new QueryColumnCondition(this, 'between', value1, value2);
+    }
+    notBetween(value1, value2) {
+        return new QueryColumnCondition(this, 'not-between', value1, value2);
+    }
+    // min/max exists for text columns too, not just numeric and date
+    min() {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'min' }));
+    }
+    max() {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'max' }));
+    }
+}
+export default ComparableColumn;

package/lib-prod/builder/column/date-column.js

@@ -0,0 +1,11 @@
+import ComparableColumn from "./comparable-column";
+import NumberColumn from "./number-column";
+export default class DateColumn extends ComparableColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+        this._type = 'date';
+    }
+    count() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+}

package/lib-prod/builder/column/number-column.js

@@ -0,0 +1,16 @@
+import ComparableColumn from "./comparable-column";
+export default class NumberColumn extends ComparableColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+        this._type = 'number';
+    }
+    count() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+    sum() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'sum' }));
+    }
+    avg() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'avg' }));
+    }
+}

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

@@ -0,0 +1,18 @@
+import QueryColumnCondition from "../condition/query-column-condition";
+class QueryColumn {
+    constructor(_table, _name, _modifiers = []) {
+        this._table = _table;
+        this._name = _name;
+        this._modifiers = _modifiers;
+    }
+    as(alias) {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'as', params: alias }));
+    }
+    isNull() {
+        return new QueryColumnCondition(this, 'is-null');
+    }
+    isNotNull() {
+        return new QueryColumnCondition(this, 'is-not-null');
+    }
+}
+export default QueryColumn;

package/lib-prod/builder/column/string-column.js

@@ -0,0 +1,33 @@
+import ComparableColumn from "./comparable-column";
+import NumberColumn from "./number-column";
+import QueryColumnCondition from "../condition/query-column-condition";
+export default class StringColumn extends ComparableColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+        this._type = 'string';
+    }
+    count() {
+        return new NumberColumn(this._table, this._name, this._modifiers.concat({ name: 'count' }));
+    }
+    lower() {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'lower' }));
+    }
+    upper() {
+        return new this.constructor(this._table, this._name, this._modifiers.concat({ name: 'upper' }));
+    }
+    contains(value) {
+        return this.like('%' + value + '%');
+    }
+    startsWith(value) {
+        return this.like(value + '%');
+    }
+    endsWith(value) {
+        return this.like('%' + value);
+    }
+    like(value) {
+        return new QueryColumnCondition(this, 'like', value);
+    }
+    notLike(value) {
+        return new QueryColumnCondition(this, 'not-like', value);
+    }
+}

package/lib-prod/builder/column/value-column.js

@@ -0,0 +1,27 @@
+import QueryColumnCondition from "../condition/query-column-condition";
+import QueryOrdering from "../other/query-ordering";
+import QueryColumn from "./query-column";
+import QueryJoinCondition from "../condition/query-join-condition";
+class ValueColumn extends QueryColumn {
+    constructor(table, name, modifiers = []) {
+        super(table, name, modifiers);
+    }
+    asc() {
+        return new QueryOrdering(this, 'ASC');
+    }
+    desc() {
+        return new QueryOrdering(this, 'DESC');
+    }
+    eq(value) {
+        if (value instanceof QueryColumn) {
+            return new QueryJoinCondition(this, 'eq', value);
+        }
+        else {
+            return new QueryColumnCondition(this, 'eq', value);
+        }
+    }
+    ne(value) {
+        return new QueryColumnCondition(this, 'ne', value);
+    }
+}
+export default ValueColumn;

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

@@ -0,0 +1,16 @@
+import QueryCondition from "./query-condition";
+import QueryConditionChain from "./query-condition-chain";
+export default class QueryColumnCondition extends QueryCondition {
+    constructor(column, type, ...values) {
+        super();
+        this._column = column;
+        this._type = type;
+        this._values = values;
+    }
+    and(condition) {
+        return new QueryConditionChain(this, condition, 'and');
+    }
+    or(condition) {
+        return new QueryConditionChain(this, condition, 'or');
+    }
+}

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

@@ -0,0 +1,26 @@
+import QueryCondition from "./query-condition";
+export default class QueryConditionChain extends QueryCondition {
+    constructor(sibling, child, chainType) {
+        super();
+        this._parenthesis = false;
+        this._negation = false;
+        this._sibling = sibling;
+        this._child = child;
+        this._chainType = chainType;
+    }
+    // TODO how to call this
+    $() {
+        this._parenthesis = true;
+        return this;
+    }
+    not() {
+        this._negation = true;
+        return this;
+    }
+    and(condition) {
+        return new QueryConditionChain(this, condition, 'and');
+    }
+    or(condition) {
+        return new QueryConditionChain(this, condition, 'or');
+    }
+}

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

@@ -0,0 +1,4 @@
+// TODO I had to copy-paste the method implementations to every child class to avoid circular dependencies
+class QueryCondition {
+}
+export default QueryCondition;

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

@@ -0,0 +1,16 @@
+import QueryCondition from "./query-condition";
+import QueryConditionChain from "./query-condition-chain";
+export default class QueryJoinCondition extends QueryCondition {
+    constructor(column, type, otherColumn) {
+        super();
+        this._column = column;
+        this._type = type;
+        this._otherColumn = otherColumn;
+    }
+    and(condition) {
+        return new QueryConditionChain(this, condition, 'and');
+    }
+    or(condition) {
+        return new QueryConditionChain(this, condition, 'or');
+    }
+}

package/lib-prod/builder/helpers/{generics-helper.ts → generics-helper.js}

@@ -1,2 +1,3 @@
 // TODO In TS generic parameters not used in the class are not enforced, so I have to add dummy fields that use them. Replace with nominal typing
-export default class GenericsHelper<T> {}
+export default class GenericsHelper {
+}

package/lib-prod/builder/helpers/internal-types.js

@@ -0,0 +1 @@
+export {};

package/lib-prod/builder/join/joined-tables-chain.js

@@ -0,0 +1,11 @@
+import JoinedTables from "./joined-tables";
+export default class JoinedTablesChain {
+    constructor(_table, _modifier, _parent) {
+        this._table = _table;
+        this._modifier = _modifier;
+        this._parent = _parent;
+    }
+    on(condition) {
+        return new JoinedTables(condition, this);
+    }
+}

package/lib-prod/builder/join/joined-tables.js

@@ -0,0 +1,19 @@
+import JoinedTablesChain from "./joined-tables-chain";
+export default class JoinedTables {
+    constructor(_condition, _parent) {
+        this._condition = _condition;
+        this._parent = _parent;
+    }
+    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);
+    }
+}

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

@@ -0,0 +1,14 @@
+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;
+    }
+}

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

@@ -0,0 +1,45 @@
+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);
+    }
+}

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

@@ -0,0 +1,22 @@
+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]);
+    }
+}

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

@@ -0,0 +1,52 @@
+import TableConditionQuery from "./table-condition-query";
+import ValueColumn from "../column/value-column";
+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])));
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import SelectQuery from './query/select-query';
+import TableQuery from "./query/table-query";
+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);
+    }
+}

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

@@ -0,0 +1,22 @@
+import BasicColumn from "./column/basic-column";
+import JoinedTablesChain from "./join/joined-tables-chain";
+class QueryTable {
+    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);
+    }
+}
+export default QueryTable;

package/lib-prod/client/{mysql.ts → mysql.js}

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

package/lib-prod/client/{pg.ts → pg.js}

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

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

@@ -0,0 +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');
+const DEFAULT_OPTIONS = {
+    lineBreaks: false,
+    parameterized: true,
+    logging: true,
+    identifierQuote: '"'
+};
+function mySqlTypeCast(field, next) {
+    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));
+        }
+    };
+}

package/lib-prod/converter/{param-converter.ts → param-converter.js}

@@ -1,23 +1,26 @@
-export function convertSubstitutionParam(param: any): string {
-    if (param == null) return 'NULL';
+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) {
+    }
+    else if (typeof param === 'boolean' || param instanceof Boolean) {
         return String(param).toUpperCase();
-    } else if (param instanceof Date) {
+    }
+    else if (param instanceof Date) {
         return `'${param.toISOString()}'`;
-    } else if (typeof param === 'number' || param instanceof Number) {
+    }
+    else if (typeof param === 'number' || param instanceof Number) {
         return String(param);
     }
     return `'${JSON.stringify(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: any) {
+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;
-}
+}