@magda/org-tree 1.2.1 → 2.0.0-alpha.1

package/bin/org-tree/NestedSetModelQueryer.js

@@ -92,7 +92,7 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 9);
+/******/ 	return __webpack_require__(__webpack_require__.s = 13);
 /******/ })
 /************************************************************************/
 /******/ ([
@@ -102,977 +102,509 @@ return /******/ (function(modules) { // webpackBootstrap
 /* 3 */,
 /* 4 */,
 /* 5 */,
-/* 6 */,
-/* 7 */,
-/* 8 */,
-/* 9 */
-/***/ (function(module, exports, __webpack_require__) {
+/* 6 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-
-var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
-  function adopt(value) {return value instanceof P ? value : new P(function (resolve) {resolve(value);});}
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {try {step(generator.next(value));} catch (e) {reject(e);}}
-    function rejected(value) {try {step(generator["throw"](value));} catch (e) {reject(e);}}
-    function step(result) {result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);}
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var __importDefault = this && this.__importDefault || function (mod) {
-  return mod && mod.__esModule ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeNotFoundError = void 0;
-const lodash_1 = __importDefault(__webpack_require__(10));
-const tsmonad_1 = __webpack_require__(12);
-const textTree = __webpack_require__(13);
-class NodeNotFoundError extends Error {}
-
-exports.NodeNotFoundError = NodeNotFoundError;
-function isNonEmptyArray(v) {
-  if (!v || !lodash_1.default.isArray(v) || !v.length)
-  return false;
-  return true;
-}
-const INVALID_CHAR_REGEX = /[^a-z_\d]/i;
-function isValidSqlIdentifier(id) {
-  if (INVALID_CHAR_REGEX.test(id))
-  return false;
-  return true;
-}
-class NestedSetModelQueryer {
-  /**
-                              * Creates an instance of NestedSetModelQueryer.
-                              * @param {pg.Pool} dbPool
-                              * @param {string} tableName
-                              * @param {string[]} [defaultSelectFieldList=null] default select fields; If null, all fields (i.e. `SELECT "id", "name"`) will be returned
-                              * @memberof NestedSetModelQueryer
-                              */
-  constructor(dbPool, tableName, defaultSelectFieldList = null, defaultInsertFieldList = null) {
-    /**
-                                                                                                 * default select fields if [], all fields (i.e. `SELECT "id", "name"`) will be returned
-                                                                                                 *
-                                                                                                 * @type {string[]}
-                                                                                                 * @memberof NestedSetModelQueryer
-                                                                                                 */
-    this.defaultSelectFieldList = ["id", "name"];
-    /**
-                                                   * Default field list that will be used when insert nodes into tree.
-                                                   * By default, only `name` field will be saved to database
-                                                   * e.g. If your tree nodes have three properties (besides `id`, `left`, `right` --- they auto generated):
-                                                   * - name
-                                                   * - description
-                                                   * - fullName
-                                                   *
-                                                   * Then you should set `defaultInsertFieldList` to ["name", "description", "fullName"]
-                                                   *
-                                                   * @type {string[]}
-                                                   * @memberof NestedSetModelQueryer
-                                                   */
-    this.defaultInsertFieldList = ["name"];
-    if (!dbPool)
-    throw new Error("dbPool cannot be empty!");
-    if (!tableName)
-    throw new Error("tableName cannot be empty!");
-    if (!isValidSqlIdentifier(tableName)) {
-      throw new Error(`tableName: ${tableName} contains invalid characters!`);
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SQLSyntax", function() { return SQLSyntax; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return SQLSyntax; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "escapeIdentifier", function() { return escapeIdentifier; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getTableColumnName", function() { return getTableColumnName; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqls", function() { return sqls; });
+/**
+ * An class represents a SQL query piece / fragment.
+ * The provided `sqls` tagged template literals will output an instance of SQLSyntax class.
+ * All properties of SQLSyntax are readonly. Thus is immutable.
+ * An instance of SQLSyntax class will record
+ *
+ * @class SQLSyntax
+ */
+class SQLSyntax {
+    constructor(isEmpty, rawSqlParts, rawValues, sqlParts, values) {
+        this.values = [];
+        this.sqlParts = [];
+        this.isEmpty = isEmpty ? true : false;
+        if (this.isEmpty) {
+            this.isEmpty = true;
+            return;
+        }
+        if (!(rawSqlParts === null || rawSqlParts === void 0 ? void 0 : rawSqlParts.length) && !(sqlParts === null || sqlParts === void 0 ? void 0 : sqlParts.length)) {
+            throw new Error("SQLSyntax: `rawSqlParts` & `sqlParts` can't be both empty for a non-empty SQLSyntax.");
+        }
+        if (!(rawSqlParts === null || rawSqlParts === void 0 ? void 0 : rawSqlParts.length)) {
+            // allow to set this.sqlParts & this.values directly.
+            // an interface for SQLSyntax.createUnsafely
+            this.sqlParts.push(...sqlParts);
+            if (values === null || values === void 0 ? void 0 : values.length) {
+                this.values.push(...values);
+            }
+            return;
+        }
+        this.rawSqlParts = rawSqlParts;
+        this.rawValues = rawValues;
+        // in case it was called with empty value (e.g. undefined ) `rawValues` parameter
+        rawValues = (rawValues === null || rawValues === void 0 ? void 0 : rawValues.length) ? rawValues : [];
+        if (rawSqlParts.length !== rawValues.length + 1) {
+            throw new Error("SQLSyntax: `rawSqlParts.length` should be equal to `rawValues.length` + 1.");
+        }
+        // if (rawSqlParts.length === 1) {
+        //     this.sqlParts.push(rawSqlParts[0]);
+        //     return;
+        // }
+        rawSqlParts.forEach((part, idx) => {
+            if (idx === 0) {
+                this.sqlParts.push(part);
+            }
+            else {
+                const previousValue = rawValues === null || rawValues === void 0 ? void 0 : rawValues[idx - 1];
+                if (previousValue instanceof SQLSyntax) {
+                    this.sqlParts[this.sqlParts.length - 1] += part;
+                }
+                else {
+                    this.sqlParts.push(part);
+                }
+            }
+            if (idx < rawValues.length) {
+                const currentVal = rawValues[idx];
+                if (currentVal instanceof SQLSyntax) {
+                    if (!currentVal.isEmpty) {
+                        this.sqlParts[this.sqlParts.length - 1] +=
+                            currentVal.sqlParts[0];
+                        this.values.push(...currentVal.values);
+                        this.sqlParts.push(...currentVal.sqlParts.slice(1));
+                    }
+                }
+                else {
+                    this.values.push(currentVal);
+                }
+            }
+        });
     }
-    this.pool = dbPool;
-    this.tableName = tableName;
-    if (defaultSelectFieldList) {
-      if (!lodash_1.default.isArray(defaultSelectFieldList))
-      throw new Error("defaultSelectFieldList should be an array");
-      this.defaultSelectFieldList = defaultSelectFieldList;
+    toQuery() {
+        let query;
+        if (SQLSyntax.customToQueryFunc) {
+            query = SQLSyntax.customToQueryFunc(this);
+        }
+        else {
+            query = SQLSyntax.defaultToQueryFunc(this);
+        }
+        if (SQLSyntax.isDebugMode) {
+            const [sqlQuery, params] = query;
+            console.log("SQL Query: ", sqlQuery);
+            console.log("SQL Query params: ", params);
+        }
+        return query;
     }
-    if (defaultSelectFieldList) {
-      if (!lodash_1.default.isArray(defaultSelectFieldList))
-      throw new Error("defaultSelectFieldList should be an array");
-      this.defaultSelectFieldList = defaultSelectFieldList;
+    static defaultToQueryFunc(sql) {
+        if (sql.isEmpty) {
+            return ["", []];
+        }
+        const finalParts = [];
+        sql.values.forEach((value, idx) => {
+            finalParts.push(sql.sqlParts[idx], `$${idx + 1}`);
+        });
+        if (sql.sqlParts.length > sql.values.length) {
+            finalParts.push(...sql.sqlParts.slice(sql.values.length, sql.sqlParts.length));
+        }
+        return [finalParts.join(""), sql.values];
     }
-    if (defaultInsertFieldList) {
-      if (!lodash_1.default.isArray(defaultInsertFieldList))
-      throw new Error("defaultInsertFieldList should be an array");
-      this.defaultInsertFieldList = defaultInsertFieldList;
+    append(syntax) {
+        return SQLSyntax.sqls `${this} ${syntax}`;
     }
-  }
-  selectFields(tableAliasOrName = "", fields = null) {
-    const fieldList = isNonEmptyArray(fields) ?
-    fields :
-    this.defaultSelectFieldList;
-    if (!isNonEmptyArray(fieldList)) {
-      return "*";
+    groupBy(...columns) {
+        columns = SQLSyntax.filterEmpty(columns);
+        if (!(columns === null || columns === void 0 ? void 0 : columns.length)) {
+            return this;
+        }
+        else {
+            return SQLSyntax.sqls `${this} GROUP BY ${SQLSyntax.csv(...columns)}`;
+        }
     }
-    if (!isValidSqlIdentifier(tableAliasOrName)) {
-      throw new Error(`'tableAliasOrName' ${tableAliasOrName} contains invalid characters.`);
+    having(condition) {
+        return SQLSyntax.sqls `${this} HAVING ${condition}`;
     }
-    // --- do not double quote `tableAliasOrName`
-    // --- or you will get missing FROM-clause entry for table error
-    return fieldList.
-    map(f => {
-      if (!isValidSqlIdentifier(f)) {
-        throw new Error(`Field name ${f} contains invalid characters.`);
-      }
-      return tableAliasOrName === "" ?
-      `"${f}"` :
-      `${tableAliasOrName}."${f}"`;
-    }).
-    join(", ");
-  }
-  /**
-     * Get nodes by name
-     * You hardly need this one --- only for write test case (you can get a id from name)
-     *
-     * @param {string} name
-     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
-     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
-     * @returns {Promise<NodeRecord[]>}
-     * @memberof NestedSetModelQueryer
-     */
-  getNodes(nodesQuery = {}, fields = null, client = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const getParamPlaceholder = (() => {
-        let currentPlaceholder = 1;
-        return () => currentPlaceholder++;
-      })();
-      const clauses = [
-      nodesQuery.name && {
-        sql: `"name" = $${getParamPlaceholder()}`,
-        values: [nodesQuery.name] },
-
-      nodesQuery.leafNodesOnly && {
-        sql: `"left" = ( "right" - 1 )` }].
-
-      filter(x => !!x);
-      const whereClause = clauses.length > 0 ?
-      `WHERE ${clauses.map(({ sql }) => sql).join(" AND ")}` :
-      "";
-      const query = `SELECT ${this.selectFields("", fields)} FROM "${this.tableName}" ${whereClause}`;
-      const result = yield (client ? client : this.pool).query(query, lodash_1.default.flatMap(clauses, ({ values }) => values || []));
-      if (!result || !result.rows || !result.rows.length)
-      return [];
-      return result.rows;
-    });
-  }
-  /**
-     *
-     * Get a node by its id
-     * @param {string} id
-     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
-     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
-     * @returns {Promise<NodeRecord>}
-     * @memberof NestedSetModelQueryer
-     */
-  getNodeById(id, fields = null, client = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const result = yield (client ?
-      client :
-      this.pool).query(`SELECT ${this.selectFields("", fields)} FROM "${this.tableName}" WHERE "id" = $1`, [id]);
-      if (!result || !result.rows || !result.rows.length)
-      return tsmonad_1.Maybe.nothing();
-      return tsmonad_1.Maybe.just(result.rows[0]);
-    });
-  }
-  /**
-     * Get the root node of the tree
-     * Return null if empty tree
-     *
-     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
-     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
-     * @returns {Promise<NodeRecord>}
-     * @memberof NestedSetModelQueryer
-     */
-  getRootNode(fields = null, client = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const result = yield (client ? client : this.pool).query(`SELECT ${this.selectFields("", fields)} FROM "${this.tableName}" WHERE "left" = 1`);
-      if (!result || !result.rows || !result.rows.length)
-      return tsmonad_1.Maybe.nothing();
-      return tsmonad_1.Maybe.just(result.rows[0]);
-    });
-  }
-  /**
-     * Get All children of a given node
-     * (including immediate children and children of immediate children etc.)
-     * If the node has no child (i.e. a leaf node), an empty array will be returned
-     *
-     * @param {string} parentNodeId
-     * @param {boolean} [includeMyself=false]
-     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
-     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
-     * @returns {Promise<NodeRecord[]>}
-     * @memberof NestedSetModelQueryer
-     */
-  getAllChildren(parentNodeId, includeMyself = false, fields = null, client = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield (client ? client : this.pool).query(`SELECT ${this.selectFields("Children", fields)} 
-             FROM "${tbl}" AS Parents,  "${tbl}" AS Children
-             WHERE Children."left" ${includeMyself ? ">=" : ">"} Parents."left" AND Children."left" ${includeMyself ? "<=" : "<"} Parents."right" AND Parents."id" = $1`, [parentNodeId]);
-      if (!result || !result.rows || !result.rows.length)
-      return [];
-      return result.rows;
-    });
-  }
-  /**
-     * Get All parents of a given node
-     * (including immediate parent and parents of immediate parent etc.)
-     * If the node has no parent (i.e. a root node), an empty array will be returned (unless `includeMyself` = true)
+    orderBy(...columns) {
+        columns = SQLSyntax.filterEmpty(columns);
+        if (!(columns === null || columns === void 0 ? void 0 : columns.length)) {
+            return this;
+        }
+        else {
+            return SQLSyntax.sqls `${this} ORDER BY ${SQLSyntax.csv(...columns)}`;
+        }
+    }
+    asc() {
+        return SQLSyntax.sqls `${this} ASC`;
+    }
+    desc() {
+        return SQLSyntax.sqls `${this} DESC`;
+    }
+    limit(n) {
+        return SQLSyntax.sqls `${this} LIMIT ${n}`;
+    }
+    offset(n) {
+        return SQLSyntax.sqls `${this} OFFSET ${n}`;
+    }
+    where(conditions) {
+        if (!conditions || conditions.isEmpty) {
+            return this;
+        }
+        return SQLSyntax.sqls `${this} WHERE ${conditions}`;
+    }
+    and(condition) {
+        if (!condition || condition.isEmpty) {
+            return this;
+        }
+        return SQLSyntax.sqls `${this} AND ${condition}`;
+    }
+    or(condition) {
+        if (!condition || condition.isEmpty) {
+            return this;
+        }
+        return SQLSyntax.sqls `${this} OR ${condition}`;
+    }
+    roundBracket() {
+        if (this.isEmpty) {
+            return this;
+        }
+        return SQLSyntax.sqls `(${this})`;
+    }
+    eq(value) {
+        if (typeof value === "undefined" || value == null) {
+            return SQLSyntax.sqls `${this} IS NULL`;
+        }
+        else {
+            return SQLSyntax.sqls `${this} = ${value}`;
+        }
+    }
+    gt(value) {
+        return SQLSyntax.sqls `${this} > ${value}`;
+    }
+    ge(value) {
+        return SQLSyntax.sqls `${this} >= ${value}`;
+    }
+    lt(value) {
+        return SQLSyntax.sqls `${this} < ${value}`;
+    }
+    le(value) {
+        return SQLSyntax.sqls `${this} <= ${value}`;
+    }
+    isNull() {
+        return SQLSyntax.sqls `${this} IS NULL`;
+    }
+    isNotNull() {
+        return SQLSyntax.sqls `${this} IS NOT NULL`;
+    }
+    in(valueOrSubQuery) {
+        if (valueOrSubQuery instanceof SQLSyntax) {
+            if (valueOrSubQuery.isEmpty) {
+                throw new Error("empty SQLSyntax is not allowed for `in`.");
+            }
+            else {
+                return SQLSyntax.sqls `${this} IN (${valueOrSubQuery})`;
+            }
+        }
+        else {
+            if (!(valueOrSubQuery === null || valueOrSubQuery === void 0 ? void 0 : valueOrSubQuery.length)) {
+                throw new Error("empty value list is not allowed for `in`.");
+            }
+            else {
+                return SQLSyntax.sqls `${this} IN ${SQLSyntax.csv(...valueOrSubQuery.map((v) => SQLSyntax.sqls `${v}`)).roundBracket()}`;
+            }
+        }
+    }
+    notIn(valueOrSubQuery) {
+        if (valueOrSubQuery instanceof SQLSyntax) {
+            if (valueOrSubQuery.isEmpty) {
+                throw new Error("empty SQLSyntax is not allowed for `notIn`.");
+            }
+            else {
+                return SQLSyntax.sqls `${this} NOT IN (${valueOrSubQuery})`;
+            }
+        }
+        else {
+            if (!(valueOrSubQuery === null || valueOrSubQuery === void 0 ? void 0 : valueOrSubQuery.length)) {
+                throw new Error("empty SQLSyntax is not allowed for `notIn`.");
+            }
+            else {
+                return SQLSyntax.sqls `${this} NOT IN ${SQLSyntax.csv(...valueOrSubQuery.map((v) => SQLSyntax.sqls `${v}`)).roundBracket()}`;
+            }
+        }
+    }
+    like(value) {
+        return SQLSyntax.sqls `${this} LIKE ${value}`;
+    }
+    notLike(value) {
+        return SQLSyntax.sqls `${this} NOT LIKE ${value}`;
+    }
+    exists(part) {
+        if (!part || !part.isEmpty) {
+            return SQLSyntax.empty;
+        }
+        return SQLSyntax.sqls `${this} EXISTS ${part}`;
+    }
+    notExists(part) {
+        if (!part || !part.isEmpty) {
+            return SQLSyntax.empty;
+        }
+        return SQLSyntax.sqls `${this} NOT EXISTS ${part}`;
+    }
+    static sqls(sqlParts, ...values) {
+        if (sqlParts.length === 1 && sqlParts[0] === "") {
+            return SQLSyntax.empty;
+        }
+        return new SQLSyntax(false, sqlParts, values);
+    }
+    /**
+     * Allow create an instance of SQLSyntax from a string variable `sqlStr`.
+     * The content of the string variable `sqlStr` will become the SQL query string without any escaping.
+     * You might need this method to create indentifier (e.g. tbale or column names) as SQLSyntax.
+     * Make sure you process the string input well to avoid SQL injection vulnerability.
      *
-     * @param {string} childNodeId
-     * @param {boolean} [includeMyself=false]
-     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
-     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
-     * @returns {Promise<NodeRecord[]>}
-     * @memberof NestedSetModelQueryer
+     * @static
+     * @param {string} sqlStr
+     * @return {SQLSyntax}
+     * @memberof SQLSyntax
      */
-  getAllParents(childNodeId, includeMyself = false, fields = null, client = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield (client ? client : this.pool).query(`SELECT ${this.selectFields("Parents", fields)} 
-             FROM "${tbl}" AS Parents,  "${tbl}" AS Children
-             WHERE Children."left" ${includeMyself ? ">=" : ">"} Parents."left" AND Children."left" ${includeMyself ? "<=" : "<"} Parents."right" AND Children."id" = $1`, [childNodeId]);
-      if (!result || !result.rows || !result.rows.length)
-      return [];
-      return result.rows;
-    });
-  }
-  /**
-     * Get Immediate Children of a Node
-     * If the node has no child (i.e. a leaf node), an empty array will be returned
-     *
-     * @param {string} parentNodeId
-     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
-     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
-     * @returns {Promise<NodeRecord[]>}
-     * @memberof NestedSetModelQueryer
-     */
-  getImmediateChildren(parentNodeId, fields = null, client = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield (client ? client : this.pool).query(`SELECT ${this.selectFields("Children", fields)} 
-            FROM "${tbl}" AS Parents, "${tbl}" AS Children
-            WHERE Children."left" BETWEEN Parents."left" AND Parents."right" 
-            AND Parents."left" = (
-                SELECT MAX(S."left") FROM "${tbl}" AS S
-                WHERE S."left" < Children."left" AND S."right" > Children."right"
-            ) 
-            AND Parents."id" = $1
-            ORDER BY Children."left" ASC`, [parentNodeId]);
-      if (!result || !result.rows || !result.rows.length)
-      return [];
-      return result.rows;
-    });
-  }
-  /**
-     * Get Immediate Parent of a Node
-     * If the node has no parent (i.e. a root node), null will be returned
-     *
-     * @param {string} childNodeId
-     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
-     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
-     * @returns {Promise<NodeRecord>}
-     * @memberof NestedSetModelQueryer
-     */
-  getImmediateParent(childNodeId, fields = null, client = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield (client ? client : this.pool).query(`SELECT ${this.selectFields("Parents", fields)} 
-            FROM "${tbl}" AS Parents, "${tbl}" AS Children
-            WHERE Children.left BETWEEN Parents.left AND Parents.right 
-            AND Parents.left = (
-                SELECT MAX(S.left) FROM "${tbl}" AS S
-                WHERE S.left < Children.left AND S.right > Children.right
-            ) 
-            AND Children.id = $1`, [childNodeId]);
-      if (!result || !result.rows || !result.rows.length)
-      return tsmonad_1.Maybe.nothing();
-      return tsmonad_1.Maybe.just(result.rows[0]);
-    });
-  }
-  /**
-     * Get all nodes at level n from top
-     * e.g. get all nodes at level 3:
-     * this.getAllNodesAtLevel(3)
-     * Root node is at level 1
-     *
-     * @param {number} level
-     * @returns {Promise<NodeRecord[]>}
-     * @memberof NestedSetModelQueryer
-     */
-  getAllNodesAtLevel(level) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield this.pool.query(`SELECT ${this.selectFields("t2")}
-            FROM "${tbl}" AS t1, "${tbl}" AS t2
-            WHERE t2.left BETWEEN t1.left AND t1.right 
-            GROUP BY t2.id 
-            HAVING COUNT(t1.id) = $1`, [level]);
-      if (!result || !result.rows || !result.rows.length)
-      return [];
-      return result.rows;
-    });
-  }
-  /**
-     * Get level no. of a given node
-     * Starts from 1. i.e. The root node is 1
-     *
-     * @param {string} nodeId
-     * @returns {Promise<number>}
-     * @throws NodeNotFoundError If the node can't be found in the tree
-     * @memberof NestedSetModelQueryer
-     */
-  getLevelOfNode(nodeId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield this.pool.query(`SELECT COUNT(Parents.id) AS level 
-            FROM "${tbl}" AS Parents, "${tbl}" AS Children
-            WHERE Children.left BETWEEN Parents.left AND Parents.right AND Children.id = $1`, [nodeId]);
-      if (!result || !result.rows || !result.rows.length)
-      throw new NodeNotFoundError();
-      const level = parseInt(result.rows[0]["level"]);
-      if (!lodash_1.default.isNumber(level) || lodash_1.default.isNaN(level) || level < 1)
-      throw new Error(`Could find a valid level for node ${nodeId}: ${level}`);
-      return level;
-    });
-  }
-  /**
-     * Get total height (no. of the levels) of the tree
-     * Starts with 1 level.
-     *
-     * @returns {Promise<number>}
-     * @throws NodeNotFoundError If the root node can't be found in the tree
-     * @memberof NestedSetModelQueryer
-     */
-  getTreeHeight() {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield this.pool.query(`SELECT MAX(level) AS height 
-             FROM(
-                SELECT COUNT(t1.id)
-                FROM "${tbl}" AS t1, "${tbl}" AS t2
-                WHERE t2.left BETWEEN t1.left AND t1.right 
-                GROUP BY t2.id 
-             ) AS L(level)`);
-      if (!result || !result.rows || !result.rows.length)
-      throw new NodeNotFoundError();
-      const height = parseInt(result.rows[0]["height"]);
-      if (!lodash_1.default.isNumber(height) || lodash_1.default.isNaN(height) || height < 0)
-      throw new Error(`Invalid height for tree: ${height}`);
-      return height;
-    });
-  }
-  /**
-     * Get left most immediate child of a node
-     *
-     * @param {string} parentNodeId
-     * @returns {Promise<Maybe<NodeRecord>>}
-     * @memberof NestedSetModelQueryer
-     */
-  getLeftMostImmediateChild(parentNodeId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield this.pool.query(`SELECT ${this.selectFields("Children")}
-            FROM "${tbl}" AS Parents, "${tbl}" AS Children 
-            WHERE Children.left = Parents.left + 1 AND Parents.id = $1`, [parentNodeId]);
-      if (!result || !result.rows || !result.rows.length)
-      return tsmonad_1.Maybe.nothing();
-      return tsmonad_1.Maybe.just(result.rows[0]);
-    });
-  }
-  /**
-     * Get right most immediate child of a node
-     *
-     * @param {string} parentNodeId
-     * @returns {Promise<Maybe<NodeRecord>>}
-     * @memberof NestedSetModelQueryer
-     */
-  getRightMostImmediateChild(parentNodeId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield this.pool.query(`SELECT ${this.selectFields("Children")}
-            FROM "${tbl}" AS Parents, "${tbl}" AS Children 
-            WHERE Children.right = Parents.right - 1 AND Parents.id = $1`, [parentNodeId]);
-      if (!result || !result.rows || !result.rows.length)
-      return tsmonad_1.Maybe.nothing();
-      return tsmonad_1.Maybe.just(result.rows[0]);
-    });
-  }
-  /**
-     * Get all nodes on the top to down path between the `higherNode` to the `lowerNode`
-     * Sort from higher level nodes to lower level node
-     * If a path doesn't exist, null will be returned
-     * If you pass a lower node to the `higherNodeId` and a higher node to `lowerNodeId`, null will be returned
-     *
-     * @param {string} higherNodeId
-     * @param {string} lowerNodeId
-     * @returns {Promise<Maybe<NodeRecord[]>}
-     * @memberof NestedSetModelQueryer
-     */
-  getTopDownPathBetween(higherNodeId, lowerNodeId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield this.pool.query(`SELECT ${this.selectFields("t2")}
-            FROM "${tbl}" AS t1, "${tbl}" AS t2, "${tbl}" AS t3 
-            WHERE t1.id = $1 AND t3.id = $2
-            AND t2.left BETWEEN t1.left AND t1.right 
-            AND t3.left BETWEEN t2.left AND t2.right
-            ORDER BY (t2.right-t2.left) DESC`, [higherNodeId, lowerNodeId]);
-      if (!result || !result.rows || !result.rows.length)
-      return tsmonad_1.Maybe.nothing();
-      return tsmonad_1.Maybe.just(result.rows);
-    });
-  }
-  /**
-     * Compare the relative position of the two nodes
-     * If node1 is superior to node2, return "ancestor"
-     * if node1 is the subordinate of node2, return "descendant"
-     * If node1 = node2 return "equal"
-     * If there is no path can be found between Node1 and Node2 return "unrelated"
-     *
-     * @param {string} node1Id
-     * @param {string} node2Id
-     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
-     * @returns {Promise<CompareNodeResult>}
-     * @memberof NestedSetModelQueryer
-     */
-  compareNodes(node1Id, node2Id, client = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const result = yield (client ? client : this.pool).query(`SELECT (
-                CASE
-                    WHEN CAST($1 AS varchar) = CAST($2 AS varchar)
-                    THEN 0
-                    WHEN t1.left BETWEEN t2.left AND t2.right 
-                    THEN -1
-                    WHEN t2.left BETWEEN t1.left AND t1.right 
-                    THEN 1
-                    ELSE null 
-                END
-            ) AS "result"
-            FROM "${tbl}" AS t1, "${tbl}" AS t2
-            WHERE t1.id = CAST($1 AS uuid) AND t2.id = CAST($2 AS uuid)`, [node1Id, node2Id]);
-      if (!result || !result.rows || !result.rows.length)
-      return "unrelated";
-      const comparisonResult = result.rows[0]["result"];
-      if (typeof comparisonResult === "number") {
-        switch (comparisonResult) {
-          case 1:
-            return "ancestor";
-          case -1:
-            return "descendant";
-          case 0:
-            return "equal";}
-
-      }
-      return "unrelated";
-    });
-  }
-  getInsertFields(insertFieldList = null) {
-    const fieldList = isNonEmptyArray(insertFieldList) ?
-    insertFieldList :
-    this.defaultInsertFieldList;
-    if (!isNonEmptyArray(fieldList)) {
-      throw new Error("Insert fields must be an non-empty array!");
+    static createUnsafely(sqlStr) {
+        return new SQLSyntax(false, undefined, undefined, [sqlStr]);
     }
-    return fieldList;
-  }
-  getNodesInsertSql(nodes, sqlValues, insertFieldList = null, tableAliasOrName = "") {
-    if (!isNonEmptyArray(nodes)) {
-      throw new Error("`sqlValues` parameter should be an non-empty array!");
+    static filterEmpty(parts) {
+        if (!(parts === null || parts === void 0 ? void 0 : parts.length)) {
+            return [];
+        }
+        return parts.filter((item) => item && !item.isEmpty);
     }
-    if (!lodash_1.default.isArray(sqlValues)) {
-      throw new Error("`sqlValues` parameter should be an array!");
+    static join(parts, delimiter, spaceBeforeDelimier = true) {
+        parts = SQLSyntax.filterEmpty(parts);
+        if (!(parts === null || parts === void 0 ? void 0 : parts.length)) {
+            return SQLSyntax.empty;
+        }
+        const sep = spaceBeforeDelimier
+            ? SQLSyntax.sqls ` ${delimiter}`
+            : delimiter;
+        let result = parts[0];
+        if (parts.length > 1) {
+            for (let i = 1; i < parts.length; i++) {
+                result = SQLSyntax.sqls `${result}${sep}${parts[i]}`;
+            }
+        }
+        return result;
     }
-    if (!isValidSqlIdentifier(tableAliasOrName)) {
-      throw new Error(`tableAliasOrName: ${tableAliasOrName} contains invalid characters!`);
+    static csv(...parts) {
+        parts = SQLSyntax.filterEmpty(parts);
+        if (!(parts === null || parts === void 0 ? void 0 : parts.length)) {
+            return SQLSyntax.empty;
+        }
+        return SQLSyntax.join(parts, SQLSyntax.sqls `,`, false);
     }
-    const tbl = this.tableName;
-    const fieldList = this.getInsertFields(insertFieldList);
-    const columnsList = fieldList.
-    map(f => {
-      if (!isValidSqlIdentifier(f)) {
-        throw new Error(`column name: ${f} contains invalid characters!`);
-      }
-      return tableAliasOrName == "" ?
-      `"${f}"` :
-      `${tableAliasOrName}."${f}"`;
-    }).
-    join(", ");
-    const valuesList = nodes.
-    map(node => "(" +
-    fieldList.
-    map(f => {
-      sqlValues.push(node[f]);
-      return `$${sqlValues.length}`;
-    }).
-    join(", ") +
-    ")").
-    join(", ");
-    return `INSERT INTO "${tbl}" (${columnsList}) VALUES ${valuesList}`;
-  }
-  /**
-     * Create the root node of the tree.
-     * If a root node already exists, an error will be thrown.
-     *
-     * @param {NodeRecord} node
-     * @param {pg.Client} [existingClient=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
-     * @returns {Promise<string>} newly created node ID
-     * @memberof NestedSetModelQueryer
-     */
-  createRootNode(node, existingClient = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const tbl = this.tableName;
-      const client = existingClient ?
-      existingClient :
-      yield this.pool.connect();
-      const fields = Object.keys(node);
-      if (!fields.length) {
-        throw new Error("`node` parameter cannot be an empty object with no key.");
-      }
-      let nodeId;
-      try {
-        yield client.query("BEGIN");
-        let result = yield client.query(`SELECT "id" FROM "${tbl}" WHERE "left" = 1 LIMIT 1`);
-        if (result && isNonEmptyArray(result.rows)) {
-          throw new Error(`A root node with id: ${result.rows[0]["id"]} already exists`);
+    static hasAndOr(s) {
+        let [sqlStr] = s.toQuery();
+        sqlStr = sqlStr.toLowerCase();
+        if (sqlStr.indexOf(" and ") == -1 && sqlStr.indexOf(" or ") == -1) {
+            return false;
         }
-        const countResult = yield client.query(`SELECT COUNT("id") AS "num" FROM "${tbl}" WHERE "left" != 1`);
-        let countNum = countResult && countResult.rows && countResult.rows.length ?
-        parseInt(countResult.rows[0].num) :
-        0;
-        countNum = isNaN(countNum) ? 0 : countNum;
-        const right = countNum ? (countNum + 1) * 2 : 2;
-        const sqlValues = [];
-        result = yield client.query(this.getNodesInsertSql([
-        Object.assign(Object.assign({}, node), { left: 1, right })],
-        sqlValues, fields.concat(["left", "right"])) + " RETURNING id", sqlValues);
-        if (!result || !isNonEmptyArray(result.rows)) {
-          throw new Error("Cannot locate create root node ID!");
+        else {
+            return true;
         }
-        yield client.query("COMMIT");
-        nodeId = result.rows[0]["id"];
-      }
-      catch (e) {
-        yield client.query("ROLLBACK");
-        throw e;
-      } finally
-      {
-        if (!existingClient) {
-          client.release();
+    }
+    static joinWithAnd(conditions) {
+        conditions = SQLSyntax.filterEmpty(conditions);
+        if (!(conditions === null || conditions === void 0 ? void 0 : conditions.length)) {
+            return SQLSyntax.empty;
         }
-      }
-      return nodeId;
-    });
-  }
-  getNodeDataWithinTx(client, nodeId, fields) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const node = yield this.getNodeById(nodeId, fields, client);
-      return node.caseOf({
-        just: node => node,
-        nothing: () => {
-          throw new NodeNotFoundError(`Cannot locate tree node record with id: ${nodeId}`);
-        } });
-
-    });
-  }
-  /**
-     * Insert a node to the tree under a parent node
-     *
-     * @param {string} parentNodeId
-     * @param {NodeRecord} node
-     * @returns {Promise<string>}
-     * @throws NodeNotFoundError if parent node not found
-     * @memberof NestedSetModelQueryer
-     */
-  insertNode(parentNodeId, node) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!parentNodeId) {
-        throw new Error("`parentNodeId` cannot be empty!");
-      }
-      const fields = Object.keys(node);
-      if (!fields.length) {
-        throw new Error("`node` parameter cannot be an empty object with no key.");
-      }
-      const tbl = this.tableName;
-      const client = yield this.pool.connect();
-      let nodeId;
-      try {
-        yield client.query("BEGIN");
-        const { right: parentRight } = yield this.getNodeDataWithinTx(client, parentNodeId, ["right"]);
-        yield client.query(`UPDATE "${tbl}" 
-                SET 
-                    "left" = CASE WHEN "left" > $1 THEN "left" + 2 ELSE "left" END,
-                    "right" = CASE WHEN "right" >= $1 THEN "right" + 2 ELSE "right" END
-                WHERE "right" >= $1`, [parentRight]);
-        const sqlValues = [];
-        const result = yield client.query(this.getNodesInsertSql([
-        Object.assign(Object.assign({}, node), { left: parentRight, right: parentRight + 1 })],
-        sqlValues, fields.concat(["left", "right"])) + " RETURNING id", sqlValues);
-        if (!result || !isNonEmptyArray(result.rows)) {
-          throw new Error("Cannot locate created node ID!");
+        return SQLSyntax.join(conditions
+            .filter((s) => s && !s.isEmpty)
+            .map((s) => (SQLSyntax.hasAndOr(s) ? s.roundBracket() : s)), SQLSyntax.sqls ` AND `, false);
+    }
+    static joinWithOr(conditions) {
+        conditions = SQLSyntax.filterEmpty(conditions);
+        if (!(conditions === null || conditions === void 0 ? void 0 : conditions.length)) {
+            return SQLSyntax.empty;
         }
-        yield client.query("COMMIT");
-        nodeId = result.rows[0]["id"];
-      }
-      catch (e) {
-        yield client.query("ROLLBACK");
-        throw e;
-      } finally
-      {
-        client.release();
-      }
-      return nodeId;
-    });
-  }
-  /**
-     * Insert a node to the right of its sibling
-     * If `siblingNodeId` belongs to a root node, an error will be thrown
-     *
-     * @param {string} siblingNodeId
-     * @param {NodeRecord} node
-     * @returns {Promise<string>}
-     * @throws NodeNotFoundError If the node can't be found in the tree
-     * @memberof NestedSetModelQueryer
-     */
-  insertNodeToRightOfSibling(siblingNodeId, node) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!siblingNodeId) {
-        throw new Error("`siblingNodeId` cannot be empty!");
-      }
-      const fields = Object.keys(node);
-      if (!fields.length) {
-        throw new Error("`node` parameter cannot be an empty object with no key.");
-      }
-      const tbl = this.tableName;
-      const client = yield this.pool.connect();
-      let nodeId;
-      try {
-        yield client.query("BEGIN");
-        const { left: siblingLeft, right: siblingRight } = yield this.getNodeDataWithinTx(client, siblingNodeId, [
-        "left",
-        "right"]);
-
-        if (siblingLeft === 1) {
-          throw new Error("Cannot add sibling to the Root node!");
+        return SQLSyntax.join(conditions
+            .filter((s) => s && !s.isEmpty)
+            .map((s) => (SQLSyntax.hasAndOr(s) ? s.roundBracket() : s)), SQLSyntax.sqls ` OR `, false);
+    }
+    static groupBy(...columns) {
+        return SQLSyntax.empty.groupBy(...columns);
+    }
+    static having(condition) {
+        return SQLSyntax.empty.having(condition);
+    }
+    static orderBy(...columns) {
+        return SQLSyntax.empty.orderBy(...columns);
+    }
+    static limit(n) {
+        return SQLSyntax.empty.limit(n);
+    }
+    static offset(n) {
+        return SQLSyntax.empty.offset(n);
+    }
+    static where(condition) {
+        return SQLSyntax.empty.where(condition);
+    }
+    static eq(column, value) {
+        if (typeof value === "undefined" || value == null) {
+            return SQLSyntax.sqls `${column} IS NULL`;
         }
-        yield client.query(`UPDATE "${tbl}" 
-                SET 
-                    "left" = CASE WHEN "left" < $1 THEN "left" ELSE "left" + 2 END,
-                    "right" = CASE WHEN "right" < $1 THEN "right" ELSE "right" + 2 END
-                WHERE "right" > $1`, [siblingRight]);
-        const sqlValues = [];
-        const result = yield client.query(this.getNodesInsertSql([
-        Object.assign(Object.assign({}, node), { left: siblingRight + 1, right: siblingRight + 2 })],
-        sqlValues, fields.concat(["left", "right"])) + " RETURNING id", sqlValues);
-        if (!result || !isNonEmptyArray(result.rows)) {
-          throw new Error("Cannot locate created node ID!");
+        else {
+            return SQLSyntax.sqls `${column} = ${value}`;
         }
-        yield client.query("COMMIT");
-        nodeId = result.rows[0]["id"];
-      }
-      catch (e) {
-        yield client.query("ROLLBACK");
-        throw e;
-      } finally
-      {
-        client.release();
-      }
-      return nodeId;
-    });
-  }
-  /**
-     * Move a subtree (the specified root node and all its subordinates)
-     * to under a new parent.
-     *
-     * If the specifed sub tree root node is a child of the new parent node,
-     * an error will be be thrown
-     *
-     * @param {string} subTreeRootNodeId
-     * @param {string} newParentId
-     * @returns {Promise<void>}
-     * @throws NodeNotFoundError If the node can't be found in the tree
-     * @memberof NestedSetModelQueryer
-     */
-  moveSubTreeTo(subTreeRootNodeId, newParentId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!subTreeRootNodeId) {
-        throw new Error("`subTreeRootNodeId` cannot be empty!");
-      }
-      if (!newParentId) {
-        throw new Error("`newParentId` cannot be empty!");
-      }
-      const tbl = this.tableName;
-      const client = yield this.pool.connect();
-      try {
-        yield client.query("BEGIN");
-        const comparisonResult = yield this.compareNodes(subTreeRootNodeId, newParentId, client);
-        if (comparisonResult === "ancestor") {
-          throw new Error(`Cannot move a higher level node (id: ${subTreeRootNodeId})to its subordinate (id: ${newParentId})`);
+    }
+    static gt(column, value) {
+        return SQLSyntax.sqls `${column} > ${value}`;
+    }
+    static ge(column, value) {
+        return SQLSyntax.sqls `${column} >= ${value}`;
+    }
+    static lt(column, value) {
+        return SQLSyntax.sqls `${column} < ${value}`;
+    }
+    static le(column, value) {
+        return SQLSyntax.sqls `${column} <= ${value}`;
+    }
+    static isNull(column) {
+        return SQLSyntax.sqls `${column} IS NULL`;
+    }
+    static isNotNull(column) {
+        return SQLSyntax.sqls `${column} IS NOT NULL`;
+    }
+    static in(column, valueOrSubQuery) {
+        if (valueOrSubQuery instanceof SQLSyntax) {
+            if (valueOrSubQuery.isEmpty) {
+                return SQLSyntax.sqls `FALSE`;
+            }
+            else {
+                return SQLSyntax.sqls `${column} IN (${valueOrSubQuery})`;
+            }
         }
-        const { left: originRootLeft, right: originRootRight } = yield this.getNodeDataWithinTx(client, subTreeRootNodeId, [
-        "left",
-        "right"]);
-
-        if (originRootLeft === "1") {
-          throw new Error("Cannot move Tree root node as substree.");
+        else {
+            if (!(valueOrSubQuery === null || valueOrSubQuery === void 0 ? void 0 : valueOrSubQuery.length)) {
+                return SQLSyntax.sqls `FALSE`;
+            }
+            else {
+                return SQLSyntax.sqls `${column} IN ${SQLSyntax.csv(...valueOrSubQuery.map((v) => SQLSyntax.sqls `${v}`)).roundBracket()}`;
+            }
         }
-        const { right: newParentRight } = yield this.getNodeDataWithinTx(client, newParentId, ["right"]);
-        yield client.query(`
-            UPDATE "${tbl}" 
-            SET 
-            "left" = "left" + CASE
-                WHEN $3::int4 < $1::int4
-                THEN CASE 
-                    WHEN "left" BETWEEN $1 AND $2
-                    THEN $3 - $1
-                    WHEN "left" BETWEEN $3 AND ($1 - 1)
-                    THEN $2 - $1 + 1
-                    ELSE 0 END
-                WHEN $3::int4 > $2::int4
-                THEN CASE
-                    WHEN "left" BETWEEN $1 AND $2
-                    THEN $3 - $2 - 1
-                    WHEN "left" BETWEEN ($2 + 1) AND ($3 - 1)
-                    THEN $1 - $2 - 1
-                    ELSE 0 END
-                ELSE 0 END,
-            "right" = "right" + CASE
-                WHEN $3::int4 < $1::int4
-                THEN CASE 
-                    WHEN "right" BETWEEN $1 AND $2
-                    THEN $3 - $1
-                    WHEN "right" BETWEEN $3 AND ($1 - 1)
-                    THEN $2 - $1 + 1
-                    ELSE 0 END
-                WHEN $3::int4 > $2::int4
-                THEN CASE
-                    WHEN "right" BETWEEN $1 AND $2
-                    THEN $3 - $2 - 1
-                    WHEN "right" BETWEEN ($2 + 1) AND ($3 - 1)
-                    THEN $1 - $2 - 1
-                    ELSE 0 END
-                ELSE 0 END
-            `, [originRootLeft, originRootRight, newParentRight]);
-        yield client.query("COMMIT");
-      }
-      catch (e) {
-        yield client.query("ROLLBACK");
-        throw e;
-      } finally
-      {
-        client.release();
-      }
-    });
-  }
-  /**
-     * Delete a subtree (and all its dependents)
-     * If you sent in a root node id (and `allowRootNodeId` is true), the whole tree will be removed
-     * When `allowRootNodeId` is false and you passed a root node id, an error will be thrown
-     *
-     * @param {string} subTreeRootNodeId
-     * @param {boolean} [allowRootNodeId=false]
-     * @returns {Promise<void>}
-     * @throws NodeNotFoundError If the node can't be found in the tree
-     * @memberof NestedSetModelQueryer
-     */
-  deleteSubTree(subTreeRootNodeId, allowRootNodeId = false) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!subTreeRootNodeId) {
-        throw new Error("`subTreeRootNodeId` cannot be empty!");
-      }
-      const tbl = this.tableName;
-      const client = yield this.pool.connect();
-      try {
-        yield client.query("BEGIN");
-        const { left: subTreeRootLeft, right: subTreeRootRight } = yield this.getNodeDataWithinTx(client, subTreeRootNodeId, [
-        "left",
-        "right"]);
-
-        if (subTreeRootLeft === 1 && !allowRootNodeId) {
-          throw new Error("Root node id is not allowed!");
-        }
-        // --- delete the sub tree nodes
-        yield client.query(`DELETE FROM "${tbl}" WHERE "left" BETWEEN $1 AND $2`, [subTreeRootLeft, subTreeRootRight]);
-        // --- closing the gap after deletion
-        yield client.query(`
-                UPDATE "${tbl}"
-                SET "left" = CASE
-                        WHEN "left" > $1
-                            THEN "left" - ($2 - $1 + 1)
-                        ELSE "left" END, 
-                    "right" = CASE
-                        WHEN "right" > $1
-                            THEN "right" - ($2 - $1 + 1) 
-                        ELSE "right" END
-                WHERE "left" > $1 OR "right" > $1
-                `, [subTreeRootLeft, subTreeRootRight]);
-        yield client.query("COMMIT");
-      }
-      catch (e) {
-        yield client.query("ROLLBACK");
-        throw e;
-      } finally
-      {
-        client.release();
-      }
-    });
-  }
-  /**
-     * Delete a single node from the tree
-     * Its childrens will become its parent's children
-     * Deleting a root node is not allowed.
-     * You can, however, delete the whole sub tree from root node or update the root node, instead.
-     *
-     * @param {string} nodeId
-     * @returns {Promise<void>}
-     * @throws NodeNotFoundError If the node can't be found in the tree
-     * @memberof NestedSetModelQueryer
-     */
-  deleteNode(nodeId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!nodeId) {
-        throw new Error("`nodeId` cannot be empty!");
-      }
-      const tbl = this.tableName;
-      const client = yield this.pool.connect();
-      try {
-        yield client.query("BEGIN");
-        const { left: subTreeRootLeft, right: subTreeRootRight } = yield this.getNodeDataWithinTx(client, nodeId, [
-        "left",
-        "right"]);
-
-        if (subTreeRootLeft === 1) {
-          throw new Error("Delete a root node is not allowed!");
+    }
+    static notIn(column, valueOrSubQuery) {
+        if (valueOrSubQuery instanceof SQLSyntax) {
+            if (valueOrSubQuery.isEmpty) {
+                return SQLSyntax.sqls `TRUE`;
+            }
+            else {
+                return SQLSyntax.sqls `${column} NOT IN (${valueOrSubQuery})`;
+            }
         }
-        // --- delete the node
-        // --- In nested set model, children are still bind to the deleted node's parent after deletion
-        yield client.query(`DELETE FROM "${tbl}" WHERE "id" = $1`, [
-        nodeId]);
-
-        // --- closing the gap after deletion
-        yield client.query(`
-                UPDATE "${tbl}"
-                SET "left" = CASE
-                        WHEN "left" > $1 AND "right" < $2
-                            THEN "left" - 1
-                        WHEN "left" > $1 AND "right" > $2
-                            THEN "left" - 2
-                        ELSE "left" END, 
-                    "right" = CASE
-                        WHEN "left" > $1 AND "right" < $2
-                            THEN "right" - 1
-                        ELSE ("right" - 2) END
-                WHERE "left" > $1 OR "right" > $1
-                `, [subTreeRootLeft, subTreeRootRight]);
-        yield client.query("COMMIT");
-      }
-      catch (e) {
-        yield client.query("ROLLBACK");
-        throw e;
-      } finally
-      {
-        client.release();
-      }
-    });
-  }
-  /**
-     * Update node data of the node specified by the nodeId
-     * The followings fields will be ignored (as they should be generated by program):
-     * - `left`
-     * - `right`
-     * - `id`
-     *
-     * @param {string} nodeId
-     * @param {NodeRecord} nodeData
-     * @param {pg.Client} [client=null]
-     * @returns {Promise<void>}
-     * @memberof NestedSetModelQueryer
-     */
-  updateNode(nodeId, nodeData, client = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (nodeId.trim() === "") {
-        throw new Error("nodeId can't be empty!");
-      }
-      const sqlValues = [nodeId];
-      const updateFields = Object.keys(nodeData).filter(k => k !== "left" && k !== "right" && k !== "id");
-      if (!updateFields.length) {
-        throw new Error("No valid node data passed for updating.");
-      }
-      const setFieldList = updateFields.
-      map(f => {
-        if (!isValidSqlIdentifier(f)) {
-          throw new Error(`field name: ${f} contains invalid characters!`);
+        else {
+            if (!(valueOrSubQuery === null || valueOrSubQuery === void 0 ? void 0 : valueOrSubQuery.length)) {
+                return SQLSyntax.sqls `TRUE`;
+            }
+            else {
+                return SQLSyntax.sqls `${column} NOT IN ${SQLSyntax.csv(...valueOrSubQuery.map((v) => SQLSyntax.sqls `${v}`)).roundBracket()}`;
+            }
         }
-        sqlValues.push(nodeData[f]);
-        return `"${f}" = $${sqlValues.length}`;
-      }).
-      join(", ");
-      yield (client ? client : this.pool).query(`UPDATE "${this.tableName}" SET ${setFieldList} WHERE "id" = $1`, sqlValues);
-    });
-  }
-  getChildTextTreeNodes(parentId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const nodes = yield this.getImmediateChildren(parentId);
-      if (!nodes || !nodes.length)
-      return [];
-      const textNodeList = [];
-      for (let i = 0; i < nodes.length; i++) {
-        const nodeChildren = yield this.getChildTextTreeNodes(nodes[i].id);
-        if (nodeChildren.length) {
-          textNodeList.push({
-            text: nodes[i].name,
-            children: nodeChildren });
-
-        } else
-        {
-          textNodeList.push(nodes[i].name);
+    }
+    static like(column, value) {
+        return SQLSyntax.sqls `${column} LIKE ${value}`;
+    }
+    static notLike(column, value) {
+        return SQLSyntax.sqls `${column} NOT LIKE ${value}`;
+    }
+    static exists(part) {
+        return SQLSyntax.empty.exists(part);
+    }
+    static notExists(part) {
+        return SQLSyntax.empty.notExists(part);
+    }
+    static distinct(...columns) {
+        return SQLSyntax.sqls `DISTINCT ${SQLSyntax.csv(...columns)}`;
+    }
+    static count(column) {
+        return SQLSyntax.sqls `COUNT(${column})`;
+    }
+    static min(column) {
+        return SQLSyntax.sqls `MIN(${column})`;
+    }
+    static max(column) {
+        return SQLSyntax.sqls `MAX(${column})`;
+    }
+    static avg(column) {
+        return SQLSyntax.sqls `AVG(${column})`;
+    }
+    static sum(column) {
+        return SQLSyntax.sqls `SUM(${column})`;
+    }
+    static roundBracket(inner) {
+        if (!inner || !(inner === null || inner === void 0 ? void 0 : inner.isEmpty)) {
+            return SQLSyntax.empty;
         }
-      }
-      return textNodeList;
-    });
-  }
-  /**
-     * Generate the Text View of the tree
-     * Provided as Dev tool only
-     *
-     * E.g. output could be:
-     * └─ Albert
-     *      ├─ Chuck
-     *      │  ├─ Fred
-     *      │  ├─ Eddie
-     *      │  └─ Donna
-     *      └─ Bert
-     *
-     * @returns {Promise<string>}
-     * @memberof NestedSetModelQueryer
-     */
-  getTreeTextView() {
-    return __awaiter(this, void 0, void 0, function* () {
-      const rootNodeMaybe = yield this.getRootNode();
-      return rootNodeMaybe.caseOf({
-        just: rootNode => __awaiter(this, void 0, void 0, function* () {
-          const tree = [];
-          const children = yield this.getChildTextTreeNodes(rootNode.id);
-          if (children.length) {
-            tree.push({
-              text: rootNode.name,
-              children });
+        return inner.roundBracket();
+    }
+}
+SQLSyntax.isDebugMode = false;
+SQLSyntax.empty = new SQLSyntax(true);
+SQLSyntax.asc = SQLSyntax.empty.asc();
+SQLSyntax.desc = SQLSyntax.empty.desc();
+function sqls(sqlParts, ...values) {
+    return SQLSyntax.sqls(sqlParts, ...values);
+}
+/**
+ * Escape postgreSQL SQL identifier string
+ * Although postgreSQL does allow non-ASCII characters in identifiers, to make it simple, we will remove any non-ASCII characters.
+ *
+ * @export
+ * @param {string} idStr
+ * @return {*}  {string}
+ */
+function escapeIdentifierStr(idStr) {
+    return '"' + idStr.replace(/[^\x20-\x7e]/g, "").replace(/"/g, "\"'") + '"';
+}
+/**
+ * Escape postgreSQL SQL identifier (e.g. column names, or table names).
+ * `xxx."ss.dd` will be escaped as `"xxx"."""ss"."dd"`
+ * Although postgreSQL does allow non-ASCII characters in identifiers, to make it simple, we will remove any non-ASCII characters.
+ *
+ * @export
+ * @param {string} id
+ * @return {*}  {SQLSyntax}
+ */
+function escapeIdentifier(id) {
+    const sanitisedIdStr = id.replace(/[^\x20-\x7e]/g, "");
+    const parts = sanitisedIdStr.split(".");
+    const escapedIdStr = parts.length > 1
+        ? parts.map((item) => escapeIdentifierStr(item)).join(".")
+        : escapeIdentifierStr(sanitisedIdStr);
+    return SQLSyntax.createUnsafely(escapedIdStr);
+}
+/**
+ * Make a postgreSQL identifier in SQLSyntax from tableRef (optional) & column name.
+ *
+ * @export
+ * @param {String} columnName
+ * @param {String} [tableRef=""]
+ * @param {Boolean} [useLowerCaseColumnName=true]
+ * @return {*}  {SQLSyntax}
+ */
+function getTableColumnName(columnName, tableRef = "", useLowerCaseColumnName = false) {
+    const id = [
+        tableRef,
+        useLowerCaseColumnName ? columnName.toLowerCase : useLowerCaseColumnName
+    ]
+        .filter((item) => item)
+        .join(".");
+    return escapeIdentifier(id);
+}
 
-          } else
-          {
-            tree.push(rootNode.name);
-          }
-          return textTree(tree);
-        }),
-        nothing: () => __awaiter(this, void 0, void 0, function* () {return "Empty Tree";}) });
 
-    });
-  }}
+//# sourceMappingURL=index.js.map
 
