taon-type-sql 21.0.22 → 21.0.23

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

@@ -0,0 +1,23 @@
+function convertSubstitutionParam(param) {
+  if (param == null) return "NULL";
+  if (typeof param === "string" || param instanceof String) {
+    return `'${String(param)}'`;
+  } else if (typeof param === "boolean" || param instanceof Boolean) {
+    return String(param).toUpperCase();
+  } else if (param instanceof Date) {
+    return `'${param.toISOString()}'`;
+  } else if (typeof param === "number" || param instanceof Number) {
+    return String(param);
+  }
+  return `'${JSON.stringify(param)}'`;
+}
+function convertEscapedParam(param) {
+  if (typeof param === "object" && !(param == null || param instanceof String || param instanceof Number || param instanceof Boolean || param instanceof Date)) {
+    return JSON.stringify(param);
+  }
+  return param;
+}
+export {
+  convertEscapedParam,
+  convertSubstitutionParam
+};

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

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

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

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

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

@@ -0,0 +1,77 @@
+function convertResult(query, result, engine) {
+  let rows = engine === "pg" ? result.rows : result;
+  let rowCount = engine === "pg" ? result.rowCount : result.affectedRows || result.changedRows;
+  if (query._action === "select") return convertSelectResult(query, rows);
+  if (query._action === "delete") return rowCount;
+  if (query._action === "update") return rowCount;
+  if (query._action === "insert") return convertInsertResult(result, engine);
+  throw new Error("Unknown query type:" + query._action);
+}
+function convertInsertResult(result, engine) {
+  if (engine === "mysql") return result.insertId > 0 ? result.insertId : void 0;
+  if (engine === "pg" && result.rows && result.rows.length === 1) {
+    let columnName = Object.keys(result.rows[0])[0];
+    return result.rows[0][columnName];
+  }
+}
+function convertSelectResult(query, rows) {
+  if (query._columns && query._columns.length === 1 && !(query._columns[0]._name === "*" && query._columns[0]._modifiers.length === 0)) {
+    if (rows.length == 0) return [];
+    let columnName = Object.keys(rows[0])[0];
+    let values = rows.map((row) => row[columnName]);
+    if (query._columns[0]._name === "*" && query._columns[0]._modifiers.some((m) => m.name === "count")) {
+      return values.map((value) => Number(value));
+    }
+    return values;
+  } else {
+    convertAliasFields(query, rows);
+    return rows;
+  }
+}
+function convertAliasFields(query, rows) {
+  let aliasByName = getColumnAliasesByName(query);
+  if (Object.keys(aliasByName).length === 0) return;
+  rows.forEach((row) => {
+    Object.keys(row).forEach((name) => {
+      if (aliasByName[name]) {
+        row[aliasByName[name]] = row[name];
+        delete row[name];
+      }
+    });
+  });
+}
+function getColumnAliasesByName(query) {
+  let aliasByName = {};
+  if (query._columns && query._columns.length > 0) {
+    query._columns.forEach((column) => {
+      if (column._name && column._name.alias && column._modifiers.length === 0) {
+        aliasByName[column._name.name] = column._name.alias;
+      } else if (column._name === "*" && column._modifiers.length === 0) {
+        getAliasColumnsOfTable(column._table).forEach((column2) => {
+          aliasByName[column2._name.name] = column2._name.alias;
+        });
+      }
+    });
+  } else {
+    let tables = query._table ? [query._table] : query._tables;
+    tables.forEach((table) => {
+      getAliasColumnsOfTable(table).forEach((column) => {
+        aliasByName[column._name.name] = column._name.alias;
+      });
+      let joinTable = table._parent;
+      while (joinTable) {
+        getAliasColumnsOfTable(joinTable).forEach((column) => {
+          aliasByName[column._name.name] = column._name.alias;
+        });
+        joinTable = joinTable._parent;
+      }
+    });
+  }
+  return aliasByName;
+}
+function getAliasColumnsOfTable(table) {
+  return Object.keys(table).map((key) => table[key]).filter((column) => column && column._name && column._name.alias);
+}
+export {
+  convertResult
+};

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

