taon-type-sql 21.0.21 → 21.0.22

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

@@ -0,0 +1,35 @@
+import QueryTable from "../query-table";
+import QueryCondition from "../condition/query-condition";
+import QueryColumn from "../column/query-column";
+import { QueryProcessor, QueryAction } from "../helpers/internal-types";
+
+
+export default class TableConditionQuery<Entity, Table extends QueryTable<Entity, any>> {
+
+    constructor(
+        protected _queryProcessor: QueryProcessor,
+        protected _table: Table,
+        protected _conditions: QueryCondition<Table>[]
+    ) {}
+
+    protected _columns: QueryColumn<Table, any>[] = [];
+    protected _action: QueryAction;
+    protected _entity: Entity | Partial<Entity>;
+
+    update(entity: Partial<Entity>): Promise<number> {
+        this._entity = entity;
+        this._action = 'update';
+        return this._queryProcessor(this);
+    }
+
+    delete(): Promise<number> {
+        this._action = 'delete';
+        return this._queryProcessor(this);
+    }
+
+    count(): Promise<number> {
+        this._columns = [this._table.$all.count()];
+        this._action = 'select';
+        return this._queryProcessor(this).then((rows: number[]) => rows[0]);
+    }
+}

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

@@ -0,0 +1,72 @@
+import QueryTable from "../query-table";
+import TableConditionQuery from "./table-condition-query";
+import QueryCondition from "../condition/query-condition";
+import ValueColumn from "../column/value-column";
+import QueryColumn from "../column/query-column";
+import { QueryProcessor, QueryAction } from "../helpers/internal-types";
+
+
+export default class TableQuery<Entity, Id, Table extends QueryTable<Entity, Id>> {
+
+    constructor(
+        protected _queryProcessor: QueryProcessor,
+        protected _table: Table
+    ) {}
+
+    protected _entity: Entity | Entity[] | Partial<Entity>;
+    protected _action: QueryAction;
+    protected _columns: QueryColumn<Table, any>[] = [];
+
+    where(...conditions: QueryCondition<Table>[]) {
+        return new TableConditionQuery<Entity, Table>(this._queryProcessor, this._table, conditions);
+    }
+
+    insert(entity: Entity): Promise<any> // returns the generated ID, but not other kinds of IDs, so the type is unknown (mysql limitations)
+    insert(entities: Entity[]): Promise<void>
+    insert(param: any): Promise<any> {
+        this._entity = param;
+        this._action = 'insert';
+        return this._queryProcessor(this);
+    }
+
+    deleteAll(): Promise<number> {
+        this._action = 'delete';
+        return this._queryProcessor(this);
+    }
+
+    updateAll(entity: Partial<Entity>): Promise<number> {
+        this._entity = entity;
+        this._action = 'update';
+        return this._queryProcessor(this);
+    }
+
+    countAll(): Promise<number> {
+        this._columns = [this._table.$all.count()];
+        this._action = 'select';
+        return this._queryProcessor(this).then((rows: any[]) => rows[0]);
+    }
+
+    delete(id: Id): Promise<boolean> {
+        return this._whereId(id).delete().then(count => count > 0);
+    }
+
+    update(id: Id, entity: Partial<Entity>): Promise<boolean> {
+        return this._whereId(id).update(entity).then(count => count > 0);
+    }
+
+    get(id: Id): Promise<Entity | undefined> {
+        let query = this._whereId(id);
+        return this._queryProcessor({ _action: 'select', ...query })
+            .then((rows: Entity[]) => rows[0]);
+    }
+
+    _whereId(id: Id): TableConditionQuery<Entity, Table> {
+        // TODO remove assertions if $id typing is fixed
+        let $id = (this._table as any).$id;
+        if ($id instanceof ValueColumn) {
+            return this.where($id.eq(id));
+        } else {
+            return this.where(...Object.keys($id).map(key => ((this._table as any)[key] as ValueColumn<Table, any>).eq((id as any)[key] as any)));
+        }
+    }
+}

package/lib-prod/builder/{query-source.d.ts → query-source.ts}

@@ -3,12 +3,23 @@ import SelectQuery from './query/select-query';
 import { QueryProcessor } from "./helpers/internal-types";
 import JoinedTables from "./join/joined-tables";
 import TableQuery from "./query/table-query";