-exports.default = NestedSetModelQueryer;
 
 /***/ }),
-/* 10 */
+/* 7 */,
+/* 8 */,
+/* 9 */
 /***/ (function(module, exports, __webpack_require__) {
 
 /* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_RESULT__;/**
@@ -18008,279 +17540,1874 @@ exports.default = NestedSetModelQueryer;
     lodash.upperCase = upperCase;
     lodash.upperFirst = upperFirst;
 
-    // Add aliases.
-    lodash.each = forEach;
-    lodash.eachRight = forEachRight;
-    lodash.first = head;
+    // Add aliases.
+    lodash.each = forEach;
+    lodash.eachRight = forEachRight;
+    lodash.first = head;
+
+    mixin(lodash, (function() {
+      var source = {};
+      baseForOwn(lodash, function(func, methodName) {
+        if (!hasOwnProperty.call(lodash.prototype, methodName)) {
+          source[methodName] = func;
+        }
+      });
+      return source;
+    }()), { 'chain': false });
+
+    /*------------------------------------------------------------------------*/
+
+    /**
+     * The semantic version number.
+     *
+     * @static
+     * @memberOf _
+     * @type {string}
+     */
+    lodash.VERSION = VERSION;
+
+    // Assign default placeholders.
+    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
+      lodash[methodName].placeholder = lodash;
+    });
+
+    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
+    arrayEach(['drop', 'take'], function(methodName, index) {
+      LazyWrapper.prototype[methodName] = function(n) {
+        n = n === undefined ? 1 : nativeMax(toInteger(n), 0);
+
+        var result = (this.__filtered__ && !index)
+          ? new LazyWrapper(this)
+          : this.clone();
+
+        if (result.__filtered__) {
+          result.__takeCount__ = nativeMin(n, result.__takeCount__);
+        } else {
+          result.__views__.push({
+            'size': nativeMin(n, MAX_ARRAY_LENGTH),
+            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
+          });
+        }
+        return result;
+      };
+
+      LazyWrapper.prototype[methodName + 'Right'] = function(n) {
+        return this.reverse()[methodName](n).reverse();
+      };
+    });
+
+    // Add `LazyWrapper` methods that accept an `iteratee` value.
+    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
+      var type = index + 1,
+          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
+
+      LazyWrapper.prototype[methodName] = function(iteratee) {
+        var result = this.clone();
+        result.__iteratees__.push({
+          'iteratee': getIteratee(iteratee, 3),
+          'type': type
+        });
+        result.__filtered__ = result.__filtered__ || isFilter;
+        return result;
+      };
+    });
+
+    // Add `LazyWrapper` methods for `_.head` and `_.last`.
+    arrayEach(['head', 'last'], function(methodName, index) {
+      var takeName = 'take' + (index ? 'Right' : '');
+
+      LazyWrapper.prototype[methodName] = function() {
+        return this[takeName](1).value()[0];
+      };
+    });
+
+    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
+    arrayEach(['initial', 'tail'], function(methodName, index) {
+      var dropName = 'drop' + (index ? '' : 'Right');
+
+      LazyWrapper.prototype[methodName] = function() {
+        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
+      };
+    });
+
+    LazyWrapper.prototype.compact = function() {
+      return this.filter(identity);
+    };
+
+    LazyWrapper.prototype.find = function(predicate) {
+      return this.filter(predicate).head();
+    };
+
+    LazyWrapper.prototype.findLast = function(predicate) {
+      return this.reverse().find(predicate);
+    };
+
+    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
+      if (typeof path == 'function') {
+        return new LazyWrapper(this);
+      }
+      return this.map(function(value) {
+        return baseInvoke(value, path, args);
+      });
+    });
+
+    LazyWrapper.prototype.reject = function(predicate) {
+      return this.filter(negate(getIteratee(predicate)));
+    };
+
+    LazyWrapper.prototype.slice = function(start, end) {
+      start = toInteger(start);
+
+      var result = this;
+      if (result.__filtered__ && (start > 0 || end < 0)) {
+        return new LazyWrapper(result);
+      }
+      if (start < 0) {
+        result = result.takeRight(-start);
+      } else if (start) {
+        result = result.drop(start);
+      }
+      if (end !== undefined) {
+        end = toInteger(end);
+        result = end < 0 ? result.dropRight(-end) : result.take(end - start);
+      }
+      return result;
+    };
+
+    LazyWrapper.prototype.takeRightWhile = function(predicate) {
+      return this.reverse().takeWhile(predicate).reverse();
+    };
+
+    LazyWrapper.prototype.toArray = function() {
+      return this.take(MAX_ARRAY_LENGTH);
+    };
+
+    // Add `LazyWrapper` methods to `lodash.prototype`.
+    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
+      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
+          isTaker = /^(?:head|last)$/.test(methodName),
+          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
+          retUnwrapped = isTaker || /^find/.test(methodName);
+
+      if (!lodashFunc) {
+        return;
+      }
+      lodash.prototype[methodName] = function() {
+        var value = this.__wrapped__,
+            args = isTaker ? [1] : arguments,
+            isLazy = value instanceof LazyWrapper,
+            iteratee = args[0],
+            useLazy = isLazy || isArray(value);
+
+        var interceptor = function(value) {
+          var result = lodashFunc.apply(lodash, arrayPush([value], args));
+          return (isTaker && chainAll) ? result[0] : result;
+        };
+
+        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
+          // Avoid lazy use if the iteratee has a "length" value other than `1`.
+          isLazy = useLazy = false;
+        }
+        var chainAll = this.__chain__,
+            isHybrid = !!this.__actions__.length,
+            isUnwrapped = retUnwrapped && !chainAll,
+            onlyLazy = isLazy && !isHybrid;
+
+        if (!retUnwrapped && useLazy) {
+          value = onlyLazy ? value : new LazyWrapper(this);
+          var result = func.apply(value, args);
+          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });
+          return new LodashWrapper(result, chainAll);
+        }
+        if (isUnwrapped && onlyLazy) {
+          return func.apply(this, args);
+        }
+        result = this.thru(interceptor);
+        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
+      };
+    });
+
+    // Add `Array` methods to `lodash.prototype`.
+    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {
+      var func = arrayProto[methodName],
+          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
+          retUnwrapped = /^(?:pop|shift)$/.test(methodName);
+
+      lodash.prototype[methodName] = function() {
+        var args = arguments;
+        if (retUnwrapped && !this.__chain__) {
+          var value = this.value();
+          return func.apply(isArray(value) ? value : [], args);
+        }
+        return this[chainName](function(value) {
+          return func.apply(isArray(value) ? value : [], args);
+        });
+      };
+    });
+
+    // Map minified method names to their real names.
+    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
+      var lodashFunc = lodash[methodName];
+      if (lodashFunc) {
+        var key = lodashFunc.name + '';
+        if (!hasOwnProperty.call(realNames, key)) {
+          realNames[key] = [];
+        }
+        realNames[key].push({ 'name': methodName, 'func': lodashFunc });
+      }
+    });
+
+    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{
+      'name': 'wrapper',
+      'func': undefined
+    }];
+
+    // Add methods to `LazyWrapper`.
+    LazyWrapper.prototype.clone = lazyClone;
+    LazyWrapper.prototype.reverse = lazyReverse;
+    LazyWrapper.prototype.value = lazyValue;
+
+    // Add chain sequence methods to the `lodash` wrapper.
+    lodash.prototype.at = wrapperAt;
+    lodash.prototype.chain = wrapperChain;
+    lodash.prototype.commit = wrapperCommit;
+    lodash.prototype.next = wrapperNext;
+    lodash.prototype.plant = wrapperPlant;
+    lodash.prototype.reverse = wrapperReverse;
+    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
+
+    // Add lazy aliases.
+    lodash.prototype.first = lodash.prototype.head;
+
+    if (symIterator) {
+      lodash.prototype[symIterator] = wrapperToIterator;
+    }
+    return lodash;
+  });
+
+  /*--------------------------------------------------------------------------*/
+
+  // Export lodash.
+  var _ = runInContext();
+
+  // Some AMD build optimizers, like r.js, check for condition patterns like:
+  if (true) {
+    // Expose Lodash on the global object to prevent errors when Lodash is
+    // loaded by a script tag in the presence of an AMD loader.
+    // See http://requirejs.org/docs/errors.html#mismatch for more details.
+    // Use `_.noConflict` to remove Lodash from the global object.
+    root._ = _;
+
+    // Define as an anonymous module so, through path mapping, it can be
+    // referenced as the "underscore" module.
+    !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
+      return _;
+    }).call(exports, __webpack_require__, exports, module),
+				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+  }
+  // Check for `exports` after `define` in case a build optimizer adds it.
+  else {}
+}.call(this));
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(14)(module)))
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countTableRecord = exports.getTableRecord = exports.searchTableRecord = exports.MAX_PAGE_RECORD_NUMBER = exports.parseIntParam = exports.deleteTableRecord = exports.updateTableRecord = exports.createTableRecord = exports.getTableColumnName = exports.escapeIdentifier = exports.escapeIdentifierStr = void 0;
+const sql_syntax_1 = __importStar(__webpack_require__(6));
+const AuthDecision_1 = __webpack_require__(11);
+const lodash_1 = __webpack_require__(9);
+const ServerError_1 = __importDefault(__webpack_require__(17));
+/**
+ * Escape SQL identifier string
+ * Although postgreSQL does allow non-ASCII characters in identifiers, to make it simple, we will remove any non-ASCII characters.
+ *
+ * @export
+ * @param {string} idStr
+ * @return {*}  {string}
+ */
+function escapeIdentifierStr(idStr) {
+    return '"' + idStr.replace(/[^\x20-\x7e]/g, "").replace(/"/g, "\"'") + '"';
+}
+exports.escapeIdentifierStr = escapeIdentifierStr;
+/**
+ * Escape SQL identifier (e.g. column names, or table names).
+ * `xxx."ss.dd` will be escaped as `"xxx"."""ss"."dd"`
+ * Although postgreSQL does allow non-ASCII characters in identifiers, to make it simple, we will remove any non-ASCII characters.
+ *
+ * @export
+ * @param {string} id
+ * @return {*}  {SQLSyntax}
+ */
+function escapeIdentifier(id) {
+    const sanitisedIdStr = id.replace(/[^\x20-\x7e]/g, "");
+    const parts = sanitisedIdStr.split(".");
+    const escapedIdStr = parts.length > 1
+        ? parts.map((item) => escapeIdentifierStr(item)).join(".")
+        : escapeIdentifierStr(sanitisedIdStr);
+    return sql_syntax_1.default.createUnsafely(escapedIdStr);
+}
+exports.escapeIdentifier = escapeIdentifier;
+/**
+ * Make a postgreSQL identifier in SQLSyntax from tableRef (optional) & column name.
+ *
+ * @export
+ * @param {String} columnName
+ * @param {String} [tableRef=""]
+ * @param {Boolean} [useLowerCaseColumnName=true]
+ * @return {*}  {SQLSyntax}
+ */
+function getTableColumnName(columnName, tableRef = "", useLowerCaseColumnName = false) {
+    const id = [
+        tableRef,
+        useLowerCaseColumnName ? columnName.toLowerCase() : columnName
+    ]
+        .filter((item) => item)
+        .join(".");
+    return escapeIdentifier(id);
+}
+exports.getTableColumnName = getTableColumnName;
+/**
+ * Create a record for given table with given data object.
+ * This method will use the key / value pairs of the object as column name / value of the new record.
+ * It will return the newly created record
+ *
+ * @export
+ * @param {pg.Client | pg.Pool} poolOrClient
+ * @param {string} table
+ * @param {{ [key: string]: Value }} data
+ * @return {*}
+ */
+function createTableRecord(poolOrClient, table, data, allowFieldList, autoGenerateUuid = true) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!table.trim()) {
+            throw new Error("invalid empty table name is supplied.");
+        }
+        if (allowFieldList === null || allowFieldList === void 0 ? void 0 : allowFieldList.length) {
+            const keys = Object.keys(data);
+            const diff = lodash_1.difference(keys, allowFieldList);
+            if (diff === null || diff === void 0 ? void 0 : diff.length) {
+                throw new ServerError_1.default(`Failed to create record, the following fields are not allowed: ${diff.join(",")}`, 400);
+            }
+        }
+        if (autoGenerateUuid) {
+            data["id"] = sql_syntax_1.sqls `uuid_generate_v4()`;
+        }
+        const [fieldList, valueList] = Object.keys(data).reduce((result, currentKey) => {
+            const currentValue = data[currentKey];
+            result[0].push(escapeIdentifier(currentKey));
+            result[1].push(sql_syntax_1.sqls `${currentValue}`);
+            return result;
+        }, [[], []]);
+        const sqlSyntax = sql_syntax_1.sqls `INSERT INTO ${escapeIdentifier(table)} 
+        (${sql_syntax_1.default.csv(...fieldList)})
+        VALUES
+        (${sql_syntax_1.default.csv(...valueList)})
+        RETURNING *`;
+        const result = yield poolOrClient.query(...sqlSyntax.toQuery());
+        return result.rows[0];
+    });
+}
+exports.createTableRecord = createTableRecord;
+function updateTableRecord(poolOrClient, table, id, data, allowFieldList) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!id.trim()) {
+            throw new ServerError_1.default("Failed to delete the record: empty id was provided.", 400);
+        }
+        if (!table.trim()) {
+            throw new ServerError_1.default("invalid empty table name is supplied.", 500);
+        }
+        if (allowFieldList === null || allowFieldList === void 0 ? void 0 : allowFieldList.length) {
+            const keys = Object.keys(data);
+            const diff = lodash_1.difference(keys, allowFieldList);
+            if (diff === null || diff === void 0 ? void 0 : diff.length) {
+                throw new ServerError_1.default(`Failed to update record, the following fields are not allowed: ${diff.join(",")}`, 400);
+            }
+        }
+        const updates = Object.keys(data).reduce((result, currentKey) => {
+            const currentValue = data[currentKey];
+            result.push(sql_syntax_1.sqls `${escapeIdentifier(currentKey)} = ${sql_syntax_1.sqls `${currentValue}`}`);
+            return result;
+        }, []);
+        const sqlSyntax = sql_syntax_1.sqls `UPDATE ${escapeIdentifier(table)} 
+        SET ${sql_syntax_1.default.csv(...updates)}
+        WHERE id = ${id}
+        RETURNING *`;
+        const result = yield poolOrClient.query(...sqlSyntax.toQuery());
+        return result.rows[0];
+    });
+}
+exports.updateTableRecord = updateTableRecord;
+function deleteTableRecord(poolOrClient, table, id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!id.trim()) {
+            throw new ServerError_1.default("Failed to delete the record: empty id was provided.", 400);
+        }
+        if (!table.trim()) {
+            throw new ServerError_1.default("invalid empty table name is supplied.", 500);
+        }
+        const sqlSyntax = sql_syntax_1.sqls `DELETE FROM ${escapeIdentifier(table)} WHERE id = ${id}`;
+        yield poolOrClient.query(...sqlSyntax.toQuery());
+    });
+}
+exports.deleteTableRecord = deleteTableRecord;
+function parseIntParam(p) {
+    if (!p) {
+        return 0;
+    }
+    const result = parseInt(p === null || p === void 0 ? void 0 : p.toString());
+    if (isNaN(result)) {
+        return 0;
+    }
+    return result;
+}
+exports.parseIntParam = parseIntParam;
+exports.MAX_PAGE_RECORD_NUMBER = 500;
+function searchTableRecord(poolOrClient, table, contiditions = [], queryConfig) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!table.trim()) {
+            throw new ServerError_1.default("invalid empty table name is supplied.");
+        }
+        const objectKind = (queryConfig === null || queryConfig === void 0 ? void 0 : queryConfig.objectKind) ? queryConfig.objectKind
+            : "authObject";
+        const authDecision = (queryConfig === null || queryConfig === void 0 ? void 0 : queryConfig.authDecision) ? queryConfig.authDecision
+            : AuthDecision_1.UnconditionalTrueDecision;
+        let limit = parseIntParam(queryConfig === null || queryConfig === void 0 ? void 0 : queryConfig.limit);
+        const offset = parseIntParam(queryConfig === null || queryConfig === void 0 ? void 0 : queryConfig.offset);
+        if (limit > exports.MAX_PAGE_RECORD_NUMBER) {
+            limit = exports.MAX_PAGE_RECORD_NUMBER;
+        }
+        const config = (queryConfig === null || queryConfig === void 0 ? void 0 : queryConfig.toSqlConfig) ? queryConfig.toSqlConfig
+            : {
+                prefixes: [
+                    `input.${objectKind}.${lodash_1.camelCase(table.replace(/s$/, ""))}`
+                ]
+            };
+        const authConditions = authDecision.toSql(config);
+        const where = sql_syntax_1.default.where(sql_syntax_1.default.joinWithAnd([...contiditions, authConditions]));
+        const sqlSyntax = sql_syntax_1.sqls `SELECT ${(queryConfig === null || queryConfig === void 0 ? void 0 : queryConfig.selectedFields) ? sql_syntax_1.default.csv(...queryConfig.selectedFields)
+            : sql_syntax_1.sqls `*`} 
+        FROM ${escapeIdentifier(table)}
+        ${((_a = queryConfig === null || queryConfig === void 0 ? void 0 : queryConfig.leftJoins) === null || _a === void 0 ? void 0 : _a.length) ? sql_syntax_1.default.join(queryConfig.leftJoins.map((joinItem) => sql_syntax_1.sqls `LEFT JOIN ${escapeIdentifier(joinItem.table)} ON ${joinItem.joinCondition}`), sql_syntax_1.sqls `\n`)
+            : sql_syntax_1.default.empty}
+        ${where}
+        ${(queryConfig === null || queryConfig === void 0 ? void 0 : queryConfig.groupBy) ? sql_syntax_1.sqls `GROUP BY ${typeof ((_b = queryConfig.groupBy) === null || _b === void 0 ? void 0 : _b.length) === "number"
+            ? sql_syntax_1.default.csv(...queryConfig.groupBy)
+            : queryConfig.groupBy}`
+            : sql_syntax_1.default.empty}
+        ${offset ? sql_syntax_1.sqls `OFFSET ${offset}` : sql_syntax_1.default.empty}
+        ${limit ? sql_syntax_1.sqls `LIMIT ${limit}` : sql_syntax_1.default.empty}
+        `;
+        const result = yield poolOrClient.query(...sqlSyntax.toQuery());
+        if (!((_c = result === null || result === void 0 ? void 0 : result.rows) === null || _c === void 0 ? void 0 : _c.length)) {
+            return [];
+        }
+        else {
+            return result.rows;
+        }
+    });
+}
+exports.searchTableRecord = searchTableRecord;
+function getTableRecord(poolOrClient, table, id, authDecision = AuthDecision_1.UnconditionalTrueDecision, objectKind = "authObject", toSqlConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const records = yield searchTableRecord(poolOrClient, table, [sql_syntax_1.sqls `id = ${id}`], {
+            authDecision,
+            objectKind,
+            toSqlConfig
+        });
+        if (!records.length) {
+            return null;
+        }
+        else {
+            return records[0];
+        }
+    });
+}
+exports.getTableRecord = getTableRecord;
+function countTableRecord(poolOrClient, table, contiditions = [], authDecision, objectKind, toSqlConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const records = yield searchTableRecord(poolOrClient, table, contiditions, {
+            authDecision,
+            objectKind,
+            toSqlConfig,
+            selectedFields: [sql_syntax_1.sqls `COUNT(*) AS total`]
+        });
+        if (!records.length) {
+            return 0;
+        }
+        else {
+            return records[0]["total"];
+        }
+    });
+}
+exports.countTableRecord = countTableRecord;
+//# sourceMappingURL=SQLUtils.js.map
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConciseOperand = exports.ConciseExpression = exports.ConciseRule = exports.UnconditionalFalseDecision = exports.UnconditionalTrueDecision = exports.isTrueEquivalent = void 0;
+const AspectQuery_1 = __webpack_require__(16);
+const sql_syntax_1 = __importStar(__webpack_require__(6));
+class AuthDecision {
+    constructor(hasResidualRules, residualRules, result, hasWarns = false, warns = [], unknowns) {
+        if (typeof hasResidualRules !== "boolean") {
+            throw new Error("Failed to create AuthDecision: invalid hasResidualRules type");
+        }
+        if (hasResidualRules && !(residualRules === null || residualRules === void 0 ? void 0 : residualRules.length)) {
+            throw new Error("Failed to create AuthDecision: residualRules must have at least one item when hasResidualRules == true");
+        }
+        this.hasResidualRules = hasResidualRules;
+        this.result = result;
+        this.residualRules = residualRules;
+        this.hasWarns = hasWarns;
+        this.warns = warns;
+        this.unknowns = unknowns;
+    }
+    static fromJson(data) {
+        var _a;
+        return new AuthDecision(data === null || data === void 0 ? void 0 : data.hasResidualRules, (_a = data === null || data === void 0 ? void 0 : data.residualRules) === null || _a === void 0 ? void 0 : _a.map((item) => ConciseRule.fromJson(item)), data === null || data === void 0 ? void 0 : data.result, (data === null || data === void 0 ? void 0 : data.hasWarns) ? true : false, data === null || data === void 0 ? void 0 : data.warns, data === null || data === void 0 ? void 0 : data.unknowns);
+    }
+    toAspectQueryGroups(prefixes) {
+        if (this.hasResidualRules) {
+            return this.residualRules.map((item) => item.toAspectQueryGroup(prefixes));
+        }
+        else {
+            if (isTrueEquivalent(this.result)) {
+                // unconditional true
+                return [new AspectQuery_1.AspectQueryGroup([new AspectQuery_1.AspectQueryTrue()])];
+            }
+            else {
+                return [new AspectQuery_1.AspectQueryGroup([new AspectQuery_1.AspectQueryFalse()])];
+            }
+        }
+    }
+    toSql(config) {
+        return sql_syntax_1.default.joinWithOr(this.toAspectQueryGroups(config.prefixes).map((item) => item.toSql(config))).roundBracket();
+    }
+}
+exports.default = AuthDecision;
+function isTrueEquivalent(value) {
+    const typeStr = typeof value;
+    if (typeStr === "boolean") {
+        return value;
+    }
+    else if (typeStr === "undefined") {
+        return false;
+    }
+    else if (typeof (value === null || value === void 0 ? void 0 : value.length) !== "undefined") {
+        return !!value.length;
+    }
+    else {
+        return !!value;
+    }
+}
+exports.isTrueEquivalent = isTrueEquivalent;
+exports.UnconditionalTrueDecision = new AuthDecision(false, undefined, true);
+exports.UnconditionalFalseDecision = new AuthDecision(false, undefined, false);
+class ConciseRule {
+    constructor(fullName, name, value, expressions, isDefault = false) {
+        if (!isDefault && !(expressions === null || expressions === void 0 ? void 0 : expressions.length)) {
+            throw new Error("Invalid ConciseRule data: it must contain at least one ConciseExpression item unless it's a default rule.");
+        }
+        this.default = isDefault ? true : false;
+        this.fullName = fullName;
+        this.name = name;
+        this.value = value;
+        this.expressions = (expressions === null || expressions === void 0 ? void 0 : expressions.length) ? expressions : [];
+    }
+    static fromJson(data) {
+        var _a;
+        return new ConciseRule(data === null || data === void 0 ? void 0 : data.fullName, data === null || data === void 0 ? void 0 : data.name, data === null || data === void 0 ? void 0 : data.value, (_a = data === null || data === void 0 ? void 0 : data.expressions) === null || _a === void 0 ? void 0 : _a.map((item) => ConciseExpression.fromJson(item)));
+    }
+    toAspectQueryGroup(prefixes) {
+        var _a;
+        return new AspectQuery_1.AspectQueryGroup((_a = this.expressions) === null || _a === void 0 ? void 0 : _a.map((item) => item.toAspectQuery(prefixes)), true, !isTrueEquivalent(this.value));
+    }
+}
+exports.ConciseRule = ConciseRule;
+class ConciseExpression {
+    constructor(operands, operator, negated = false) {
+        var _a, _b;
+        this.negated = negated ? true : false;
+        this.operands = operands;
+        this.operator = operator;
+        if (!((_a = this.operands) === null || _a === void 0 ? void 0 : _a.length)) {
+            throw new Error("invalid ConciseExpression data: it must have at least one operand.");
+        }
+        if (((_b = this.operands) === null || _b === void 0 ? void 0 : _b.length) > 1 && typeof operator !== "string") {
+            throw new Error("invalid ConciseExpression data: when operands number > 1, operator must be a valid string value.");
+        }
+    }
+    static fromJson(data) {
+        var _a;
+        return new ConciseExpression((_a = data === null || data === void 0 ? void 0 : data.operands) === null || _a === void 0 ? void 0 : _a.map((item) => ConciseOperand.fromJson(item)), data === null || data === void 0 ? void 0 : data.operator, data === null || data === void 0 ? void 0 : data.negated);
+    }
+    getSqlOperator() {
+        switch (this.operator) {
+            case "=":
+                return sql_syntax_1.sqls `=`;
+            case ">":
+                return sql_syntax_1.sqls `>`;
+            case "<":
+                return sql_syntax_1.sqls `<`;
+            case ">=":
+                return sql_syntax_1.sqls `>=`;
+            case "<=":
+                return sql_syntax_1.sqls `<=`;
+            default:
+                throw new Error(`Failed to convert auth decision operator to SQL operator: unsupported operator: ${this.operator}`);
+        }
+    }
+    toAspectQuery(prefixes) {
+        var _a, _b;
+        if (((_a = this.operands) === null || _a === void 0 ? void 0 : _a.length) == 1) {
+            const [aspectId, path, isCollection] = this.operands[0].extractAspectIdAndPath(prefixes);
+            if (isCollection) {
+                return new AspectQuery_1.AspectQueryArrayNotEmpty(aspectId, path, this.negated);
+            }
+            else {
+                return new AspectQuery_1.AspectQueryExists(aspectId, path, this.negated);
+            }
+        }
+        else if (((_b = this.operands) === null || _b === void 0 ? void 0 : _b.length) == 2) {
+            const refOperand = this.operands.find((item) => item.isRef);
+            const valOperand = this.operands.find((item) => !item.isRef);
+            if (!valOperand) {
+                throw new Error("Failed to convert auth decision expression to AspectQuery: " +
+                    `expression with both terms are references is currently not supported. Expression: ${this}`);
+            }
+            if (!refOperand) {
+                // it's unlikely both terms are values as our decision API has already done the evaluation for this case.
+                throw new Error("Failed to convert auth decision expression to AspectQuery: " +
+                    `Terms shouldn't be both value. Expression: ${this}`);
+            }
+            const [aspectId, path, isCollection] = refOperand.extractAspectIdAndPath(prefixes);
+            if (isCollection && this.operator != "=") {
+                throw new Error("Failed to convert auth decision expression to AspectQuery: " +
+                    `Only \`=\` operator is supported for collection reference. Expression: ${this}`);
+            }
+            if (isCollection && this.operator == "=") {
+                return new AspectQuery_1.AspectQueryValueInArray(valOperand.toAspectQueryValue(), aspectId, path, this.negated);
+            }
+            else {
+                return new AspectQuery_1.AspectQueryWithValue(valOperand.toAspectQueryValue(), this.getSqlOperator(), this.operands[0].isRef, aspectId, path, this.negated);
+            }
+        }
+        else {
+            throw new Error(`Failed to convert auth decision expression to AspectQuery: more than 2 operands found. Expression: ${this}`);
+        }
+    }
+}
+exports.ConciseExpression = ConciseExpression;
+class ConciseOperand {
+    constructor(isRef, value) {
+        if (typeof isRef !== "boolean") {
+            throw new Error("Invalid ConciseOperand data: isRef must be a boolean value.");
+        }
+        this.isRef = isRef;
+        if (isRef && typeof value !== "string") {
+            throw new Error("Invalid ConciseOperand data: when `isRef`== true, `value` must be a string value (ref string).");
+        }
+        this.value = value;
+    }
+    static fromJson(data) {
+        return new ConciseOperand(data === null || data === void 0 ? void 0 : data.isRef, data === null || data === void 0 ? void 0 : data.value);
+    }
+    refString() {
+        if (!this.isRef) {
+            throw new Error("Cannot convert non-ref term to a ref string");
+        }
+        else {
+            if (typeof this.value === "string") {
+                return this.value;
+            }
+            else {
+                throw new Error(`ref term has non-string type value: ${this.value}`);
+            }
+        }
+    }
+    isCollectionRef() {
+        return this.refString().endsWith("[_]");
+    }
+    refStringWithoutPrefixes(prefixes) {
+        const sortedPrefixes = prefixes.sort((a, b) => b.length - a.length);
+        return sortedPrefixes.reduce((ref, prefix) => {
+            if (ref.startsWith(prefix)) {
+                return ref.substring(prefix.length);
+            }
+            else {
+                return ref;
+            }
+        }, this.refString());
+    }
+    extractAspectIdAndPath(prefixes) {
+        // make it work for both "input.object.record" & "input.object.record." prefixe input
+        // we remove the first leading `.` char (if any)
+        let ref = this.refStringWithoutPrefixes(prefixes).replace(/^\./, "");
+        const isCollection = this.isCollectionRef();
+        if (isCollection) {
+            ref = ref.replace(/\[_\]$/, "");
+        }
+        const parts = ref.split(".").filter((item) => item);
+        if (parts.length < 2) {
+            return [ref, [], isCollection];
+        }
+        else {
+            return [parts[0], parts.slice(1, parts.length), isCollection];
+        }
+    }
+    toAspectQueryValue() {
+        if (this.isRef) {
+            throw new Error(`Attempt to covert reference \`Operand\` to \`AspectQueryValue\`: ${this}`);
+        }
+        return new AspectQuery_1.AspectQueryValue(this.value);
+    }
+}
+exports.ConciseOperand = ConciseOperand;
+//# sourceMappingURL=AuthDecision.js.map
+
+/***/ }),
+/* 12 */,
+/* 13 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  Object.defineProperty(o, k2, { enumerable: true, get: function () {return m[k];} });
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+var __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {
+  Object.defineProperty(o, "default", { enumerable: true, value: v });
+} : function (o, v) {
+  o["default"] = v;
+});
+var __importStar = this && this.__importStar || function (mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+  __setModuleDefault(result, mod);
+  return result;
+};
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {return value instanceof P ? value : new P(function (resolve) {resolve(value);});}
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {try {step(generator.next(value));} catch (e) {reject(e);}}
+    function rejected(value) {try {step(generator["throw"](value));} catch (e) {reject(e);}}
+    function step(result) {result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);}
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeNotFoundError = void 0;
+const lodash_1 = __importDefault(__webpack_require__(9));
+const tsmonad_1 = __webpack_require__(15);
+const sql_syntax_1 = __importStar(__webpack_require__(6));
+const SQLUtils_1 = __webpack_require__(10);
+const AuthDecision_1 = __webpack_require__(11);
+const textTree = __webpack_require__(18);
+class NodeNotFoundError extends Error {}
+
+exports.NodeNotFoundError = NodeNotFoundError;
+function isNonEmptyArray(v) {
+  if (!v || !lodash_1.default.isArray(v) || !v.length)
+  return false;
+  return true;
+}
+const INVALID_CHAR_REGEX = /[^a-z_\d]/i;
+function isValidSqlIdentifier(id) {
+  if (INVALID_CHAR_REGEX.test(id))
+  return false;
+  return true;
+}
+class NestedSetModelQueryer {
+  /**
+                              * Creates an instance of NestedSetModelQueryer.
+                              * @param {pg.Pool} dbPool
+                              * @param {string} tableName
+                              * @param {string[]} [defaultSelectFieldList=null] default select fields; If null, all fields (i.e. `SELECT "id", "name"`) will be returned
+                              * @memberof NestedSetModelQueryer
+                              */
+  constructor(dbPool, tableName, defaultSelectFieldList = null, defaultInsertFieldList = null) {
+    /**
+                                                                                                 * default select fields if [], all fields (i.e. `SELECT "id", "name"`) will be returned
+                                                                                                 *
+                                                                                                 * @type {string[]}
+                                                                                                 * @memberof NestedSetModelQueryer
+                                                                                                 */
+    this.defaultSelectFieldList = ["id", "name"];
+    /**
+                                                   * Default field list that will be used when insert nodes into tree.
+                                                   * By default, only `name` field will be saved to database
+                                                   * e.g. If your tree nodes have three properties (besides `id`, `left`, `right` --- they auto generated):
+                                                   * - name
+                                                   * - description
+                                                   * - fullName
+                                                   *
+                                                   * Then you should set `defaultInsertFieldList` to ["name", "description", "fullName"]
+                                                   *
+                                                   * @type {string[]}
+                                                   * @memberof NestedSetModelQueryer
+                                                   */
+    this.defaultInsertFieldList = ["name"];
+    if (!dbPool)
+    throw new Error("dbPool cannot be empty!");
+    if (!tableName)
+    throw new Error("tableName cannot be empty!");
+    if (!isValidSqlIdentifier(tableName)) {
+      throw new Error(`tableName: ${tableName} contains invalid characters!`);
+    }
+    this.pool = dbPool;
+    this.tableName = tableName;
+    if (defaultSelectFieldList) {
+      if (!lodash_1.default.isArray(defaultSelectFieldList))
+      throw new Error("defaultSelectFieldList should be an array");
+      this.defaultSelectFieldList = defaultSelectFieldList;
+    }
+    if (defaultSelectFieldList) {
+      if (!lodash_1.default.isArray(defaultSelectFieldList))
+      throw new Error("defaultSelectFieldList should be an array");
+      this.defaultSelectFieldList = defaultSelectFieldList;
+    }
+    if (defaultInsertFieldList) {
+      if (!lodash_1.default.isArray(defaultInsertFieldList))
+      throw new Error("defaultInsertFieldList should be an array");
+      this.defaultInsertFieldList = defaultInsertFieldList;
+    }
+  }
+  selectFields(tableAliasOrName = "", fields = null) {
+    const fieldList = isNonEmptyArray(fields) ?
+    fields :
+    this.defaultSelectFieldList;
+    if (!isNonEmptyArray(fieldList)) {
+      return sql_syntax_1.sqls`*`;
+    }
+    if (!isValidSqlIdentifier(tableAliasOrName)) {
+      throw new Error(`'tableAliasOrName' ${tableAliasOrName} contains invalid characters.`);
+    }
+    // --- do not double quote `tableAliasOrName`
+    // --- or you will get missing FROM-clause entry for table error
+    return sql_syntax_1.default.createUnsafely(fieldList.
+    map(f => {
+      if (!isValidSqlIdentifier(f)) {
+        throw new Error(`Field name ${f} contains invalid characters.`);
+      }
+      return tableAliasOrName === "" ?
+      `"${f}"` :
+      `${tableAliasOrName}."${f}"`;
+    }).
+    join(", "));
+  }
+  /**
+     * Get nodes by name
+     * You hardly need this one --- only for write test case (you can get a id from name)
+     *
+     * @param {string} name
+     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
+     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
+     * @returns {Promise<NodeRecord[]>}
+     * @memberof NestedSetModelQueryer
+     */
+  getNodes(nodesQuery = {}, fields = null, client = null, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"] });
+
+      const clauses = [
+      authConditions,
+      nodesQuery.name ?
+      sql_syntax_1.sqls`"name" = ${nodesQuery.name}` :
+      sql_syntax_1.default.empty,
+      nodesQuery.leafNodesOnly ?
+      sql_syntax_1.sqls`"left" = ( "right" - 1 )` :
+      sql_syntax_1.default.empty];
+
+      const whereClause = sql_syntax_1.default.where(sql_syntax_1.default.joinWithAnd(clauses));
+      const query = sql_syntax_1.sqls`SELECT ${this.selectFields("", fields)} FROM ${SQLUtils_1.escapeIdentifier(this.tableName)} ${whereClause}`;
+      const result = yield (client ? client : this.pool).query(...query.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return [];
+      return result.rows;
+    });
+  }
+  /**
+     *
+     * Get a node by its id
+     * @param {string} id
+     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
+     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
+     * @returns {Promise<NodeRecord>}
+     * @memberof NestedSetModelQueryer
+     */
+  getNodeById(id, fields = null, client = null, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"] });
+
+      const result = yield (client ? client : this.pool).query(...sql_syntax_1.sqls`SELECT ${this.selectFields("", fields)} FROM ${SQLUtils_1.escapeIdentifier(this.tableName)} WHERE ${sql_syntax_1.default.joinWithAnd([
+      sql_syntax_1.sqls`"id" = ${id}`,
+      authConditions])
+      }`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return tsmonad_1.Maybe.nothing();
+      return tsmonad_1.Maybe.just(result.rows[0]);
+    });
+  }
+  /**
+     * Get the root node of the tree
+     * Return null if empty tree or the user has no access to the root node
+     *
+     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
+     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
+     * @returns {Promise<NodeRecord>}
+     * @memberof NestedSetModelQueryer
+     */
+  getRootNode(fields = null, client = null, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"] });
 
-    mixin(lodash, (function() {
-      var source = {};
-      baseForOwn(lodash, function(func, methodName) {
-        if (!hasOwnProperty.call(lodash.prototype, methodName)) {
-          source[methodName] = func;
-        }
-      });
-      return source;
-    }()), { 'chain': false });
+      const result = yield (client ? client : this.pool).query(...sql_syntax_1.sqls`SELECT ${this.selectFields("", fields)} FROM ${SQLUtils_1.escapeIdentifier(this.tableName)} WHERE ${sql_syntax_1.default.joinWithAnd([
+      sql_syntax_1.sqls`"left" = 1`,
+      authConditions])
+      }`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return tsmonad_1.Maybe.nothing();
+      return tsmonad_1.Maybe.just(result.rows[0]);
+    });
+  }
+  /**
+     * Get All children of a given node
+     * (including immediate children and children of immediate children etc.)
+     * If the node has no child (i.e. a leaf node), an empty array will be returned
+     *
+     * @param {string} parentNodeId
+     * @param {boolean} [includeMyself=false]
+     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
+     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
+     * @returns {Promise<NodeRecord[]>}
+     * @memberof NestedSetModelQueryer
+     */
+  getAllChildren(parentNodeId, includeMyself = false, fields = null, client = null, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "children" });
+
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const conditions = [
+      sql_syntax_1.sqls`Children."left" ${includeMyself ? sql_syntax_1.sqls`>=` : sql_syntax_1.sqls`>`} Parents."left"`,
+      sql_syntax_1.sqls`Children."left" ${includeMyself ? sql_syntax_1.sqls`<=` : sql_syntax_1.sqls`<`} Parents."right"`,
+      sql_syntax_1.sqls`Parents."id" = ${parentNodeId}`,
+      authConditions];
+
+      const result = yield (client ? client : this.pool).query(...sql_syntax_1.sqls`SELECT ${this.selectFields("Children", fields)} 
+             FROM ${tbl} AS Parents,  ${tbl} AS Children
+             WHERE ${sql_syntax_1.default.joinWithAnd(conditions)}`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return [];
+      return result.rows;
+    });
+  }
+  /**
+     * Get All parents of a given node
+     * (including immediate parent and parents of immediate parent etc.)
+     * If the node has no parent (i.e. a root node), an empty array will be returned (unless `includeMyself` = true)
+     *
+     * @param {string} childNodeId
+     * @param {boolean} [includeMyself=false]
+     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
+     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
+     * @returns {Promise<NodeRecord[]>}
+     * @memberof NestedSetModelQueryer
+     */
+  getAllParents(childNodeId, includeMyself = false, fields = null, client = null, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "parents" });
+
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const conditions = [
+      sql_syntax_1.sqls`Children."left" ${includeMyself ? sql_syntax_1.sqls`>=` : sql_syntax_1.sqls`>`} Parents."left"`,
+      sql_syntax_1.sqls`Children."left" ${includeMyself ? sql_syntax_1.sqls`<=` : sql_syntax_1.sqls`<`} Parents."right"`,
+      sql_syntax_1.sqls`Children."id" = ${childNodeId}`,
+      authConditions];
+
+      const result = yield (client ? client : this.pool).query(...sql_syntax_1.sqls`SELECT ${this.selectFields("Parents", fields)} 
+             FROM ${tbl} AS Parents, ${tbl} AS Children
+             WHERE ${sql_syntax_1.default.joinWithAnd(conditions)}`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return [];
+      return result.rows;
+    });
+  }
+  /**
+     * Get Immediate Children of a Node
+     * If the node has no child (i.e. a leaf node), an empty array will be returned
+     *
+     * @param {string} parentNodeId
+     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
+     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
+     * @returns {Promise<NodeRecord[]>}
+     * @memberof NestedSetModelQueryer
+     */
+  getImmediateChildren(parentNodeId, fields = null, client = null, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "children" });
 