@@ -0,0 +1,8 @@
+import { createQueryConverter } from "./query-converter";
+import { convertSubstitutionParam } from "./param-converter";
+function convertQueryToSQL(query, options, engine) {
+  return createQueryConverter((param) => convertSubstitutionParam(param), options, engine)(query);
+}
+export {
+  convertQueryToSQL
+};

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

@@ -0,0 +1,32 @@
+function number(param) {
+  let result = Number(param);
+  if (Number.isNaN(result)) throw new Error("Invalid number parameter in SQL query: " + param);
+  return result;
+}
+function boolean(param) {
+  if (typeof param === "boolean") return param;
+  if (param instanceof Boolean) return param.valueOf();
+  if (param === "true") return true;
+  if (param === "false") return false;
+  throw new Error("Invalid boolean parameter in SQL query: " + param);
+}
+function date(param) {
+  if (param instanceof Date) return param;
+  if (typeof param === "number" || param instanceof Number) return new Date(param);
+  if (typeof param === "string" || param instanceof String) {
+    if (Number.isNaN(Date.parse(String(param)))) throw new Error("Invalid date parameter in SQL query: " + param);
+    return new Date(param);
+  }
+  throw new Error("Invalid date parameter in SQL query: " + param);
+}
+function string(param) {
+  if (typeof param === "string") return param;
+  if (param instanceof String) return param.valueOf();
+  throw new Error("Invalid string parameter in SQL query: " + param);
+}
+export {
+  boolean,
+  date,
+  number,
+  string
+};

package/lib-prod/env/env.angular-node-app.js