+
+
 export default class QuerySource {
-    protected _queryProcessor: QueryProcessor;
-    constructor(_queryProcessor: QueryProcessor);
-    from<Entity, Table1 extends QueryTable<Entity, any>>(table1: Table1 & QueryTable<Entity, any>): SelectQuery<Entity, Table1>;
-    from<Tables extends QueryTable<any, any>>(tables: JoinedTables<Tables>): SelectQuery<any, Tables>;
-    from<Table1 extends QueryTable<any, any>, Table2 extends QueryTable<any, any>>(table1: Table1, table2: Table2): SelectQuery<any, Table1 | Table2>;
-    from<Table1 extends QueryTable<any, any>, Table2 extends QueryTable<any, any>, Table3 extends QueryTable<any, any>>(table1: Table1, table2: Table2, table3: Table3): SelectQuery<any, Table1 | Table2 | Table3>;
-    table<Entity, Id, Table extends QueryTable<Entity, Id>>(table: Table & QueryTable<Entity, Id>): TableQuery<Entity, Id, Table>;
-}
+
+    constructor(protected _queryProcessor: QueryProcessor) {}
+
+    from<Entity, Table1 extends QueryTable<Entity, any>>(table1: Table1 & QueryTable<Entity, any>): SelectQuery<Entity, Table1>
+    from<Tables extends QueryTable<any, any>>(tables: JoinedTables<Tables>): SelectQuery<any, Tables>
+    from<Table1 extends QueryTable<any, any>, Table2 extends QueryTable<any, any>>(table1: Table1, table2: Table2): SelectQuery<any, Table1 | Table2>
+    from<Table1 extends QueryTable<any, any>, Table2 extends QueryTable<any, any>, Table3 extends QueryTable<any, any>>(table1: Table1, table2: Table2, table3: Table3): SelectQuery<any, Table1 | Table2 | Table3>
+    from<Entity, Table1 extends QueryTable<any, any>, Table2 extends QueryTable<any, any>, Table3 extends QueryTable<any, any>>(table1: any, table2?: any, table3?: any) {
+        if (table3 != null) return new SelectQuery<any, Table1 | Table2 | Table3>(this._queryProcessor, [table1, table2, table3]);
+        else if (table2 != null) return new SelectQuery<any, Table1 | Table2>(this._queryProcessor, [table1, table2]);
+        return new SelectQuery<Entity, Table1>(this._queryProcessor, [table1]);
+    }
+
+    table<Entity, Id, Table extends QueryTable<Entity, Id>>(table: Table & QueryTable<Entity, Id>): TableQuery<Entity, Id, Table> {
+        return new TableQuery<Entity, Id, Table>(this._queryProcessor, table);
+    }
+}

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

@@ -0,0 +1,34 @@
+import BasicColumn from "./column/basic-column";
+import GenericsHelper from "./helpers/generics-helper";
+import JoinedTablesChain from "./join/joined-tables-chain";
+
+
+abstract class QueryTable<Entity, Id> {
+
+    constructor(protected _$name: string) {}
+
+    protected _$type: GenericsHelper<Entity>;
+    protected _$idType: GenericsHelper<Id>;
+
+    // abstract readonly $id; // FIXME I got a dozen incomprehensible type errors
+
+    $all = new BasicColumn<this, Entity>(this, '*');
+
+    innerJoin<JoinTable extends QueryTable<any, any>>(table: JoinTable): JoinedTablesChain<this | JoinTable> {
+        return new JoinedTablesChain<this | JoinTable>(table, 'inner', this);
+    }
+
+    leftJoin<JoinTable extends QueryTable<any, any>>(table: JoinTable): JoinedTablesChain<this | JoinTable> {
+        return new JoinedTablesChain<this | JoinTable>(table, 'left', this);
+    }
+
+    rightJoin<JoinTable extends QueryTable<any, any>>(table: JoinTable): JoinedTablesChain<this | JoinTable> {
+        return new JoinedTablesChain<this | JoinTable>(table, 'right', this);
+    }
+
+    fullJoin<JoinTable extends QueryTable<any, any>>(table: JoinTable): JoinedTablesChain<this | JoinTable> {
+        return new JoinedTablesChain<this | JoinTable>(table, 'full', this);
+    }
+}
+
+export default QueryTable;

package/lib-prod/client/mysql.ts

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

package/lib-prod/client/pg.ts

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

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