-    /*------------------------------------------------------------------------*/
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const result = yield (client ? client : this.pool).query(...sql_syntax_1.sqls`SELECT ${this.selectFields("Children", fields)} 
+            FROM ${tbl} AS Parents, ${tbl} AS Children
+            WHERE Children."left" BETWEEN Parents."left" AND Parents."right" 
+            AND Parents."left" = (
+                SELECT MAX(S."left") FROM ${tbl} AS S
+                WHERE S."left" < Children."left" AND S."right" > Children."right"
+            ) 
+            AND Parents."id" = ${parentNodeId}
+            ${authConditions.isEmpty ?
+      sql_syntax_1.default.empty :
+      sql_syntax_1.sqls` AND ${authConditions}`}
+            ORDER BY Children."left" ASC`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return [];
+      return result.rows;
+    });
+  }
+  /**
+     * Get Immediate Parent of a Node
+     * If the node has no parent (i.e. a root node), null will be returned
+     *
+     * @param {string} childNodeId
+     * @param {string[]} [fields=null] Selected Fields; If null, use this.defaultSelectFieldList
+     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
+     * @returns {Promise<NodeRecord>}
+     * @memberof NestedSetModelQueryer
+     */
+  getImmediateParent(childNodeId, fields = null, client = null, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "parents" });
 