@@ -0,0 +1,130 @@
+const ENV_ANGULAR_NODE_APP_WEBSITE_DOMAIN = "taon-type-sql.example.domain.com";
+const ENV_ANGULAR_NODE_APP_WEBSITE_TITLE = "Taon Type Sql";
+const ENV_ANGULAR_NODE_APP_RELEASE_TARGET_ARTIFACT = "angular-node-app";
+const ENV_ANGULAR_NODE_APP_RELEASE_ENV_NAME = "__";
+const ENV_ANGULAR_NODE_APP_CONTAINER_ONLY = void 0;
+const ENV_ANGULAR_NODE_APP_CONTAINER_END = void 0;
+const ENV_ANGULAR_NODE_APP_CONTAINER_START = void 0;
+const ENV_ANGULAR_NODE_APP_CONTAINER_SKIP_RELEASED = void 0;
+const ENV_ANGULAR_NODE_APP_CONTAINER_SKIP = void 0;
+const ENV_ANGULAR_NODE_APP_INIT_BRANDING = void 0;
+const ENV_ANGULAR_NODE_APP_INIT_STRUCT = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_PWA_DISABLE_SERVICE_WORKER = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_PWA_NAME = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_PWA_SHORT_NAME = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_PWA_START_URL = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_ELECTRON_SHOW_DEV_TOOLS = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_SSR = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_WEBSQL = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_PROD = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_OVERRIDE_OUTPUT_PATH = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_BASE_HREF = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_WATCH = void 0;
+const ENV_ANGULAR_NODE_APP_BUILD_GEN_ONLY_CLIENT_CODE = void 0;
+const ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER = void 0;
+const ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_CLI_MINIFY = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_CLI_INCLUDE_NODE_MODULES = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_CLI_UGLIFY = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_CLI_OBSCURE = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_CLI_COMPRESS = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_NODE_BACKEND_APP_MINIFY = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_LIB_REMOVE_DTS = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_LIB_OBSCURE_FILE_BY_FILE = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_LIB_UGLIFY_FILE_BY_FILE = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_LIB_INCLUDE_SOURCE_MAPS = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_LIB_COMPRESS = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_RESOLVED_NEW_VERSION = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_RELEASE_VERSION_BUMP_TYPE = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_ENV_NUMBER = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_INSTALL_LOCALLY = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_RELEASE_TYPE = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_AUTO_RELEASE_USING_CONFIG = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_AUTO_RELEASE_TASK_NAME = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_TAON_INSTANCE_IP = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_SKIP_NPM_PUBLISH = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_SKIP_DEPLOY = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_SKIP_TAG_GIT_PUSH = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_SKIP_RELEASE_QUESTION = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_SKIP_RESOLVING_GIT_CHANGES = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_SKIP_CODE_CUTTING = void 0;
+const ENV_ANGULAR_NODE_APP_RELEASE_SKIP_BUILDING_ARTIFACTS = void 0;
+const ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_BEFORE_COPY_HOOK = void 0;
+const ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_COPY_TO_LOCATIONS = void 0;
+const ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_COPY_TO_PROJECTS = void 0;
+const ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_SKIP = void 0;
+const ENV_ANGULAR_NODE_APP_WEBSITE_USE_DOMAIN = void 0;
+const ENV_ANGULAR_NODE_APP_PURPOSE = void 0;
+const ENV_ANGULAR_NODE_APP_RECURSIVE_ACTION = void 0;
+const ENV_ANGULAR_NODE_APP_IS_CI_PROCESS = void 0;
+const ENV_ANGULAR_NODE_APP_DOCKER_ADDITIONAL_CONTAINER = void 0;
+const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_START_IN_ORDER = void 0;
+const ENV_ANGULAR_NODE_APP_DOCKER_SKIP_USING_MYSQL_DB = void 0;
+export {
+  ENV_ANGULAR_NODE_APP_BUILD_BASE_HREF,
+  ENV_ANGULAR_NODE_APP_BUILD_ELECTRON_SHOW_DEV_TOOLS,
+  ENV_ANGULAR_NODE_APP_BUILD_GEN_ONLY_CLIENT_CODE,
+  ENV_ANGULAR_NODE_APP_BUILD_OVERRIDE_OUTPUT_PATH,
+  ENV_ANGULAR_NODE_APP_BUILD_PROD,
+  ENV_ANGULAR_NODE_APP_BUILD_PWA_DISABLE_SERVICE_WORKER,
+  ENV_ANGULAR_NODE_APP_BUILD_PWA_NAME,
+  ENV_ANGULAR_NODE_APP_BUILD_PWA_SHORT_NAME,
+  ENV_ANGULAR_NODE_APP_BUILD_PWA_START_URL,
+  ENV_ANGULAR_NODE_APP_BUILD_SSR,
+  ENV_ANGULAR_NODE_APP_BUILD_WATCH,
+  ENV_ANGULAR_NODE_APP_BUILD_WEBSQL,
+  ENV_ANGULAR_NODE_APP_CONTAINER_END,
+  ENV_ANGULAR_NODE_APP_CONTAINER_ONLY,
+  ENV_ANGULAR_NODE_APP_CONTAINER_SKIP,
+  ENV_ANGULAR_NODE_APP_CONTAINER_SKIP_RELEASED,
+  ENV_ANGULAR_NODE_APP_CONTAINER_START,
+  ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_BEFORE_COPY_HOOK,
+  ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_COPY_TO_LOCATIONS,
+  ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_COPY_TO_PROJECTS,
+  ENV_ANGULAR_NODE_APP_COPY_TO_MANAGER_SKIP,
+  ENV_ANGULAR_NODE_APP_DOCKER_ADDITIONAL_CONTAINER,
+  ENV_ANGULAR_NODE_APP_DOCKER_SKIP_START_IN_ORDER,
+  ENV_ANGULAR_NODE_APP_DOCKER_SKIP_USING_MYSQL_DB,
+  ENV_ANGULAR_NODE_APP_INIT_BRANDING,
+  ENV_ANGULAR_NODE_APP_INIT_STRUCT,
+  ENV_ANGULAR_NODE_APP_IS_CI_PROCESS,
+  ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_BACKGROUND,
+  ENV_ANGULAR_NODE_APP_LOADING_PRE_ANGULAR_BOOTSTRAP_LOADER,
+  ENV_ANGULAR_NODE_APP_PURPOSE,
+  ENV_ANGULAR_NODE_APP_RECURSIVE_ACTION,
+  ENV_ANGULAR_NODE_APP_RELEASE_AUTO_RELEASE_TASK_NAME,
+  ENV_ANGULAR_NODE_APP_RELEASE_AUTO_RELEASE_USING_CONFIG,
+  ENV_ANGULAR_NODE_APP_RELEASE_CLI_COMPRESS,
+  ENV_ANGULAR_NODE_APP_RELEASE_CLI_INCLUDE_NODE_MODULES,
+  ENV_ANGULAR_NODE_APP_RELEASE_CLI_MINIFY,
+  ENV_ANGULAR_NODE_APP_RELEASE_CLI_OBSCURE,
+  ENV_ANGULAR_NODE_APP_RELEASE_CLI_UGLIFY,
+  ENV_ANGULAR_NODE_APP_RELEASE_ENV_NAME,
+  ENV_ANGULAR_NODE_APP_RELEASE_ENV_NUMBER,
+  ENV_ANGULAR_NODE_APP_RELEASE_INSTALL_LOCALLY,
+  ENV_ANGULAR_NODE_APP_RELEASE_LIB_COMPRESS,
+  ENV_ANGULAR_NODE_APP_RELEASE_LIB_DO_NOT_INCLUDE_LIB_FILES,
+  ENV_ANGULAR_NODE_APP_RELEASE_LIB_INCLUDE_SOURCE_MAPS,
+  ENV_ANGULAR_NODE_APP_RELEASE_LIB_OBSCURE_FILE_BY_FILE,
+  ENV_ANGULAR_NODE_APP_RELEASE_LIB_REMOVE_DTS,
+  ENV_ANGULAR_NODE_APP_RELEASE_LIB_UGLIFY_FILE_BY_FILE,
+  ENV_ANGULAR_NODE_APP_RELEASE_NODE_BACKEND_APP_MINIFY,
+  ENV_ANGULAR_NODE_APP_RELEASE_RELEASE_TYPE,
+  ENV_ANGULAR_NODE_APP_RELEASE_RELEASE_VERSION_BUMP_TYPE,
+  ENV_ANGULAR_NODE_APP_RELEASE_REMOVE_RELEASE_OUTPUT_AFTER_LOCAL_INSTALL,
+  ENV_ANGULAR_NODE_APP_RELEASE_RESOLVED_NEW_VERSION,
+  ENV_ANGULAR_NODE_APP_RELEASE_SKIP_BUILDING_ARTIFACTS,
+  ENV_ANGULAR_NODE_APP_RELEASE_SKIP_CODE_CUTTING,
+  ENV_ANGULAR_NODE_APP_RELEASE_SKIP_DEPLOY,
+  ENV_ANGULAR_NODE_APP_RELEASE_SKIP_NPM_PUBLISH,
+  ENV_ANGULAR_NODE_APP_RELEASE_SKIP_RELEASE_QUESTION,
+  ENV_ANGULAR_NODE_APP_RELEASE_SKIP_RESOLVING_GIT_CHANGES,
+  ENV_ANGULAR_NODE_APP_RELEASE_SKIP_TAG_GIT_PUSH,
+  ENV_ANGULAR_NODE_APP_RELEASE_TAON_INSTANCE_IP,
+  ENV_ANGULAR_NODE_APP_RELEASE_TARGET_ARTIFACT,
+  ENV_ANGULAR_NODE_APP_WEBSITE_DOMAIN,
+  ENV_ANGULAR_NODE_APP_WEBSITE_TITLE,
+  ENV_ANGULAR_NODE_APP_WEBSITE_USE_DOMAIN
+};