@@ -0,0 +1,89 @@
+import { Log, Level } from 'ng2-logger/lib-prod';
+import { convertQueryToParameterizedSQL } from '../converter/parameterized-converter';
+import { convertQueryToSQL } from '../converter/sql-converter';
+import { convertResult } from "../converter/result-converter";
+import { QueryEngine, ConverterOptions } from '../converter/types';
+import { QueryProcessor } from '../builder/helpers/internal-types';
+import { Helpers__NS___fixCommand, Helpers__NS__bigMaxBuffer, Helpers__NS__checkProcess, Helpers__NS__cleanExit, Helpers__NS__clearConsole, Helpers__NS__command, Helpers__NS__commandOutputAsString, Helpers__NS__commandOutputAsStringAsync, Helpers__NS__compilationWrapper, Helpers__NS__contain, Helpers__NS__createFolder, Helpers__NS__createSymLink, Helpers__NS__error, Helpers__NS__execute, Helpers__NS__exists, Helpers__NS__filesFrom, Helpers__NS__foldersFrom, Helpers__NS__getFilesFrom, Helpers__NS__getFoldersFrom, Helpers__NS__getIsBrowser, Helpers__NS__getIsElectron, Helpers__NS__getIsNode, Helpers__NS__getIsRunningInGitBash, Helpers__NS__getIsSupportedTaonTerminal, Helpers__NS__getIsVerboseMode, Helpers__NS__getIsWebSQL, Helpers__NS__getIsWsl, Helpers__NS__getStdio, Helpers__NS__hideNodeWarnings, Helpers__NS__info, Helpers__NS__isBlob, Helpers__NS__isBuffer, Helpers__NS__isClass, Helpers__NS__isExistedSymlink, Helpers__NS__isFile, Helpers__NS__isFolder, Helpers__NS__isRunningInDocker, Helpers__NS__isRunningInLinuxGraphicsCapableEnvironment, Helpers__NS__isSymlinkFileExitedOrUnexisted, Helpers__NS__isSymlinkThatMatchesUrl, Helpers__NS__isUnexistedLink, Helpers__NS__killOnPort, Helpers__NS__killProcess, Helpers__NS__killProcessByPort, Helpers__NS__linksToFolderFrom, Helpers__NS__linksToFoldersFrom, Helpers__NS__log, Helpers__NS__logError, Helpers__NS__logInfo, Helpers__NS__logProc, Helpers__NS__logSuccess, Helpers__NS__logWarn, Helpers__NS__mediaTypeFromSrc, Helpers__NS__mkdirp, Helpers__NS__modifyLineByLine, Helpers__NS__msgCacheClear, Helpers__NS__openFolderInFileExplorer, Helpers__NS__parse, Helpers__NS__pathContainLink, Helpers__NS__questionYesNo, Helpers__NS__readFile, Helpers__NS__readJson, Helpers__NS__readJson5, Helpers__NS__readJsonC, Helpers__NS__relative, Helpers__NS__remove, Helpers__NS__removeEmptyLineFromString, Helpers__NS__removeFileIfExists, Helpers__NS__removeFolderIfExists, Helpers__NS__removeIfExists, Helpers__NS__removeSlashAtBegin, Helpers__NS__removeSlashAtEnd, Helpers__NS__removeSymlinks, Helpers__NS__renderError, Helpers__NS__replaceLinesInFile, Helpers__NS__run, Helpers__NS__runAsyncIn, Helpers__NS__runSyncIn, Helpers__NS__runSyncOrAsync, Helpers__NS__sleep, Helpers__NS__stopApplication, Helpers__NS__stringify, Helpers__NS__success, Helpers__NS__taskDone, Helpers__NS__taskStarted, Helpers__NS__throwError, Helpers__NS__timeout, Helpers__NS__tryCatchError, Helpers__NS__tryReadFile, Helpers__NS__tryRemoveDir, Helpers__NS__values, Helpers__NS__wait, Helpers__NS__warn, Helpers__NS__writeFile, Helpers__NS__writeJson, Helpers__NS__writeJson5, Helpers__NS__writeJsonC } from 'tnp-core/lib-prod';
+
+const log = Log.create('query processor',
+  // Level.__NOTHING
+)
+
+export interface QueryProcessorOptions {
+  lineBreaks?: boolean,
+  parameterized?: boolean,
+  logging?: boolean,
+  logger?: (sql: string, params?: any[]) => void,
+  identifierQuote?: string
+}
+
+const DEFAULT_OPTIONS: QueryProcessorOptions = {
+  lineBreaks: false,
+  parameterized: true,
+  logging: true,
+  identifierQuote: '"'
+};
+
+function mySqlTypeCast(field: any, next: any) {
+  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: any, _options: QueryProcessorOptions = {}, engine: QueryEngine = 'pg'): QueryProcessor {
+
+  let options: QueryProcessorOptions = Object.assign({}, DEFAULT_OPTIONS, _options);
+
+  let queryOptions: ConverterOptions = {
+    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: any) => {
+    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.js → param-converter.ts}

@@ -1,31 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertSubstitutionParam = convertSubstitutionParam;
-exports.convertEscapedParam = convertEscapedParam;
-function convertSubstitutionParam(param) {
-    if (param == null)
-        return 'NULL';
+export function convertSubstitutionParam(param: any): string {
+    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
-function convertEscapedParam(param) {
+export function convertEscapedParam(param: any) {
     if (typeof param === 'object' && !(param == null || param instanceof String || param instanceof Number ||
         param instanceof Boolean || param instanceof Date)) {
         return JSON.stringify(param);
     }
     return param;
-}
-//# sourceMappingURL=param-converter.js.map
+}

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

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