-    /**
-     * The semantic version number.
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const result = yield (client ? client : this.pool).query(...sql_syntax_1.sqls`SELECT ${this.selectFields("Parents", fields)} 
+            FROM ${tbl} AS Parents, ${tbl} AS Children
+            WHERE Children.left BETWEEN Parents.left AND Parents.right 
+            AND Parents.left = (
+                SELECT MAX(S.left) FROM ${tbl} AS S
+                WHERE S.left < Children.left AND S.right > Children.right
+            ) 
+            AND Children.id = ${childNodeId}
+            ${authConditions.isEmpty ?
+      sql_syntax_1.default.empty :
+      sql_syntax_1.sqls` AND ${authConditions}`}`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return tsmonad_1.Maybe.nothing();
+      return tsmonad_1.Maybe.just(result.rows[0]);
+    });
+  }
+  /**
+     * Get all nodes at level n from top
+     * e.g. get all nodes at level 3:
+     * this.getAllNodesAtLevel(3)
+     * Root node is at level 1
      *
-     * @static
-     * @memberOf _
-     * @type {string}
+     * @param {number} level
+     * @returns {Promise<NodeRecord[]>}
+     * @memberof NestedSetModelQueryer
      */
-    lodash.VERSION = VERSION;
+  getAllNodesAtLevel(level, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "t2" });
+
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const result = yield this.pool.query(...sql_syntax_1.sqls`SELECT ${this.selectFields("t2")}
+            FROM ${tbl} AS t1, ${tbl} AS t2
+            WHERE t2.left BETWEEN t1.left AND t1.right
+            ${authConditions.isEmpty ?
+      sql_syntax_1.default.empty :
+      sql_syntax_1.sqls` AND ${authConditions}`}
+            GROUP BY t2.id 
+            HAVING COUNT(t1.id) = ${level}`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return [];
+      return result.rows;
+    });
+  }
+  /**
+     * Get level no. of a given node
+     * Starts from 1. i.e. The root node is 1
+     *
+     * @param {string} nodeId
+     * @returns {Promise<number>}
+     * @throws NodeNotFoundError If the node can't be found in the tree
+     * @memberof NestedSetModelQueryer
+     */
+  getLevelOfNode(nodeId, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "parents" });
+
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const result = yield this.pool.query(...sql_syntax_1.sqls`SELECT COUNT(Parents.id) AS level 
+            FROM ${tbl} AS Parents, ${tbl} AS Children
+            WHERE Children.left BETWEEN Parents.left AND Parents.right AND Children.id = ${nodeId}
+            ${authConditions.isEmpty ?
+      sql_syntax_1.default.empty :
+      sql_syntax_1.sqls` AND ${authConditions}`}`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      throw new NodeNotFoundError();
+      const level = parseInt(result.rows[0]["level"]);
+      if (!lodash_1.default.isNumber(level) || lodash_1.default.isNaN(level) || level < 1)
+      throw new Error(`Could find a valid level for node ${nodeId}: ${level}`);
+      return level;
+    });
+  }
+  /**
+     * Get total height (no. of the levels) of the tree
+     * Starts with 1 level.
+     *
+     * @returns {Promise<number>}
+     * @throws NodeNotFoundError If the root node can't be found in the tree
+     * @memberof NestedSetModelQueryer
+     */
+  getTreeHeight(authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "t1" });
+
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const result = yield this.pool.query(...sql_syntax_1.sqls`SELECT MAX(level) AS height 
+             FROM(
+                SELECT COUNT(t1.id)
+                FROM ${tbl} AS t1, ${tbl} AS t2
+                WHERE t2.left BETWEEN t1.left AND t1.right 
+                ${authConditions.isEmpty ?
+      sql_syntax_1.default.empty :
+      sql_syntax_1.sqls` AND ${authConditions}`}
+                GROUP BY t2.id 
+             ) AS L(level)`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      throw new NodeNotFoundError();
+      const height = parseInt(result.rows[0]["height"]);
+      if (!lodash_1.default.isNumber(height) || lodash_1.default.isNaN(height) || height < 0)
+      throw new Error(`Invalid height for tree: ${height}`);
+      return height;
+    });
+  }
+  /**
+     * Get left most immediate child of a node
+     *
+     * @param {string} parentNodeId
+     * @returns {Promise<Maybe<NodeRecord>>}
+     * @memberof NestedSetModelQueryer
+     */
+  getLeftMostImmediateChild(parentNodeId, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "children" });
+
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const result = yield this.pool.query(...sql_syntax_1.sqls`SELECT ${this.selectFields("Children")}
+            FROM ${tbl} AS Parents, ${tbl} AS Children 
+            WHERE Children.left = Parents.left + 1 AND Parents.id = ${parentNodeId}
+            ${authConditions.isEmpty ?
+      sql_syntax_1.default.empty :
+      sql_syntax_1.sqls` AND ${authConditions}`}`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return tsmonad_1.Maybe.nothing();
+      return tsmonad_1.Maybe.just(result.rows[0]);
+    });
+  }
+  /**
+     * Get right most immediate child of a node
+     *
+     * @param {string} parentNodeId
+     * @returns {Promise<Maybe<NodeRecord>>}
+     * @memberof NestedSetModelQueryer
+     */
+  getRightMostImmediateChild(parentNodeId, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "children" });
+
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const result = yield this.pool.query(...sql_syntax_1.sqls`SELECT ${this.selectFields("Children")}
+            FROM ${tbl} AS Parents, ${tbl} AS Children 
+            WHERE Children.right = Parents.right - 1 AND Parents.id = ${parentNodeId}
+            ${authConditions.isEmpty ?
+      sql_syntax_1.default.empty :
+      sql_syntax_1.sqls` AND ${authConditions}`}`.toQuery());
+      if (!result || !result.rows || !result.rows.length)
+      return tsmonad_1.Maybe.nothing();
+      return tsmonad_1.Maybe.just(result.rows[0]);
+    });
+  }
+  /**
+     * Get all nodes on the top to down path between the `higherNode` to the `lowerNode`
+     * Sort from higher level nodes to lower level node.
+     * Result will include `higherNode` and the `lowerNode`.
+     * If `higherNode` and the `lowerNode` is the same node, an array contains the single node will be return.
+     * If a path doesn't exist, empty array (`[]`) will be returned
+     * If you pass a lower node to the `higherNodeId` and a higher node to `lowerNodeId`, empty array will be returned
+     *
+     * @param {string} higherNodeId
+     * @param {string} lowerNodeId
+     * @returns {Promise<Maybe<NodeRecord[]>}
+     * @memberof NestedSetModelQueryer
+     */
+  getTopDownPathBetween(higherNodeId, lowerNodeId, authDecision = AuthDecision_1.UnconditionalTrueDecision) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+      const authConditions = authDecision.toSql({
+        prefixes: ["input.authObject.orgUnit"],
+        tableRef: "t2" });
+
+      const tbl = SQLUtils_1.escapeIdentifier(this.tableName);
+      const result = yield this.pool.query(...sql_syntax_1.sqls`SELECT ${this.selectFields("t2")}
+            FROM ${tbl} AS t1, ${tbl} AS t2, ${tbl} AS t3 
+            WHERE t1.id = ${higherNodeId} AND t3.id = ${lowerNodeId}
+            AND t2.left BETWEEN t1.left AND t1.right 
+            AND t3.left BETWEEN t2.left AND t2.right
+            ${authConditions.isEmpty ?
+      sql_syntax_1.default.empty :
+      sql_syntax_1.sqls` AND ${authConditions}`}
+            ORDER BY (t2.right-t2.left) DESC`.toQuery());
+      if (!((_a = result === null || result === void 0 ? void 0 : result.rows) === null || _a === void 0 ? void 0 : _a.length)) {
+        return [];
+      } else
+      {
+        return result.rows;
+      }
+    });
+  }
+  /**
+     * Compare the relative position of the two nodes
+     * If node1 is superior to node2, return "ancestor"
+     * if node1 is the subordinate of node2, return "descendant"
+     * If node1 = node2 return "equal"
+     * If there is no path can be found between Node1 and Node2 return "unrelated"
+     *
+     * @param {string} node1Id
+     * @param {string} node2Id
+     * @param {pg.Client} [client=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
+     * @returns {Promise<CompareNodeResult>}
+     * @memberof NestedSetModelQueryer
+     */
+  compareNodes(node1Id, node2Id, client = null) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const tbl = this.tableName;
+      const result = yield (client ? client : this.pool).query(`SELECT (
+                CASE
+                    WHEN CAST($1 AS varchar) = CAST($2 AS varchar)
+                    THEN 0
+                    WHEN t1.left BETWEEN t2.left AND t2.right 
+                    THEN -1
+                    WHEN t2.left BETWEEN t1.left AND t1.right 
+                    THEN 1
+                    ELSE null 
+                END
+            ) AS "result"
+            FROM "${tbl}" AS t1, "${tbl}" AS t2
+            WHERE t1.id = CAST($1 AS uuid) AND t2.id = CAST($2 AS uuid)`, [node1Id, node2Id]);
+      if (!result || !result.rows || !result.rows.length)
+      return "unrelated";
+      const comparisonResult = result.rows[0]["result"];
+      if (typeof comparisonResult === "number") {
+        switch (comparisonResult) {
+          case 1:
+            return "ancestor";
+          case -1:
+            return "descendant";
+          case 0:
+            return "equal";}
 
-    // Assign default placeholders.
-    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
-      lodash[methodName].placeholder = lodash;
+      }
+      return "unrelated";
     });
