taon-type-sql 21.0.21 → 21.0.23

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

@@ -1,284 +1,268 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createQueryConverter = createQueryConverter;
-const type_converter_1 = require("./type-converter");
+import { string, number, date, boolean } from "./type-converter";
 function createQueryConverter(paramConverter, options, engine) {
-    return convertQuery;
-    function convertQuery(query) {
-        if (query._action === 'select')
-            return convertSelectQuery(query);
-        if (query._action === 'delete')
-            return convertDeleteQuery(query);
-        if (query._action === 'update')
-            return convertUpdateQuery(query);
-        if (query._action === 'insert')
-            return convertInsertQuery(query);
-        throw new Error('Unknown query type:' + query._action);
+  return convertQuery;
+  function convertQuery(query) {
+    if (query._action === "select") return convertSelectQuery(query);
+    if (query._action === "delete") return convertDeleteQuery(query);
+    if (query._action === "update") return convertUpdateQuery(query);
+    if (query._action === "insert") return convertInsertQuery(query);
+    throw new Error("Unknown query type:" + query._action);
+  }
+  function convertDeleteQuery(query) {
+    let s = "DELETE FROM " + convertTable(query._table);
+    s += convertConditions(query._conditions);
+    return s;
+  }
+  function convertUpdateQuery(query) {
+    let s = "UPDATE " + convertTable(query._table) + " SET ";
+    s += convertUpdateSetters(query._table, query._entity);
+    s += convertConditions(query._conditions);
+    return s;
+  }
+  function convertUpdateSetters(table, entity) {
+    return Object.keys(entity).sort().map((key) => {
+      let value = entity[key];
+      let column = table[key];
+      return convertColumnName(column) + " = " + convertParam(column, value);
+    }).join(", ");
+  }
+  function convertInsertQuery(query) {
+    let items = Array.isArray(query._entity) ? query._entity : [query._entity];
+    let keySet = items.reduce((set, item) => {
+      Object.keys(item).forEach((key) => set.add(key));
+      return set;
+    }, /* @__PURE__ */ new Set());
+    let keys = Array.from(keySet).sort();
+    let s = "INSERT INTO " + convertTable(query._table) + " ";
+    s += "(" + keys.map((key) => convertColumnName(query._table[key])).join(", ") + ")";
+    s += options.lineBreak + "VALUES ";
+    s += items.map((item) => convertInsertItem(query._table, item, keys)).map((row) => "(" + row + ")").join(", ");
+    s += getPgInsertReturningIfNeeded(query);
+    return s;
+  }
+  function getPgInsertReturningIfNeeded(query) {
+    if (engine === "pg" && query._action === "insert" && !Array.isArray(query._entity) && query._table.$id && query._table.$id._table && query._table.$id._name) {
+      return " RETURNING " + convertColumnName(query._table.$id);
     }
-    function convertDeleteQuery(query) {
-        let s = 'DELETE FROM ' + convertTable(query._table);
-        s += convertConditions(query._conditions);
-        return s;
+    return "";
+  }
+  function convertInsertItem(table, entity, keys) {
+    return keys.map((key) => {
+      let value = entity[key];
+      let column = table[key];
+      return convertParam(column, value);
+    }).join(", ");
+  }
+  function convertSelectQuery(query) {
+    let s = "SELECT ";
+    if (query._distinct) {
+      s += "DISTINCT ";
     }
-    function convertUpdateQuery(query) {
-        let s = 'UPDATE ' + convertTable(query._table) + ' SET ';
-        s += convertUpdateSetters(query._table, query._entity);
-        s += convertConditions(query._conditions);
-        return s;
+    if (query._columns == null || query._columns.length === 0) {
+      s += "*";
+    } else {
+      s += query._columns.map((column) => convertColumn(column)).join(", ");
     }
-    function convertUpdateSetters(table, entity) {
-        return Object.keys(entity).sort().map(key => {
-            let value = entity[key];
-            let column = table[key];
-            return convertColumnName(column) + ' = ' + convertParam(column, value);
-        }).join(', ');
+    s += options.lineBreak + "FROM ";
+    if (query._tables) {
+      s += query._tables.map((table) => table._parent ? convertJoin(table) : convertTable(table)).join(", ");
+    } else {
+      s += convertTable(query._table);
     }
-    function convertInsertQuery(query) {
-        let items = Array.isArray(query._entity) ? query._entity : [query._entity];
-        let keySet = items.reduce((set, item) => {
-            Object.keys(item).forEach(key => set.add(key));
-            return set;
-        }, new Set());
-        let keys = Array.from(keySet).sort();
-        let s = 'INSERT INTO ' + convertTable(query._table) + ' ';
-        s += '(' + keys.map(key => convertColumnName(query._table[key])).join(', ') + ')';
-        s += options.lineBreak + 'VALUES ';
-        s += items.map(item => convertInsertItem(query._table, item, keys))
-            .map((row) => '(' + row + ')').join(', ');
-        s += getPgInsertReturningIfNeeded(query);
-        return s;
+    s += convertConditions(query._conditions);
+    if (query._groupBy && query._groupBy.length > 0) {
+      s += options.lineBreak + "GROUP BY ";
+      s += query._groupBy.map((column) => convertColumn(column)).join(", ");
     }
-    function getPgInsertReturningIfNeeded(query) {
-        if (engine === 'pg' && query._action === 'insert' && !Array.isArray(query._entity) &&
-            query._table.$id && query._table.$id._table && query._table.$id._name) {
-            return ' RETURNING ' + convertColumnName(query._table.$id);
-        }
-        return '';
+    s += convertConditions(query._having, "HAVING");
+    if (query._orderings && query._orderings.length > 0) {
+      s += options.lineBreak + "ORDER BY ";
+      s += query._orderings.map((ordering) => convertOrdering(ordering)).join(", ");
     }
-    function convertInsertItem(table, entity, keys) {
-        return keys.map(key => {
-            let value = entity[key];
-            let column = table[key];
-            return convertParam(column, value);
-        }).join(', ');
+    if (query._limit != null) {
+      s += options.lineBreak + "LIMIT " + number(query._limit);
     }
-    function convertSelectQuery(query) {
-        let s = 'SELECT ';
-        if (query._distinct) {
-            s += 'DISTINCT ';
-        }
-        if (query._columns == null || query._columns.length === 0) {
-            s += '*';
-        }
-        else {
-            s += query._columns.map((column) => convertColumn(column)).join(', ');
-        }
-        s += options.lineBreak + 'FROM ';
-        if (query._tables) {
-            s += query._tables.map((table) => table._parent ? convertJoin(table) : convertTable(table)).join(', ');
-        }
-        else {
-            s += convertTable(query._table);
-        }
-        s += convertConditions(query._conditions);
-        if (query._groupBy && query._groupBy.length > 0) {
-            s += options.lineBreak + 'GROUP BY ';
-            s += query._groupBy.map((column) => convertColumn(column)).join(', ');
-        }
-        s += convertConditions(query._having, 'HAVING');
-        if (query._orderings && query._orderings.length > 0) {
-            s += options.lineBreak + 'ORDER BY ';
-            s += query._orderings.map((ordering) => convertOrdering(ordering)).join(', ');
-        }
-        if (query._limit != null) {
-            s += options.lineBreak + 'LIMIT ' + (0, type_converter_1.number)(query._limit);
-        }
-        if (query._offset != null) {
-            s += options.lineBreak + 'OFFSET ' + (0, type_converter_1.number)(query._offset);
-        }
-        return s;
+    if (query._offset != null) {
+      s += options.lineBreak + "OFFSET " + number(query._offset);
     }
-    function convertConditions(conditions, keyword = 'WHERE') {
-        let s = '';
-        if (conditions && conditions.length > 0) {
-            s += options.lineBreak + keyword + ' ';
-            preprocessConditions(conditions);
-            s += conditions.map(condition => convertCondition(condition, true)).join(' AND ');
-        }
-        return s;
+    return s;
+  }
+  function convertConditions(conditions, keyword = "WHERE") {
+    let s = "";
+    if (conditions && conditions.length > 0) {
+      s += options.lineBreak + keyword + " ";
+      preprocessConditions(conditions);
+      s += conditions.map((condition) => convertCondition(condition, true)).join(" AND ");
     }
-    function convertJoin(joinChain) {
-        let items = [];
-        while (joinChain) {
-            items.push(joinChain);
-            joinChain = joinChain._parent;
-        }
-        let root = items[items.length - 1];
-        let s = convertTable(root);
-        for (let i = items.length - 2; i >= 0; i -= 2) {
-            let table = items[i]._table;
-            let modifier = items[i]._modifier;
-            let condition = items[i - 1]._condition;
-            let param = convertColumn(condition._otherColumn);
-            s += ' ' + modifier.toUpperCase() + ' JOIN ' + convertTable(table) + ' ON ' +
-                convertColumnCondition(condition, param);
-        }
-        return s;
+    return s;
+  }
+  function convertJoin(joinChain) {
+    let items = [];
+    while (joinChain) {
+      items.push(joinChain);
+      joinChain = joinChain._parent;
     }
-    function convertOrdering(ordering) {
-        if (ordering._column) {
-            let s = convertColumn(ordering._column);
-            if (ordering._nullsPosition != null) { // "NULLS FIRST" only exists in PG, this is the general solution
-                s += ' IS NULL ' + (ordering._nullsPosition === 'FIRST' ? 'DESC' : 'ASC') + ', ' + s;
-            }
-            if (ordering._direction === 'ASC')
-                s += ' ASC';
-            if (ordering._direction === 'DESC')
-                s += ' DESC';
-            return s;
-        }
-        else {
-            return convertColumn(ordering);
-        }
+    let root = items[items.length - 1];
+    let s = convertTable(root);
+    for (let i = items.length - 2; i >= 0; i -= 2) {
+      let table = items[i]._table;
+      let modifier = items[i]._modifier;
+      let condition = items[i - 1]._condition;
+      let param = convertColumn(condition._otherColumn);
+      s += " " + modifier.toUpperCase() + " JOIN " + convertTable(table) + " ON " + convertColumnCondition(condition, param);
     }
-    function convertTable(table) {
-        return options.nameEscape + table._$name + options.nameEscape;
+    return s;
+  }
+  function convertOrdering(ordering) {
+    if (ordering._column) {
+      let s = convertColumn(ordering._column);
+      if (ordering._nullsPosition != null) {
+        s += " IS NULL " + (ordering._nullsPosition === "FIRST" ? "DESC" : "ASC") + ", " + s;
+      }
+      if (ordering._direction === "ASC") s += " ASC";
+      if (ordering._direction === "DESC") s += " DESC";
+      return s;
+    } else {
+      return convertColumn(ordering);
     }
-    function convertColumn(column) {
-        let s = '';
-        if (!(column._name === '*' && column._modifiers.length > 0 && column._modifiers[0].name === 'count')) {
-            s += convertTable(column._table) + '.';
-        }
-        s += convertColumnName(column);
-        return convertColumnModifiers(s, column);
+  }
+  function convertTable(table) {
+    return options.nameEscape + table._$name + options.nameEscape;
+  }
+  function convertColumn(column) {
+    let s = "";
+    if (!(column._name === "*" && column._modifiers.length > 0 && column._modifiers[0].name === "count")) {
+      s += convertTable(column._table) + ".";
     }
-    function convertColumnModifiers(s, column) {
-        if (column._modifiers) {
-            column._modifiers.forEach((modifier) => {
-                let name = modifier.name;
-                if (name === 'lower')
-                    s = 'LOWER(' + s + ')';
-                else if (name === 'upper')
-                    s = 'UPPER(' + s + ')';
-                else if (name === 'count')
-                    s = 'COUNT(' + s + ')';
-                else if (name === 'sum')
-                    s = 'SUM(' + s + ')';
-                else if (name === 'avg')
-                    s = 'AVG(' + s + ')';
-                else if (name === 'min')
-                    s = 'MIN(' + s + ')';
-                else if (name === 'max')
-                    s = 'MAX(' + s + ')';
-                else if (name === 'as')
-                    s = s + ' AS ' + options.nameEscape + modifier.params + options.nameEscape;
-            });
-        }
-        return s + '';
+    s += convertColumnName(column);
+    return convertColumnModifiers(s, column);
+  }
+  function convertColumnModifiers(s, column) {
+    if (column._modifiers) {
+      column._modifiers.forEach((modifier) => {
+        let name = modifier.name;
+        if (name === "lower") s = "LOWER(" + s + ")";
+        else if (name === "upper") s = "UPPER(" + s + ")";
+        else if (name === "count") s = "COUNT(" + s + ")";
+        else if (name === "sum") s = "SUM(" + s + ")";
+        else if (name === "avg") s = "AVG(" + s + ")";
+        else if (name === "min") s = "MIN(" + s + ")";
+        else if (name === "max") s = "MAX(" + s + ")";
+        else if (name === "as") s = s + " AS " + options.nameEscape + modifier.params + options.nameEscape;
+      });
     }
-    function convertColumnName(column) {
-        if (column._name === '*')
-            return column._name;
-        let name = typeof column._name === 'string' ? column._name : column._name.name;
-        return options.nameEscape + name + options.nameEscape;
+    return s + "";
+  }
+  function convertColumnName(column) {
+    if (column._name === "*") return column._name;
+    let name = typeof column._name === "string" ? column._name : column._name.name;
+    return options.nameEscape + name + options.nameEscape;
+  }
+  function preprocessConditions(conditions) {
+    conditions.forEach((condition) => {
+      if (conditions.length > 1 && condition._sibling) {
+        condition._parenthesis = true;
+      }
+      preprocessParams(condition);
+    });
+  }
+  function preprocessParams(condition) {
+    if (condition._sibling) {
+      preprocessParams(condition._sibling);
     }
-    function preprocessConditions(conditions) {
-        conditions.forEach(condition => {
-            if (conditions.length > 1 && condition._sibling) {
-                condition._parenthesis = true;
-            }
-            preprocessParams(condition);
-        });
+    if (!condition._sibling && !condition._child) {
+      condition.__param = getConditionParam(condition);
     }
-    // this is only needed, so that the $1, $2... numbering is not reversed
-    function preprocessParams(condition) {
-        if (condition._sibling) {
-            preprocessParams(condition._sibling);
-        }
-        if (!condition._sibling && !condition._child) {
-            condition.__param = getConditionParam(condition);
-        }
-        if (condition._child) {
-            preprocessParams(condition._child);
-        }
+    if (condition._child) {
+      preprocessParams(condition._child);
     }
-    function convertCondition(condition, root = false) {
-        if (!condition._sibling && !condition._child) {
-            return convertColumnCondition(condition, condition.__param);
-        }
-        let s = '';
-        if (condition._child) {
-            s += convertCondition(condition._child);
-        }
-        if (condition._sibling) {
-            s = convertCondition(condition._sibling, root) + ' ' + condition._chainType.toUpperCase() + ' ' + s;
-        }
-        if (condition._parenthesis || ((!root || condition._negation) && condition._child)) {
-            s = '( ' + s + ' )';
-        }
-        if (condition._negation) {
-            s = 'NOT ' + s;
-        }
-        return s;
+  }
+  function convertCondition(condition, root = false) {
+    if (!condition._sibling && !condition._child) {
+      return convertColumnCondition(condition, condition.__param);
     }
-    function convertColumnCondition(condition, param) {
-        let s = convertColumn(condition._column);
-        s += getConditionString(condition, param);
-        return s;
+    let s = "";
+    if (condition._child) {
+      s += convertCondition(condition._child);
     }
-    function getConditionString(condition, param) {
-        switch (condition._type) {
-            case 'eq': return ' = ' + param;
-            case 'ne': return ' <> ' + param;
-            case 'lt': return ' < ' + param;
-            case 'gt': return ' > ' + param;
-            case 'lte': return ' <= ' + param;
-            case 'gte': return ' >= ' + param;
-            case 'is-null': return ' IS NULL';
-            case 'is-not-null': return ' IS NOT NULL';
-            case 'like': return ' LIKE ' + param;
-            case 'not-like': return ' NOT LIKE ' + param;
-            case 'in': return ' IN (' + param + ')';
-            case 'not-in': return ' NOT IN (' + param + ')';
-            case 'between': return ' BETWEEN ' + param;
-            case 'not-between': return ' NOT BETWEEN ' + param;
-            default: return '';
-        }
+    if (condition._sibling) {
+      s = convertCondition(condition._sibling, root) + " " + condition._chainType.toUpperCase() + " " + s;
     }
-    function getConditionParam(condition) {
-        let param = '';
-        if (condition._otherColumn) {
-            param = convertColumn(condition._otherColumn);
-        }
-        else {
-            let _convertParam = (param) => convertParam(condition._column, param);
-            if (condition._type === 'in' || condition._type === 'not-in') {
-                param = condition._values.map((value) => _convertParam(value)).join(', ');
-            }
-            else if (condition._type === 'between' || condition._type === 'not-between') {
-                param = _convertParam(condition._values[0]) + ' AND ' + _convertParam(condition._values[1]);
-            }
-            else if (condition._type !== 'is-null' && condition._type !== 'is-not-null') {
-                param = _convertParam(condition._values[0]);
-            }
-        }
-        return param;
+    if (condition._parenthesis || (!root || condition._negation) && condition._child) {
+      s = "( " + s + " )";
     }
-    function convertParam(column, param) {
-        if (param == null)
-            return 'NULL';
-        return paramConverter(getTypedParam(column._type, param));
+    if (condition._negation) {
+      s = "NOT " + s;
     }
-    function getTypedParam(type, param) {
-        if (type === 'number')
-            return (0, type_converter_1.number)(param);
-        else if (type === 'boolean')
-            return (0, type_converter_1.boolean)(param);
-        else if (type === 'date')
-            return (0, type_converter_1.date)(param);
-        else if (type === 'string')
-            return (0, type_converter_1.string)(param);
-        return param;
+    return s;
+  }
+  function convertColumnCondition(condition, param) {
+    let s = convertColumn(condition._column);
+    s += getConditionString(condition, param);
+    return s;
+  }
+  function getConditionString(condition, param) {
+    switch (condition._type) {
+      case "eq":
+        return " = " + param;
+      case "ne":
+        return " <> " + param;
+      case "lt":
+        return " < " + param;
+      case "gt":
+        return " > " + param;
+      case "lte":
+        return " <= " + param;
+      case "gte":
+        return " >= " + param;
+      case "is-null":
+        return " IS NULL";
+      case "is-not-null":
+        return " IS NOT NULL";
+      case "like":
+        return " LIKE " + param;
+      case "not-like":
+        return " NOT LIKE " + param;
+      case "in":
+        return " IN (" + param + ")";
+      case "not-in":
+        return " NOT IN (" + param + ")";
+      case "between":
+        return " BETWEEN " + param;
+      case "not-between":
+        return " NOT BETWEEN " + param;
+      default:
+        return "";
     }
+  }
+  function getConditionParam(condition) {
+    let param = "";
+    if (condition._otherColumn) {
+      param = convertColumn(condition._otherColumn);
+    } else {
+      let _convertParam = (param2) => convertParam(condition._column, param2);
+      if (condition._type === "in" || condition._type === "not-in") {
+        param = condition._values.map((value) => _convertParam(value)).join(", ");
+      } else if (condition._type === "between" || condition._type === "not-between") {
+        param = _convertParam(condition._values[0]) + " AND " + _convertParam(condition._values[1]);
+      } else if (condition._type !== "is-null" && condition._type !== "is-not-null") {
+        param = _convertParam(condition._values[0]);
+      }
+    }
+    return param;
+  }
+  function convertParam(column, param) {
+    if (param == null) return "NULL";
+    return paramConverter(getTypedParam(column._type, param));
+  }
+  function getTypedParam(type, param) {
+    if (type === "number") return number(param);
+    else if (type === "boolean") return boolean(param);
+    else if (type === "date") return date(param);
+    else if (type === "string") return string(param);
+    return param;
+  }
 }
-//# sourceMappingURL=query-converter.js.map
+export {
+  createQueryConverter
+};