sasat 0.19.37 → 0.19.39

package/lib/db/connectors/mysql/client.d.ts

@@ -3,6 +3,7 @@ import * as mysql from 'mysql2';
 export declare class MysqlClient extends DBClient {
     readonly connectionOption?: Partial<mysql.ConnectionOptions> | undefined;
     private readonly pool;
+    logger: (sql: string) => void;
     constructor(connectionOption?: Partial<mysql.ConnectionOptions> | undefined, poolOption?: Partial<mysql.PoolOptions>);
     transaction(): Promise<SQLTransaction>;
     release(): Promise<void>;

package/lib/db/connectors/mysql/client.js

@@ -8,6 +8,7 @@ export class MysqlClient extends DBClient {
     constructor(connectionOption, poolOption) {
         super();
         this.connectionOption = connectionOption;
+        this.logger = () => { };
         this.pool = mysql.createPool({
             ...defaultConfig,
             ...connectionOption,
@@ -28,6 +29,7 @@ export class MysqlClient extends DBClient {
         this._released = true;
     }
     execSql(sql) {
+        this.logger(sql);
         return promisify(this.pool.query).bind(this.pool)(sql);
     }
 }

package/lib/db/sql/condition.js

@@ -28,12 +28,12 @@ export const orderToSQL = (order) => order
     .join(', ');
 const mergeWhereClause = (whereClauses) => {
     const result = [];
-    whereClauses.forEach(it => {
+    for (const it of whereClauses) {
         if (Array.isArray(it))
             result.push(...it);
         else
             result.push(it);
-    });
+    }
     return result;
 };
 export const createSQLString = (sql) => {

package/lib/runtime/dsl/factory.d.ts

@@ -4,14 +4,14 @@ type StrOrNum = string | number;
 type ValueType = string | boolean | number | null;
 export declare const QExpr: {
     readonly field: (table: string, name: string, alias?: string) => Field;
-    readonly fn: (fnName: string, args: Value[]) => Fn;
+    readonly fn: (fnName: string, args: Value[], alias?: string) => Fn;
     readonly paren: (expression: BooleanValueExpression) => ParenthesisExpression;
     readonly table: (name: string, joins: Join[], alias: string) => QueryTable;
     readonly subQueryTable: (query: Query, joins: Join[], alias: string) => QueryTable;
     readonly join: (table: QueryTable, conditions: BooleanValueExpression, type?: JoinType) => Join;
     readonly value: (value: ValueType) => Literal;
-    readonly sort: (field: Field | Fn, direction?: SortDirection) => Sort;
-    readonly order: (field: Field | Fn, direction?: SortDirection) => Sort;
+    readonly sort: (field: Field | Fn | Identifier, direction?: SortDirection) => Sort;
+    readonly order: (field: Field | Fn | Identifier, direction?: SortDirection) => Sort;
     readonly ident: (identifier: string) => Identifier;
     readonly raw: (sql: string) => RawExpression;
     readonly simpleWhere: (tableNameOrAlias: string, where: {
@@ -28,11 +28,11 @@ export declare const QExpr: {
     readonly comparison: (left: Value, operator: ComparisonOperators, right: Value) => ComparisonExpression;
     readonly contains: (left: Value, right: string) => BooleanValueExpression;
     readonly notContains: (left: Value, right: string) => BooleanValueExpression;
-    readonly statsWiths: (left: Value, right: string) => BooleanValueExpression;
-    readonly notStatsWiths: (left: Value, right: string) => BooleanValueExpression;
-    readonly endsWiths: (left: Value, right: string) => BooleanValueExpression;
-    readonly notEndsWiths: (left: Value, right: string) => BooleanValueExpression;
-    readonly In: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
+    readonly startsWith: (left: Value, right: string) => BooleanValueExpression;
+    readonly notStartsWith: (left: Value, right: string) => BooleanValueExpression;
+    readonly endsWith: (left: Value, right: string) => BooleanValueExpression;
+    readonly notEndsWith: (left: Value, right: string) => BooleanValueExpression;
+    readonly in: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
     readonly notIn: (left: Value, values: StrOrNum[]) => InExpression;
     readonly between: (left: Value, begin: Value, end: Value) => BetweenExpression;
     readonly isNull: (expr: Value) => IsNullExpression;
@@ -53,11 +53,11 @@ export declare const QExpr: {
         comparison: (left: Value, operator: ComparisonOperators, right: Value) => ComparisonExpression;
         contains: (left: Value, right: string) => BooleanValueExpression;
         notContains: (left: Value, right: string) => BooleanValueExpression;
-        statsWiths: (left: Value, right: string) => BooleanValueExpression;
-        notStatsWiths: (left: Value, right: string) => BooleanValueExpression;
-        endsWiths: (left: Value, right: string) => BooleanValueExpression;
-        notEndsWiths: (left: Value, right: string) => BooleanValueExpression;
-        In: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
+        startsWith: (left: Value, right: string) => BooleanValueExpression;
+        notStartsWith: (left: Value, right: string) => BooleanValueExpression;
+        endsWith: (left: Value, right: string) => BooleanValueExpression;
+        notEndsWith: (left: Value, right: string) => BooleanValueExpression;
+        in: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
         notIn: (left: Value, values: StrOrNum[]) => InExpression;
         between: (left: Value, begin: Value, end: Value) => BetweenExpression;
         isNull: (expr: Value) => IsNullExpression;

package/lib/runtime/dsl/factory.js

@@ -29,10 +29,11 @@ const field = (table, name, alias) => ({
     name: name,
     alias,
 });
-const fn = (fnName, args) => ({
+const fn = (fnName, args, alias) => ({
     kind: QueryNodeKind.Function,
     fnName,
     args,
+    alias,
 });
 const paren = (expression) => ({
     kind: QueryNodeKind.Parenthesis,
@@ -103,11 +104,11 @@ const conditions = {
     comparison: (left, operator, right) => comparison(operator)(left, right),
     contains: containsExpr(false, 'contains'),
     notContains: containsExpr(true, 'contains'),
-    statsWiths: containsExpr(false, 'start'),
-    notStatsWiths: containsExpr(true, 'start'),
-    endsWiths: containsExpr(false, 'end'),
-    notEndsWiths: containsExpr(true, 'end'),
-    In,
+    startsWith: containsExpr(false, 'start'),
+    notStartsWith: containsExpr(true, 'start'),
+    endsWith: containsExpr(false, 'end'),
+    notEndsWith: containsExpr(true, 'end'),
+    in: In,
     notIn,
     between,
     isNull: isNull(false),

package/lib/runtime/dsl/query/query.d.ts

@@ -20,7 +20,7 @@ export declare enum QueryNodeKind {
 }
 export type LockMode = 'FOR UPDATE' | 'FOR SHARE';
 export type Query = {
-    select: Select;
+    select: SelectExpr[];
     from: QueryTable;
     where?: BooleanValueExpression;
     groupBy?: GroupByExpr;
@@ -34,13 +34,11 @@ export type GroupByExpr = {
     kind: QueryNodeKind.GroupBy;
     cols: (Field | Identifier)[];
 };
-type Select = SelectExpr[];
-export declare const NO_ALIAS: "__SASAT_NO_ALIAS";
 export type Field = {
     kind: QueryNodeKind.Field;
     table: string;
     name: string;
-    alias?: string | typeof NO_ALIAS;
+    alias?: string;
 };
 export type Fn = {
     kind: QueryNodeKind.Function;
@@ -48,13 +46,13 @@ export type Fn = {
     args: Value[];
     alias?: string;
 };
-export type SelectExpr = Field | Fn;
+export type SelectExpr = Field | Fn | Identifier;
 export type QueryTable = {
     kind: QueryNodeKind.Table;
     alias: string;
     joins: Join[];
 } & ({
-    subquery: false;
+    subquery?: false;
     name: string;
 } | {
     subquery: true;
@@ -137,4 +135,3 @@ export type Sort = {
     direction?: SortDirection;
 };
 export type QueryNode = Field | Fn | QueryTable | Literal | BooleanValueExpression | Join | Sort;
-export {};

package/lib/runtime/dsl/query/query.js

@@ -18,4 +18,3 @@ export var QueryNodeKind;
     QueryNodeKind[QueryNodeKind["Raw"] = 15] = "Raw";
     QueryNodeKind[QueryNodeKind["GroupBy"] = 16] = "GroupBy";
 })(QueryNodeKind || (QueryNodeKind = {}));
-export const NO_ALIAS = '__SASAT_NO_ALIAS';

package/lib/runtime/dsl/query/sql/hydrate.js

@@ -1,13 +1,13 @@
 import { SELECT_ALIAS_SEPARATOR } from './nodeToSql.js';
 const rowToObjs = (row) => {
     const objs = {};
-    Object.entries(row).forEach(([key, value]) => {
+    for (const [key, value] of Object.entries(row)) {
         const [table, column] = key.split(SELECT_ALIAS_SEPARATOR);
         if (!objs[table]) {
             objs[table] = {};
         }
         objs[table][column] = value;
-    });
+    }
     return objs;
 };
 const getUnique = (obj, info) => info.keyAliases.map(it => obj[it]).join('_~_');
@@ -44,9 +44,9 @@ const execTable = (info, objs, current) => {
         result = currentTarget;
     }
     if (currentTarget !== null) {
-        info.joins.forEach(it => {
+        for (const it of info.joins) {
             currentTarget[it.property] = execTable(it, objs, currentTarget[it.property]);
-        });
+        }
     }
     return result;
 };
@@ -54,17 +54,17 @@ export const hydrate = (data, info) => {
     const result = [];
     const t0mapper = {};
     info.isArray = false;
-    data.forEach(row => {
+    for (const row of data) {
         const objs = rowToObjs(row);
         const currentObj = objs[info.tableAlias];
         const unique = getUnique(currentObj, info);
         if (t0mapper[unique] === undefined) {
             t0mapper[unique] = result.length;
             result.push(execTable(info, objs, currentObj));
-            return;
+            continue;
         }
         const base = result[t0mapper[unique]];
         execTable(info, objs, base);
-    });
+    }
     return result;
 };

package/lib/runtime/dsl/query/sql/nodeToSql.js

@@ -3,7 +3,16 @@ import { SqlString } from '../../../sql/sqlString.js';
 import { queryToSql } from './queryToSql.js';
 export const SELECT_ALIAS_SEPARATOR = '__';
 export const Sql = {
-    select: (expr) => expr.kind === QueryNodeKind.Field ? Sql.fieldInSelect(expr) : Sql.fn(expr),
+    select: (expr) => {
+        switch (expr.kind) {
+            case QueryNodeKind.Field:
+                return Sql.fieldInSelect(expr);
+            case QueryNodeKind.Identifier:
+                return Sql.identifier(expr);
+            case QueryNodeKind.Function:
+                return Sql.fn(expr);
+        }
+    },
     literal: (literal) => SqlString.escape(literal.value),
     fieldInCondition: (identifier) => SqlString.escapeId(identifier.table) +
         '.' +
@@ -20,7 +29,7 @@ export const Sql = {
     identifier: (ident) => {
         return SqlString.escapeId(ident.identifier);
     },
-    fn: (fn) => `${fn.fnName}(${fn.args.map(Sql.value).join(',')})`,
+    fn: (fn) => `${fn.fnName}(${fn.args.map(Sql.value).join(',')})${fn.alias ? ` AS ${fn.alias}` : ''}`,
     value: (v) => {
         if (v.kind === QueryNodeKind.Function)
             return Sql.fn(v);

package/lib/runtime/gqlResolveInfoToField.js

@@ -5,9 +5,9 @@ export const selectionSetToField = (selections, number) => {
         tableAlias: 't' + number,
     };
     let num = number;
-    selections.forEach(it => {
+    for (const it of selections) {
         if (it.kind !== 'Field')
-            return;
+            continue;
         if (it.selectionSet) {
             num += 1;
             const field = selectionSetToField(it.selectionSet.selections, num);
@@ -15,9 +15,10 @@ export const selectionSetToField = (selections, number) => {
             num = field[1];
         }
         else {
-            result.fields.push(it.name.value);
+            if (it.name.value !== '__typename')
+                result.fields.push(it.name.value);
         }
-    });
+    }
     return [result, num];
 };
 export const gqlResolveInfoToField = (info) => {

package/lib/runtime/sql/runQuery.d.ts

@@ -4,7 +4,7 @@ import { RelationMap, TableInfo } from '../dsl/query/createQueryResolveInfo.js';
 import { Fields } from '../field.js';
 import { QueryResolveInfo } from '../dsl/query/sql/hydrate.js';
 import { QueryOptions } from '../sasatDBDatasource.js';
-export declare const createQuery: (baseTableName: string, fields: Fields<unknown>, options: QueryOptions | undefined, tableInfo: TableInfo, relationMap: RelationMap, context?: unknown) => Query;
+export declare const createQuery: (baseTableName: string, fields: Fields<any>, options: QueryOptions | undefined, tableInfo: TableInfo, relationMap: RelationMap, context?: unknown) => Query;
 export type PagingOption = {
     numberOfItem: number;
     where?: BooleanValueExpression;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasat",
-  "version": "0.19.37",
+  "version": "0.19.39",
   "repository": "https://github.com/nin138/sasat.git",
   "author": "nin138 <ninian138@gmail.com>",
   "license": "MIT",