-
-    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
-    arrayEach(['drop', 'take'], function(methodName, index) {
-      LazyWrapper.prototype[methodName] = function(n) {
-        n = n === undefined ? 1 : nativeMax(toInteger(n), 0);
-
-        var result = (this.__filtered__ && !index)
-          ? new LazyWrapper(this)
-          : this.clone();
-
-        if (result.__filtered__) {
-          result.__takeCount__ = nativeMin(n, result.__takeCount__);
-        } else {
-          result.__views__.push({
-            'size': nativeMin(n, MAX_ARRAY_LENGTH),
-            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
-          });
+  }
+  getInsertFields(insertFieldList = null) {
+    const fieldList = isNonEmptyArray(insertFieldList) ?
+    insertFieldList :
+    this.defaultInsertFieldList;
+    if (!isNonEmptyArray(fieldList)) {
+      throw new Error("Insert fields must be an non-empty array!");
+    }
+    return fieldList;
+  }
+  getNodesInsertSql(nodes, sqlValues, insertFieldList = null, tableAliasOrName = "") {
+    if (!isNonEmptyArray(nodes)) {
+      throw new Error("`sqlValues` parameter should be an non-empty array!");
+    }
+    if (!lodash_1.default.isArray(sqlValues)) {
+      throw new Error("`sqlValues` parameter should be an array!");
+    }
+    if (!isValidSqlIdentifier(tableAliasOrName)) {
+      throw new Error(`tableAliasOrName: ${tableAliasOrName} contains invalid characters!`);
+    }
+    const tbl = this.tableName;
+    const fieldList = this.getInsertFields(insertFieldList);
+    const columnsList = fieldList.
+    map(f => {
+      if (!isValidSqlIdentifier(f)) {
+        throw new Error(`column name: ${f} contains invalid characters!`);
+      }
+      return tableAliasOrName == "" ?
+      `"${f}"` :
+      `${tableAliasOrName}."${f}"`;
+    }).
+    join(", ");
+    const valuesList = nodes.
+    map(node => "(" +
+    fieldList.
+    map(f => {
+      sqlValues.push(node[f]);
+      return `$${sqlValues.length}`;
+    }).
+    join(", ") +
+    ")").
+    join(", ");
+    return `INSERT INTO "${tbl}" (${columnsList}) VALUES ${valuesList}`;
+  }
+  /**
+     * Create the root node of the tree.
+     * If a root node already exists, an error will be thrown.
+     *
+     * @param {NodeRecord} node
+     * @param {pg.Client} [existingClient=null] Optional pg client; Use supplied client connection for query rather than a random connection from Pool
+     * @returns {Promise<string>} newly created node ID
+     * @memberof NestedSetModelQueryer
+     */
+  createRootNode(node, existingClient = null) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const tbl = this.tableName;
+      const client = existingClient ?
+      existingClient :
+      yield this.pool.connect();
+      const fields = Object.keys(node);
+      if (!fields.length) {
+        throw new Error("`node` parameter cannot be an empty object with no key.");
+      }
+      let nodeId;
+      try {
+        yield client.query("BEGIN");
+        let result = yield client.query(`SELECT "id" FROM "${tbl}" WHERE "left" = 1 LIMIT 1`);
+        if (result && isNonEmptyArray(result.rows)) {
+          throw new Error(`A root node with id: ${result.rows[0]["id"]} already exists`);
         }
-        return result;
-      };
-
-      LazyWrapper.prototype[methodName + 'Right'] = function(n) {
-        return this.reverse()[methodName](n).reverse();
-      };
-    });
-
-    // Add `LazyWrapper` methods that accept an `iteratee` value.
-    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
-      var type = index + 1,
-          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
-
-      LazyWrapper.prototype[methodName] = function(iteratee) {
-        var result = this.clone();
-        result.__iteratees__.push({
-          'iteratee': getIteratee(iteratee, 3),
-          'type': type
-        });
-        result.__filtered__ = result.__filtered__ || isFilter;
-        return result;
-      };
-    });
-
-    // Add `LazyWrapper` methods for `_.head` and `_.last`.
-    arrayEach(['head', 'last'], function(methodName, index) {
-      var takeName = 'take' + (index ? 'Right' : '');
-
-      LazyWrapper.prototype[methodName] = function() {
-        return this[takeName](1).value()[0];
-      };
+        const countResult = yield client.query(`SELECT COUNT("id") AS "num" FROM "${tbl}" WHERE "left" != 1`);
+        let countNum = countResult && countResult.rows && countResult.rows.length ?
+        parseInt(countResult.rows[0].num) :
+        0;
+        countNum = isNaN(countNum) ? 0 : countNum;
+        const right = countNum ? (countNum + 1) * 2 : 2;
+        const sqlValues = [];
+        result = yield client.query(this.getNodesInsertSql([
+        Object.assign(Object.assign({}, node), { left: 1, right })],
+        sqlValues, fields.concat(["left", "right"])) + " RETURNING id", sqlValues);
+        if (!result || !isNonEmptyArray(result.rows)) {
+          throw new Error("Cannot locate create root node ID!");
+        }
+        yield client.query("COMMIT");
+        nodeId = result.rows[0]["id"];
+      }
+      catch (e) {
+        yield client.query("ROLLBACK");
+        throw e;
+      } finally
+      {
+        if (!existingClient) {
+          client.release();
+        }
+      }
+      return nodeId;
     });
+  }
+  getNodeDataWithinTx(client, nodeId, fields) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const node = yield this.getNodeById(nodeId, fields, client);
+      return node.caseOf({
+        just: node => node,
+        nothing: () => {
+          throw new NodeNotFoundError(`Cannot locate tree node record with id: ${nodeId}`);
+        } });
 
-    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
-    arrayEach(['initial', 'tail'], function(methodName, index) {
-      var dropName = 'drop' + (index ? '' : 'Right');
-
-      LazyWrapper.prototype[methodName] = function() {
-        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
-      };
     });
-
-    LazyWrapper.prototype.compact = function() {
-      return this.filter(identity);
-    };
-
-    LazyWrapper.prototype.find = function(predicate) {
-      return this.filter(predicate).head();
-    };
-
-    LazyWrapper.prototype.findLast = function(predicate) {
-      return this.reverse().find(predicate);
-    };
-
-    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
-      if (typeof path == 'function') {
-        return new LazyWrapper(this);
+  }
+  /**
+     * Insert a node to the tree under a parent node
+     *
+     * @param {string} parentNodeId
+     * @param {NodeRecord} node
+     * @returns {Promise<string>}
+     * @throws NodeNotFoundError if parent node not found
+     * @memberof NestedSetModelQueryer
+     */
+  insertNode(parentNodeId, node) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!parentNodeId) {
+        throw new Error("`parentNodeId` cannot be empty!");
       }
-      return this.map(function(value) {
-        return baseInvoke(value, path, args);
-      });
+      const fields = Object.keys(node);
+      if (!fields.length) {
+        throw new Error("`node` parameter cannot be an empty object with no key.");
+      }
+      const tbl = this.tableName;
+      const client = yield this.pool.connect();
+      let nodeId;
+      try {
+        yield client.query("BEGIN");
+        const { right: parentRight } = yield this.getNodeDataWithinTx(client, parentNodeId, ["right"]);
+        yield client.query(`UPDATE "${tbl}" 
+                SET 
+                    "left" = CASE WHEN "left" > $1 THEN "left" + 2 ELSE "left" END,
+                    "right" = CASE WHEN "right" >= $1 THEN "right" + 2 ELSE "right" END
+                WHERE "right" >= $1`, [parentRight]);
+        const sqlValues = [];
+        const result = yield client.query(this.getNodesInsertSql([
+        Object.assign(Object.assign({}, node), { left: parentRight, right: parentRight + 1 })],
+        sqlValues, fields.concat(["left", "right"])) + " RETURNING id", sqlValues);
+        if (!result || !isNonEmptyArray(result.rows)) {
+          throw new Error("Cannot locate created node ID!");
+        }
+        yield client.query("COMMIT");
+        nodeId = result.rows[0]["id"];
+      }
+      catch (e) {
+        yield client.query("ROLLBACK");
+        throw e;
+      } finally
+      {
+        client.release();
+      }
+      return nodeId;
     });
+  }
+  /**
+     * Insert a node to the right of its sibling
+     * If `siblingNodeId` belongs to a root node, an error will be thrown
+     *
+     * @param {string} siblingNodeId
+     * @param {NodeRecord} node
+     * @returns {Promise<string>}
+     * @throws NodeNotFoundError If the node can't be found in the tree
+     * @memberof NestedSetModelQueryer
+     */
+  insertNodeToRightOfSibling(siblingNodeId, node) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!siblingNodeId) {
+        throw new Error("`siblingNodeId` cannot be empty!");
+      }
+      const fields = Object.keys(node);
+      if (!fields.length) {
+        throw new Error("`node` parameter cannot be an empty object with no key.");
+      }
+      const tbl = this.tableName;
+      const client = yield this.pool.connect();
+      let nodeId;
+      try {
+        yield client.query("BEGIN");
+        const { left: siblingLeft, right: siblingRight } = yield this.getNodeDataWithinTx(client, siblingNodeId, [
+        "left",
+        "right"]);
 
-    LazyWrapper.prototype.reject = function(predicate) {
-      return this.filter(negate(getIteratee(predicate)));
-    };
-
-    LazyWrapper.prototype.slice = function(start, end) {
-      start = toInteger(start);
-
-      var result = this;
-      if (result.__filtered__ && (start > 0 || end < 0)) {
-        return new LazyWrapper(result);
+        if (siblingLeft === 1) {
+          throw new Error("Cannot add sibling to the Root node!");
+        }
+        yield client.query(`UPDATE "${tbl}" 
+                SET 
+                    "left" = CASE WHEN "left" < $1 THEN "left" ELSE "left" + 2 END,
+                    "right" = CASE WHEN "right" < $1 THEN "right" ELSE "right" + 2 END
+                WHERE "right" > $1`, [siblingRight]);
+        const sqlValues = [];
+        const result = yield client.query(this.getNodesInsertSql([
+        Object.assign(Object.assign({}, node), { left: siblingRight + 1, right: siblingRight + 2 })],
+        sqlValues, fields.concat(["left", "right"])) + " RETURNING id", sqlValues);
+        if (!result || !isNonEmptyArray(result.rows)) {
+          throw new Error("Cannot locate created node ID!");
+        }
+        yield client.query("COMMIT");
+        nodeId = result.rows[0]["id"];
       }
-      if (start < 0) {
-        result = result.takeRight(-start);
-      } else if (start) {
-        result = result.drop(start);
+      catch (e) {
+        yield client.query("ROLLBACK");
+        throw e;
+      } finally
+      {
+        client.release();
       }
-      if (end !== undefined) {
-        end = toInteger(end);
-        result = end < 0 ? result.dropRight(-end) : result.take(end - start);
+      return nodeId;
+    });
+  }
+  /**
+     * Move a subtree (the specified root node and all its subordinates)
+     * to under a new parent.
+     *
+     * If the specifed sub tree root node is a child of the new parent node,
+     * an error will be be thrown
+     *
+     * @param {string} subTreeRootNodeId
+     * @param {string} newParentId
+     * @returns {Promise<void>}
+     * @throws NodeNotFoundError If the node can't be found in the tree
+     * @memberof NestedSetModelQueryer
+     */
+  moveSubTreeTo(subTreeRootNodeId, newParentId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!subTreeRootNodeId) {
+        throw new Error("`subTreeRootNodeId` cannot be empty!");
       }
-      return result;
-    };
-
-    LazyWrapper.prototype.takeRightWhile = function(predicate) {
-      return this.reverse().takeWhile(predicate).reverse();
-    };
-
-    LazyWrapper.prototype.toArray = function() {
-      return this.take(MAX_ARRAY_LENGTH);
-    };
-
-    // Add `LazyWrapper` methods to `lodash.prototype`.
-    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
-      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
-          isTaker = /^(?:head|last)$/.test(methodName),
-          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
-          retUnwrapped = isTaker || /^find/.test(methodName);
-
-      if (!lodashFunc) {
-        return;
+      if (!newParentId) {
+        throw new Error("`newParentId` cannot be empty!");
       }
-      lodash.prototype[methodName] = function() {
-        var value = this.__wrapped__,
-            args = isTaker ? [1] : arguments,
-            isLazy = value instanceof LazyWrapper,
-            iteratee = args[0],
-            useLazy = isLazy || isArray(value);
-
-        var interceptor = function(value) {
-          var result = lodashFunc.apply(lodash, arrayPush([value], args));
-          return (isTaker && chainAll) ? result[0] : result;
-        };
-
-        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
-          // Avoid lazy use if the iteratee has a "length" value other than `1`.
-          isLazy = useLazy = false;
+      const tbl = this.tableName;
+      const client = yield this.pool.connect();
+      try {
+        yield client.query("BEGIN");
+        const comparisonResult = yield this.compareNodes(subTreeRootNodeId, newParentId, client);
+        if (comparisonResult === "ancestor") {
+          throw new Error(`Cannot move a higher level node (id: ${subTreeRootNodeId})to its subordinate (id: ${newParentId})`);
         }
-        var chainAll = this.__chain__,
-            isHybrid = !!this.__actions__.length,
-            isUnwrapped = retUnwrapped && !chainAll,
-            onlyLazy = isLazy && !isHybrid;
+        const { left: originRootLeft, right: originRootRight } = yield this.getNodeDataWithinTx(client, subTreeRootNodeId, [
+        "left",
+        "right"]);
 
-        if (!retUnwrapped && useLazy) {
-          value = onlyLazy ? value : new LazyWrapper(this);
-          var result = func.apply(value, args);
-          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });
-          return new LodashWrapper(result, chainAll);
-        }
-        if (isUnwrapped && onlyLazy) {
-          return func.apply(this, args);
+        if (originRootLeft === "1") {
+          throw new Error("Cannot move Tree root node as substree.");
         }
-        result = this.thru(interceptor);
-        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
-      };
+        const { right: newParentRight } = yield this.getNodeDataWithinTx(client, newParentId, ["right"]);
+        yield client.query(`
+            UPDATE "${tbl}" 
+            SET 
+            "left" = "left" + CASE
+                WHEN $3::int4 < $1::int4
+                THEN CASE 
+                    WHEN "left" BETWEEN $1 AND $2
+                    THEN $3 - $1
+                    WHEN "left" BETWEEN $3 AND ($1 - 1)
+                    THEN $2 - $1 + 1
+                    ELSE 0 END
+                WHEN $3::int4 > $2::int4
+                THEN CASE
+                    WHEN "left" BETWEEN $1 AND $2
+                    THEN $3 - $2 - 1
+                    WHEN "left" BETWEEN ($2 + 1) AND ($3 - 1)
+                    THEN $1 - $2 - 1
+                    ELSE 0 END
+                ELSE 0 END,
+            "right" = "right" + CASE
+                WHEN $3::int4 < $1::int4
+                THEN CASE 
+                    WHEN "right" BETWEEN $1 AND $2
+                    THEN $3 - $1
+                    WHEN "right" BETWEEN $3 AND ($1 - 1)
+                    THEN $2 - $1 + 1
+                    ELSE 0 END
+                WHEN $3::int4 > $2::int4
+                THEN CASE
+                    WHEN "right" BETWEEN $1 AND $2
+                    THEN $3 - $2 - 1
+                    WHEN "right" BETWEEN ($2 + 1) AND ($3 - 1)
+                    THEN $1 - $2 - 1
+                    ELSE 0 END
+                ELSE 0 END
+            `, [originRootLeft, originRootRight, newParentRight]);
+        yield client.query("COMMIT");
+      }
+      catch (e) {
+        yield client.query("ROLLBACK");
+        throw e;
+      } finally
+      {
+        client.release();
+      }
     });
+  }
+  /**
+     * Delete a subtree (and all its dependents)
+     * If you sent in a root node id (and `allowRootNodeId` is true), the whole tree will be removed
+     * When `allowRootNodeId` is false and you passed a root node id, an error will be thrown
+     *
+     * @param {string} subTreeRootNodeId
+     * @param {boolean} [allowRootNodeId=false]
+     * @returns {Promise<void>}
+     * @throws NodeNotFoundError If the node can't be found in the tree
+     * @memberof NestedSetModelQueryer
+     */
+  deleteSubTree(subTreeRootNodeId, allowRootNodeId = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!subTreeRootNodeId) {
+        throw new Error("`subTreeRootNodeId` cannot be empty!");
+      }
+      const tbl = this.tableName;
+      const client = yield this.pool.connect();
+      try {
+        yield client.query("BEGIN");
+        const { left: subTreeRootLeft, right: subTreeRootRight } = yield this.getNodeDataWithinTx(client, subTreeRootNodeId, [
+        "left",
+        "right"]);
 
-    // Add `Array` methods to `lodash.prototype`.
-    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {
-      var func = arrayProto[methodName],
-          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
-          retUnwrapped = /^(?:pop|shift)$/.test(methodName);
+        if (subTreeRootLeft === 1 && !allowRootNodeId) {
+          throw new Error("Root node id is not allowed!");
+        }
+        // --- delete the sub tree nodes
+        yield client.query(`DELETE FROM "${tbl}" WHERE "left" BETWEEN $1 AND $2`, [subTreeRootLeft, subTreeRootRight]);
+        // --- closing the gap after deletion
+        yield client.query(`
+                UPDATE "${tbl}"
+                SET "left" = CASE
+                        WHEN "left" > $1
+                            THEN "left" - ($2 - $1 + 1)
+                        ELSE "left" END, 
+                    "right" = CASE
+                        WHEN "right" > $1
+                            THEN "right" - ($2 - $1 + 1) 
+                        ELSE "right" END
+                WHERE "left" > $1 OR "right" > $1
+                `, [subTreeRootLeft, subTreeRootRight]);
+        yield client.query("COMMIT");
+      }
+      catch (e) {
+        yield client.query("ROLLBACK");
+        throw e;
+      } finally
+      {
+        client.release();
+      }
+    });
+  }
+  /**
+     * Delete a single node from the tree
+     * Its childrens will become its parent's children
+     * Deleting a root node is not allowed.
+     * You can, however, delete the whole sub tree from root node or update the root node, instead.
+     *
+     * @param {string} nodeId
+     * @returns {Promise<void>}
+     * @throws NodeNotFoundError If the node can't be found in the tree
+     * @memberof NestedSetModelQueryer
+     */
+  deleteNode(nodeId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!nodeId) {
+        throw new Error("`nodeId` cannot be empty!");
+      }
+      const tbl = this.tableName;
+      const client = yield this.pool.connect();
+      try {
+        yield client.query("BEGIN");
+        const { left: subTreeRootLeft, right: subTreeRootRight } = yield this.getNodeDataWithinTx(client, nodeId, [
+        "left",
+        "right"]);
 
-      lodash.prototype[methodName] = function() {
-        var args = arguments;
-        if (retUnwrapped && !this.__chain__) {
-          var value = this.value();
-          return func.apply(isArray(value) ? value : [], args);
+        if (subTreeRootLeft === 1) {
+          throw new Error("Delete a root node is not allowed!");
         }
-        return this[chainName](function(value) {
-          return func.apply(isArray(value) ? value : [], args);
-        });
-      };
+        // --- delete the node
+        // --- In nested set model, children are still bind to the deleted node's parent after deletion
+        yield client.query(`DELETE FROM "${tbl}" WHERE "id" = $1`, [
+        nodeId]);
+
+        // --- closing the gap after deletion
+        yield client.query(`
+                UPDATE "${tbl}"
+                SET "left" = CASE
+                        WHEN "left" > $1 AND "right" < $2
+                            THEN "left" - 1
+                        WHEN "left" > $1 AND "right" > $2
+                            THEN "left" - 2
+                        ELSE "left" END, 
+                    "right" = CASE
+                        WHEN "left" > $1 AND "right" < $2
+                            THEN "right" - 1
+                        ELSE ("right" - 2) END
+                WHERE "left" > $1 OR "right" > $1
+                `, [subTreeRootLeft, subTreeRootRight]);
+        yield client.query("COMMIT");
+      }
+      catch (e) {
+        yield client.query("ROLLBACK");
+        throw e;
+      } finally
+      {
+        client.release();
+      }
+    });
+  }
+  /**
+     * Update node data of the node specified by the nodeId
+     * The followings fields will be ignored (as they should be generated by program):
+     * - `left`
+     * - `right`
+     * - `id`
+     *
+     * @param {string} nodeId
+     * @param {NodeRecord} nodeData
+     * @param {pg.Client} [client=null]
+     * @returns {Promise<void>}
+     * @memberof NestedSetModelQueryer
+     */
+  updateNode(nodeId, nodeData, client = null) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (nodeId.trim() === "") {
+        throw new Error("nodeId can't be empty!");
+      }
+      const sqlValues = [nodeId];
+      const updateFields = Object.keys(nodeData).filter(k => k !== "left" && k !== "right" && k !== "id");
+      if (!updateFields.length) {
+        throw new Error("No valid node data passed for updating.");
+      }
+      const setFieldList = updateFields.
+      map(f => {
+        if (!isValidSqlIdentifier(f)) {
+          throw new Error(`field name: ${f} contains invalid characters!`);
+        }
+        sqlValues.push(nodeData[f]);
+        return `"${f}" = $${sqlValues.length}`;
+      }).
+      join(", ");
+      yield (client ? client : this.pool).query(`UPDATE "${this.tableName}" SET ${setFieldList} WHERE "id" = $1`, sqlValues);
     });
+  }
+  getChildTextTreeNodes(parentId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const nodes = yield this.getImmediateChildren(parentId);
+      if (!nodes || !nodes.length)
+      return [];
+      const textNodeList = [];
+      for (let i = 0; i < nodes.length; i++) {
+        const nodeChildren = yield this.getChildTextTreeNodes(nodes[i].id);
+        if (nodeChildren.length) {
+          textNodeList.push({
+            text: nodes[i].name,
+            children: nodeChildren });
 
-    // Map minified method names to their real names.
-    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
-      var lodashFunc = lodash[methodName];
-      if (lodashFunc) {
-        var key = lodashFunc.name + '';
-        if (!hasOwnProperty.call(realNames, key)) {
-          realNames[key] = [];
+        } else
+        {
+          textNodeList.push(nodes[i].name);
         }
-        realNames[key].push({ 'name': methodName, 'func': lodashFunc });
       }
+      return textNodeList;
     });
+  }
+  /**
+     * Generate the Text View of the tree
+     * Provided as Dev tool only
+     *
+     * E.g. output could be:
+     * └─ Albert
+     *      ├─ Chuck
+     *      │  ├─ Fred
+     *      │  ├─ Eddie
+     *      │  └─ Donna
+     *      └─ Bert
+     *
+     * @returns {Promise<string>}
+     * @memberof NestedSetModelQueryer
+     */
+  getTreeTextView() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const rootNodeMaybe = yield this.getRootNode();
+      return rootNodeMaybe.caseOf({
+        just: rootNode => __awaiter(this, void 0, void 0, function* () {
+          const tree = [];
+          const children = yield this.getChildTextTreeNodes(rootNode.id);
+          if (children.length) {
+            tree.push({
+              text: rootNode.name,
+              children });
 
-    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{
-      'name': 'wrapper',
-      'func': undefined
-    }];
-
-    // Add methods to `LazyWrapper`.
-    LazyWrapper.prototype.clone = lazyClone;
-    LazyWrapper.prototype.reverse = lazyReverse;
-    LazyWrapper.prototype.value = lazyValue;
-
-    // Add chain sequence methods to the `lodash` wrapper.
-    lodash.prototype.at = wrapperAt;
-    lodash.prototype.chain = wrapperChain;
-    lodash.prototype.commit = wrapperCommit;
-    lodash.prototype.next = wrapperNext;
-    lodash.prototype.plant = wrapperPlant;
-    lodash.prototype.reverse = wrapperReverse;
-    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
-
-    // Add lazy aliases.
-    lodash.prototype.first = lodash.prototype.head;
-
-    if (symIterator) {
-      lodash.prototype[symIterator] = wrapperToIterator;
-    }
-    return lodash;
-  });
-
-  /*--------------------------------------------------------------------------*/
-
-  // Export lodash.
-  var _ = runInContext();
-
-  // Some AMD build optimizers, like r.js, check for condition patterns like:
-  if (true) {
-    // Expose Lodash on the global object to prevent errors when Lodash is
-    // loaded by a script tag in the presence of an AMD loader.
-    // See http://requirejs.org/docs/errors.html#mismatch for more details.
-    // Use `_.noConflict` to remove Lodash from the global object.
-    root._ = _;
+          } else
+          {
+            tree.push(rootNode.name);
+          }
+          return textTree(tree);
+        }),
+        nothing: () => __awaiter(this, void 0, void 0, function* () {return "Empty Tree";}) });
 
-    // Define as an anonymous module so, through path mapping, it can be
-    // referenced as the "underscore" module.
-    !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
-      return _;
-    }).call(exports, __webpack_require__, exports, module),
-				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-  }
-  // Check for `exports` after `define` in case a build optimizer adds it.
-  else {}
-}.call(this));
+    });
+  }}
 
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(11)(module)))
+exports.default = NestedSetModelQueryer;
 
 /***/ }),
-/* 11 */
+/* 14 */
 /***/ (function(module, exports) {
 
 module.exports = function(module) {
@@ -18308,14 +19435,262 @@ module.exports = function(module) {
 
 
 /***/ }),
-/* 12 */
+/* 15 */
 /***/ (function(module, exports, __webpack_require__) {
 
 !function(t,n){if(true)module.exports=n();else { var i, e; }}(this,function(){return function(t){function n(i){if(e[i])return e[i].exports;var r=e[i]={exports:{},id:i,loaded:!1};return t[i].call(r.exports,r,r.exports,n),r.loaded=!0,r.exports}var e={};return n.m=t,n.c=e,n.p="",n(0)}([function(t,n,e){"use strict";function i(t){for(var e in t)n.hasOwnProperty(e)||(n[e]=t[e])}Object.defineProperty(n,"__esModule",{value:!0}),i(e(2)),i(e(3)),i(e(1)),i(e(4))},function(t,n){"use strict";function e(t,n){var i=0;if(t===n)return!0;if("function"==typeof t.equals)return t.equals(n);if(t.length>0&&t.length===n.length){for(;i<t.length;i+=1)if(!e(t[i],n[i]))return!1;return!0}return!1}Object.defineProperty(n,"__esModule",{value:!0}),n.eq=e},function(t,n,e){"use strict";function i(t){return null!==t&&void 0!==t}function r(t,n){if(i(t)&&i(n))throw new TypeError("Cannot construct an Either with both a left and a right");if(!i(t)&&!i(n))throw new TypeError("Cannot construct an Either with neither a left nor a right");return i(t)&&!i(n)?s.left(t):!i(t)&&i(n)?s.right(n):void 0}Object.defineProperty(n,"__esModule",{value:!0});var o,u=e(1);!function(t){t[t.Left=0]="Left",t[t.Right=1]="Right"}(o=n.EitherType||(n.EitherType={})),n.either=r;var s=function(){function t(t,n,e){this.type=t,this.l=n,this.r=e,this.of=this.unit,this.chain=this.bind,this.lift=this.fmap,this.map=this.fmap}return t.left=function(n){return new t(o.Left,n)},t.right=function(n){return new t(o.Right,null,n)},t.prototype.unit=function(n){return t.right(n)},t.prototype.bind=function(n){return this.type===o.Right?n(this.r):t.left(this.l)},t.prototype.fmap=function(t){var n=this;return this.bind(function(e){return n.unit(t(e))})},t.prototype.caseOf=function(t){return this.type===o.Right?t.right(this.r):t.left(this.l)},t.prototype.equals=function(t){return t.type===this.type&&(this.type===o.Left&&u.eq(t.l,this.l)||this.type===o.Right&&u.eq(t.r,this.r))},t.prototype["do"]=function(t){void 0===t&&(t={});var n={left:function(t){},right:function(t){}},e=Object.assign(n,t);return this.caseOf(e),this},t}();n.Either=s},function(t,n,e){"use strict";function i(t){return u.maybe(t)}Object.defineProperty(n,"__esModule",{value:!0});var r,o=e(1);!function(t){t[t.Nothing=0]="Nothing",t[t.Just=1]="Just"}(r=n.MaybeType||(n.MaybeType={})),n.maybe=i;var u=function(){function t(t,n){this.type=t,this.value=n,this.of=this.unit,this.chain=this.bind,this.lift=this.fmap,this.map=this.fmap}return t.sequence=function(n){if(Object.keys(n).filter(function(t){return n[t].type===r.Nothing}).length)return t.nothing();var e={};for(var i in n)n.hasOwnProperty(i)&&(e[i]=n[i].value);return t.just(e)},t.maybe=function(n){return null===n||void 0===n?new t(r.Nothing):new t(r.Just,n)},t.just=function(n){if(null===n||void 0===n)throw new TypeError("Cannot Maybe.just(null)");return new t(r.Just,n)},t.nothing=function(){return new t(r.Nothing)},t.prototype.unit=function(n){return t.maybe(n)},t.prototype.bind=function(n){return this.type===r.Just?n(this.value):t.nothing()},t.prototype.fmap=function(t){var n=this;return this.bind(function(e){return n.unit(t(e))})},t.prototype.caseOf=function(t){return this.type===r.Just?t.just(this.value):t.nothing()},t.prototype.defaulting=function(n){return t.just(this.valueOr(n))},t.prototype.equals=function(t){return t.type===this.type&&(this.type===r.Nothing||o.eq(t.value,this.value))},t.prototype.valueOr=function(t){return this.valueOrCompute(function(){return t})},t.prototype.valueOrCompute=function(t){return this.type===r.Just?this.value:t()},t.prototype.valueOrThrow=function(t){if(this.type===r.Just)return this.value;throw t||new Error("No value is available.")},t.prototype["do"]=function(t){void 0===t&&(t={});var n={just:function(t){},nothing:function(){}},e=Object.assign(n,t);return this.caseOf(e),this},t}();u.all=function(t){return u.sequence(t)},n.Maybe=u},function(t,n){"use strict";function e(t,n){return i.writer(t,n)}Object.defineProperty(n,"__esModule",{value:!0}),n.writer=e;var i=function(){function t(t,n){this.story=t,this.value=n,this.of=this.unit,this.chain=this.bind,this.lift=this.fmap,this.map=this.fmap}return t.writer=function(n,e){return new t(n,e)},t.tell=function(n){return new t([n],0)},t.prototype.unit=function(n){return new t([],n)},t.prototype.bind=function(n){var e=n(this.value),i=this.story.concat(e.story);return new t(i,e.value)},t.prototype.fmap=function(t){var n=this;return this.bind(function(e){return n.unit(t(e))})},t.prototype.caseOf=function(t){return t.writer(this.story,this.value)},t.prototype.equals=function(t){var n,e=!0;for(n=0;n<this.story.length;n+=1)e=e&&this.story[n]===t.story[n];return e&&this.value===t.value},t}();n.Writer=i}])});
 //# sourceMappingURL=tsmonad.js.map
 
 /***/ }),
-/* 13 */
+/* 16 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AspectQueryGroup = exports.AspectQueryValueInArray = exports.AspectQueryArrayNotEmpty = exports.AspectQueryWithValue = exports.AspectQueryExists = exports.AspectQueryFalse = exports.AspectQueryTrue = exports.AspectQuery = exports.AspectQueryValue = void 0;
+const sql_syntax_1 = __importStar(__webpack_require__(6));
+const SQLUtils_1 = __webpack_require__(10);
+class AspectQueryValue {
+    constructor(value) {
+        this.value = value;
+        switch (typeof value) {
+            case "number":
+                this.postgresType = sql_syntax_1.sqls `NUMERIC`;
+                break;
+            case "boolean":
+                this.postgresType = sql_syntax_1.sqls `BOOL`;
+                break;
+            case "string":
+                this.postgresType = sql_syntax_1.sqls `TEXT`;
+                break;
+            default:
+                throw new Error("getPostgresValueTypeCastStr: unsupported data type: `${" +
+                    typeof value +
+                    "}`");
+        }
+    }
+}
+exports.AspectQueryValue = AspectQueryValue;
+class AspectQuery {
+    constructor(aspectId, path = [], negated = false) {
+        this.aspectId = aspectId;
+        this.path = path;
+        this.negated = negated;
+    }
+    /**
+     * Public interface of all types of AspectQuery. Call this method to covert AspectQuery to SQL statement.
+     * Sub-class might choose to override this method to alter generic logic.
+     *
+     * @param {AspectQueryToSqlConfig} config
+     * @return {SQLSyntax}
+     * @memberof AspectQuery
+     */
+    toSql(config) {
+        if (!this.aspectId) {
+            throw new Error("Invalid AspectQuery: aspectId cannot be empty.");
+        }
+        const sqlQuery = this.sqlQueries(config);
+        if (this.negated) {
+            return sql_syntax_1.sqls `NOT ${sqlQuery}`;
+        }
+        else {
+            return sqlQuery;
+        }
+    }
+}
+exports.AspectQuery = AspectQuery;
+class AspectQueryTrue extends AspectQuery {
+    constructor() {
+        super(undefined);
+    }
+    sqlQueries(config) {
+        return sql_syntax_1.sqls `TRUE`;
+    }
+    // override default toSql as we don't need any validation logic
+    toSql(config) {
+        return this.sqlQueries(config);
+    }
+}
+exports.AspectQueryTrue = AspectQueryTrue;
+class AspectQueryFalse extends AspectQuery {
+    constructor() {
+        super(undefined);
+    }
+    sqlQueries(config) {
+        return sql_syntax_1.sqls `FALSE`;
+    }
+    // override default toSql as we don't need any validation logic
+    toSql(config) {
+        return this.sqlQueries(config);
+    }
+}
+exports.AspectQueryFalse = AspectQueryFalse;
+class AspectQueryExists extends AspectQuery {
+    sqlQueries(config) {
+        var _a;
+        const fieldRef = SQLUtils_1.getTableColumnName(this.aspectId, config.tableRef, config.useLowerCaseColumnName);
+        if ((_a = this.path) === null || _a === void 0 ? void 0 : _a.length) {
+            return sql_syntax_1.sqls `(${fieldRef} #> string_to_array(${this.path.join(",")}, ',')) IS NOT NULL`;
+        }
+        else {
+            return fieldRef.isNotNull();
+        }
+    }
+}
+exports.AspectQueryExists = AspectQueryExists;
+class AspectQueryWithValue extends AspectQuery {
+    constructor(value, operator, placeReferenceFirst, aspectId, path = [], negated = false) {
+        super(aspectId, path, negated);
+        this.value = value;
+        this.operator = operator;
+        this.placeReferenceFirst = placeReferenceFirst;
+    }
+    sqlQueries(config) {
+        var _a;
+        const fieldRef = SQLUtils_1.getTableColumnName(this.aspectId, config.tableRef, config.useLowerCaseColumnName);
+        const tableDataRef = !((_a = this.path) === null || _a === void 0 ? void 0 : _a.length)
+            ? sql_syntax_1.sqls `${fieldRef}::${this.value.postgresType}`
+            : sql_syntax_1.sqls `(${fieldRef} #>> string_to_array(${this.path.join(",")}, ','))::${this.value.postgresType}`;
+        return this.placeReferenceFirst
+            ? sql_syntax_1.sqls `COALESCE(${tableDataRef} ${this.operator} ${this.value.value}::${this.value.postgresType}, false)`
+            : sql_syntax_1.sqls `COALESCE(${this.value.value}::${this.value.postgresType} ${this.operator} ${tableDataRef}, false)`;
+    }
+}
+exports.AspectQueryWithValue = AspectQueryWithValue;
+class AspectQueryArrayNotEmpty extends AspectQuery {
+    sqlQueries(config) {
+        var _a;
+        const fieldRef = SQLUtils_1.getTableColumnName(this.aspectId, config.tableRef, config.useLowerCaseColumnName);
+        const tableDataRef = !((_a = this.path) === null || _a === void 0 ? void 0 : _a.length)
+            ? sql_syntax_1.sqls `(${fieldRef} #> string_to_array('0',','))`
+            : sql_syntax_1.sqls `(${fieldRef} #>> string_to_array(${[...this.path, "0"].join(",")}, ','))`;
+        return tableDataRef.isNotNull();
+    }
+}
+exports.AspectQueryArrayNotEmpty = AspectQueryArrayNotEmpty;
+class AspectQueryValueInArray extends AspectQuery {
+    constructor(value, aspectId, path = [], negated = false) {
+        super(aspectId, path, negated);
+        this.value = value;
+    }
+    sqlQueries(config) {
+        var _a;
+        const fieldRef = SQLUtils_1.getTableColumnName(this.aspectId, config.tableRef, config.useLowerCaseColumnName);
+        const tableDataRef = !((_a = this.path) === null || _a === void 0 ? void 0 : _a.length)
+            ? sql_syntax_1.sqls `COALESCE(
+                (
+                  (${fieldRef}::JSONB #> string_to_array('0',','))::JSONB
+                ) @> to_json(${this.value.value})::JSONB,
+                FALSE
+              )`
+            : sql_syntax_1.sqls `COALESCE(
+                (
+                  (${fieldRef}::JSONB #> string_to_array(${this.path.join(",")}, ','))::JSONB
+                ) @> to_json(${this.value.value})::JSONB,
+                FALSE
+              )`;
+        return tableDataRef;
+    }
+}
+exports.AspectQueryValueInArray = AspectQueryValueInArray;
+class AspectQueryGroup {
+    constructor(queries, joinWithAnd = true, negated = false) {
+        this.queries = queries;
+        this.joinWithAnd = joinWithAnd;
+        this.negated = negated;
+    }
+    toSql(config) {
+        var _a;
+        if (!((_a = this.queries) === null || _a === void 0 ? void 0 : _a.length)) {
+            return sql_syntax_1.default.empty;
+        }
+        let result;
+        if (this.joinWithAnd) {
+            if (this.queries.findIndex((item) => item instanceof AspectQueryFalse) !== -1) {
+                result = sql_syntax_1.sqls `FALSE`;
+            }
+            else {
+                result = sql_syntax_1.default.joinWithAnd(this.queries.map((q) => {
+                    if (q instanceof AspectQueryTrue) {
+                        return sql_syntax_1.default.empty;
+                    }
+                    else {
+                        return q.toSql(config);
+                    }
+                }));
+            }
+        }
+        else {
+            if (this.queries.findIndex((item) => item instanceof AspectQueryTrue) !== -1) {
+                result = sql_syntax_1.sqls `TRUE`;
+            }
+            else {
+                result = sql_syntax_1.default.joinWithOr(this.queries.map((q) => {
+                    if (q instanceof AspectQueryFalse) {
+                        return sql_syntax_1.default.empty;
+                    }
+                    else {
+                        return q.toSql(config);
+                    }
+                }));
+            }
+        }
+        if (this.negated) {
+            return sql_syntax_1.sqls `NOT ${result}`;
+        }
+        else {
+            return result;
+        }
+    }
+}
+exports.AspectQueryGroup = AspectQueryGroup;
+//# sourceMappingURL=AspectQuery.js.map
+
+/***/ }),
+/* 17 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+class ServerError extends Error {
+    constructor(message = "Unknown Error", statusCode = 500) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+    toData() {
+        return {
+            isError: true,
+            errorCode: this.statusCode,
+            errorMessage: this.message
+        };
+    }
+}
+exports.default = ServerError;
+//# sourceMappingURL=ServerError.js.map
+
+/***/ }),
+/* 18 */
 /***/ (function(module, exports) {
 
 module.exports = require("text-treeview");