@aerokit/sdk 12.44.0

package/dist/cjs/db/dao.js

@@ -0,0 +1,795 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dao_exports = {};
+__export(dao_exports, {
+  DAO: () => DAO,
+  create: () => create,
+  dao: () => dao
+});
+module.exports = __toCommonJS(dao_exports);
+var import_orm = require("./orm");
+var import_ormstatements = require("./ormstatements");
+var import_sequence = require("./sequence");
+var import_database = require("./database");
+var import_db = require("@aerokit/sdk/db");
+var import_update = require("./update");
+var import_insert = require("./insert");
+var import_log = require("@aerokit/sdk/log");
+var import_core = require("@aerokit/sdk/core");
+function DAO(orm, logCtxName, dataSourceName) {
+  if (orm === void 0)
+    throw Error("Illegal argument: orm[" + orm + "]");
+  this.orm = (0, import_orm.get)(orm);
+  this.sequenceName = this.orm.table + "_" + this.orm.getPrimaryKey().name.toUpperCase();
+  this.dropIdGenerator = function() {
+    return import_sequence.Sequence.drop(this.sequenceName, dataSourceName);
+  };
+  this.generateId = function() {
+    return import_sequence.Sequence.nextval(this.sequenceName, this.orm.table, dataSourceName);
+  };
+  const conn = import_database.Database.getConnection(dataSourceName);
+  try {
+    this.ormstatements = (0, import_ormstatements.create)(this.orm, conn);
+  } finally {
+    conn.close();
+  }
+  let loggerName = logCtxName;
+  if (!loggerName) {
+    loggerName = "db.dao";
+    if (this.orm.table)
+      loggerName = "db.dao." + this.orm.table.toLowerCase();
+  }
+  this.$log = import_log.Logging.getLogger(loggerName);
+  this.execute = function(sqlBuilder, parameterBindings) {
+    const sql = sqlBuilder.build();
+    if (sql === void 0 || sql.length < 1)
+      throw Error("Illegal argument: sql from statement builder is invalid[" + sql + "]");
+    this.$log.trace("Executing SQL Statement: {}", sql);
+    const parameters = sqlBuilder.parameters && sqlBuilder.parameters();
+    const _parameterBindings = [];
+    if (parameterBindings?.$filter && parameters && parameters.length > 0) {
+      if (parameterBindings.$filter.equals) {
+        const propertiesKeys = Object.keys(parameterBindings.$filter.equals);
+        const addedPropertiesKeys = [];
+        parameters.forEach((e) => {
+          if (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {
+            const value = parameterBindings.$filter.equals[e.name];
+            if (Array.isArray(value)) {
+              value.forEach((v) => {
+                _parameterBindings.push({
+                  type: e.type,
+                  value: parseValue(e.type, v)
+                });
+              });
+            } else {
+              _parameterBindings.push({
+                type: e.type,
+                value: parseValue(e.type, value)
+              });
+            }
+            addedPropertiesKeys.push(e.name);
+          }
+        });
+      }
+      if (parameterBindings.$filter.notEquals) {
+        const propertiesKeys = Object.keys(parameterBindings.$filter.notEquals);
+        const addedPropertiesKeys = [];
+        parameters.forEach((e) => {
+          if (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {
+            const value = parameterBindings.$filter.notEquals[e.name];
+            if (Array.isArray(value)) {
+              value.forEach((v) => {
+                _parameterBindings.push({
+                  type: e.type,
+                  value: parseValue(e.type, v)
+                });
+              });
+            } else {
+              _parameterBindings.push({
+                type: e.type,
+                value: parseValue(e.type, value)
+              });
+            }
+            addedPropertiesKeys.push(e.name);
+          }
+        });
+      }
+      if (parameterBindings.$filter.contains) {
+        const propertiesKeys = Object.keys(parameterBindings.$filter.contains);
+        const addedPropertiesKeys = [];
+        parameters.forEach((e) => {
+          if (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {
+            _parameterBindings.push({
+              type: e.type,
+              value: `%${parameterBindings.$filter.contains[e.name]}%`
+            });
+            addedPropertiesKeys.push(e.name);
+          }
+        });
+      }
+      if (parameterBindings.$filter.greaterThan) {
+        const propertiesKeys = Object.keys(parameterBindings.$filter.greaterThan);
+        const addedPropertiesKeys = [];
+        parameters.forEach((e) => {
+          if (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {
+            _parameterBindings.push({
+              type: e.type,
+              value: parseValue(e.type, parameterBindings.$filter.greaterThan[e.name])
+            });
+            addedPropertiesKeys.push(e.name);
+          }
+        });
+      }
+      if (parameterBindings.$filter.lessThan) {
+        const propertiesKeys = Object.keys(parameterBindings.$filter.lessThan);
+        const addedPropertiesKeys = [];
+        parameters.forEach((e) => {
+          if (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {
+            _parameterBindings.push({
+              type: e.type,
+              value: parseValue(e.type, parameterBindings.$filter.lessThan[e.name])
+            });
+            addedPropertiesKeys.push(e.name);
+          }
+        });
+      }
+      if (parameterBindings.$filter.greaterThanOrEqual) {
+        const propertiesKeys = Object.keys(parameterBindings.$filter.greaterThanOrEqual);
+        const addedPropertiesKeys = [];
+        parameters.forEach((e) => {
+          if (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {
+            _parameterBindings.push({
+              type: e.type,
+              value: parseValue(e.type, parameterBindings.$filter.greaterThanOrEqual[e.name])
+            });
+            addedPropertiesKeys.push(e.name);
+          }
+        });
+      }
+      if (parameterBindings.$filter.lessThanOrEqual) {
+        const propertiesKeys = Object.keys(parameterBindings.$filter.lessThanOrEqual);
+        const addedPropertiesKeys = [];
+        parameters.forEach((e) => {
+          if (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {
+            _parameterBindings.push({
+              type: e.type,
+              value: parseValue(e.type, parameterBindings.$filter.lessThanOrEqual[e.name])
+            });
+            addedPropertiesKeys.push(e.name);
+          }
+        });
+      }
+    }
+    if (parameters && parameters.length > 0) {
+      for (var i = 0; i < parameters.length; i++) {
+        var val;
+        if (parameterBindings) {
+          if (Array.isArray(parameterBindings)) {
+            val = parameterBindings[i];
+          } else {
+            val = parameterBindings[parameters[i].name];
+          }
+        }
+        if ((val === null || val === void 0) && sql.toLowerCase().startsWith("select")) {
+          continue;
+        }
+        const index = i + 1;
+        this.$log.trace("Binding to parameter[{}]: {}", index, val);
+        _parameterBindings.push({
+          "type": parameters[i].type,
+          "value": parseValue(parameters[i].type, val)
+        });
+      }
+    }
+    let result;
+    if (sql.toLowerCase().startsWith("select")) {
+      result = import_db.Query.execute(sql, _parameterBindings, dataSourceName);
+    } else if (sql.toLowerCase().startsWith("insert")) {
+      result = import_insert.Insert.execute(sql, _parameterBindings, dataSourceName);
+    } else {
+      result = import_update.Update.execute(sql, _parameterBindings, dataSourceName);
+    }
+    return result !== null ? result : [];
+  };
+  function parseValue(type, value) {
+    switch (type.toUpperCase()) {
+      case "INTEGER":
+        return parseInt(value);
+      case "DOUBLE":
+      case "FLOAT":
+        return parseFloat(value);
+      case "BOOLEAN":
+        return value ? "true" : "false";
+      default:
+        return value;
+    }
+  }
+}
+;
+DAO.prototype.notify = function(event) {
+  const func = this[event];
+  if (!this[event])
+    return;
+  if (typeof func !== "function")
+    throw Error("Illegal argument. Not a function: " + func);
+  const args = [].slice.call(arguments);
+  func.apply(this, args.slice(1));
+};
+DAO.prototype.createSQLEntity = function(entity) {
+  let i;
+  const persistentItem = {};
+  const mandatories = this.orm.getMandatoryProperties();
+  for (i = 0; i < mandatories.length; i++) {
+    if (mandatories[i].dbValue) {
+      persistentItem[mandatories[i].name] = mandatories[i].dbValue.apply(this, [entity[mandatories[i].name], entity]);
+    } else {
+      persistentItem[mandatories[i].name] = entity[mandatories[i].name];
+    }
+  }
+  const optionals = this.orm.getOptionalProperties();
+  for (i = 0; i < optionals.length; i++) {
+    if (optionals[i].dbValue !== void 0) {
+      persistentItem[optionals[i].name] = optionals[i].dbValue.apply(this, [entity[optionals[i].name], entity]);
+    } else {
+      persistentItem[optionals[i].name] = entity[optionals[i].name] === void 0 ? null : entity[optionals[i].name];
+    }
+  }
+  return persistentItem;
+};
+DAO.prototype.createEntity = function(resultSetEntry, entityPropertyNames) {
+  const entity = {};
+  let properties = this.orm.properties;
+  if (entityPropertyNames && entityPropertyNames.length > 0) {
+    properties = properties.filter(function(prop) {
+      return entityPropertyNames.indexOf(prop.name) > -1;
+    });
+  }
+  for (let i = 0; i < properties.length; i++) {
+    const prop = properties[i];
+    entity[prop.name] = resultSetEntry[prop.columnName];
+    if (prop.value) {
+      entity[prop.name] = prop.value(entity[prop.name]);
+    }
+  }
+  Object.keys(entity).forEach(function(propertyName) {
+    if (entity[propertyName] === null)
+      entity[propertyName] = void 0;
+  });
+  let entitySegment = "";
+  if (entity[this.orm.getPrimaryKey().name]) {
+    entitySegment = "[" + entity[this.orm.getPrimaryKey().name] + "]";
+  }
+  return entity;
+};
+DAO.prototype.validateEntity = function(entity, skip) {
+  if (entity === void 0 || entity === null) {
+    throw new Error("Illegal argument: entity is " + entity);
+  }
+  if (skip) {
+    if (skip.constructor !== Array) {
+      skip = [skip];
+    }
+    for (var j = 0; j < skip.length; j++) {
+      skip[j];
+    }
+  }
+  const mandatories = this.orm.getMandatoryProperties();
+  for (let i = 0; i < mandatories.length; i++) {
+    const propName = mandatories[i].name;
+    if (skip && skip.indexOf(propName) > -1 || mandatories[i].type.toUpperCase() === "BOOLEAN")
+      continue;
+    const propValue = entity[propName];
+    if (propValue === void 0 || propValue === null) {
+      throw new Error("Illegal " + propName + " attribute value in " + this.orm.table + " entity: " + propValue);
+    }
+  }
+};
+DAO.prototype.insert = function(_entity) {
+  const ids = [];
+  let entities = _entity;
+  if (_entity.constructor !== Array) {
+    entities = [_entity];
+  }
+  this.$log.trace("Inserting {} {}", this.orm.table, entities.length === 1 ? "entity" : "entities");
+  for (let i = 0; i < entities.length; i++) {
+    let entity = entities[i];
+    entity = entities[i];
+    this.validateEntity(entity, [this.orm.getPrimaryKey().name]);
+    const uniques = this.orm.getUniqueProperties();
+    for (let _i = 0; _i < uniques.length; _i++) {
+      const prop = uniques[_i];
+      const st = this.ormstatements.dialect.select(prop.column).from(this.orm.table).where(prop.column + "=?", [prop]);
+      const params = {};
+      params[prop.name] = entity[prop.name];
+      const rs = this.execute(st, params);
+      if (rs.length > 0)
+        throw Error("Unique constraint violation for " + prop.name + "[" + entity[prop.name] + "]");
+    }
+    const dbEntity = this.createSQLEntity(entity);
+    try {
+      const parametericStatement = this.ormstatements.insert.apply(this.ormstatements);
+      if (this.orm.isAutoIncrementPrimaryKey()) {
+        const id = this.generateId();
+        dbEntity[this.orm.getPrimaryKey().name] = id;
+      }
+      const updatedRecordCount = this.execute(parametericStatement, dbEntity);
+      if (!this.orm.isAutoIncrementPrimaryKey() && isNotEmptyArray(updatedRecordCount)) {
+        const id = updatedRecordCount[0];
+        dbEntity[this.orm.getPrimaryKey().name] = id;
+      }
+      this.notify("afterInsert", dbEntity);
+      this.notify("beforeInsertAssociationSets", dbEntity);
+      if ((updatedRecordCount > 0 || isNotEmptyArray(updatedRecordCount)) && this.orm.associations && Object.keys(this.orm.associations).length) {
+        this.$log.trace("Inserting association sets for {}[{}]", this.orm.table, dbEntity[this.orm.getPrimaryKey().name]);
+        for (const idx in Object.keys(this.orm.associations)) {
+          const association = this.orm.associations[idx];
+          const associationName = association["name"];
+          if ([this.orm.ASSOCIATION_TYPES["MANY-TO-MANY"], this.orm.ASSOCIATION_TYPES["MANY-TO-ONE"]].indexOf(association.type) < 0) {
+            if (entity[associationName] && entity[associationName].length > 0) {
+              const associationDaoFactoryFunc = association.targetDao || this;
+              if (associationDaoFactoryFunc.constructor !== Function)
+                throw Error("Invalid ORM: Association " + associationName + " dao property is expected to be function. Instead, it is: " + typeof associationDaoFactoryFunc);
+              const associationDAO = associationDaoFactoryFunc.apply(this);
+              this.notify("beforeInsertAssociationSet", entity[associationName], entity);
+              this.$log.trace("Inserting {} inline entities into association set {}", entity[associationName].length, associationName);
+              for (let j = 0; j < entity[associationName].length; j++) {
+                const associatedEntity = entity[associationName][j];
+                const associatedEntityJoinKey = association.joinKey;
+                const key = association.key || this.orm.getPrimaryKey().name;
+                associatedEntity[associatedEntityJoinKey] = entity[key];
+                this.notify("beforeInsertAssociationSetEntity", entity[associationName], dbEntity);
+                associationDAO.insert.apply(associationDAO, [associatedEntity]);
+              }
+              this.$log.trace("Inserting {} inline entities into association set {} finsihed", entity[associationName].length, associationName);
+              this.notify("afterInsertAssociationSet", entity[associationName], dbEntity);
+            }
+          }
+        }
+      }
+      if (updatedRecordCount > 0 || isNotEmptyArray(updatedRecordCount)) {
+        ids.push(dbEntity[this.orm.getPrimaryKey().name]);
+        this.$log.trace("{}[] entity inserted", this.orm.table, dbEntity[this.orm.getPrimaryKey().name]);
+      } else {
+        this.$log.trace("No changes incurred in {}", this.orm.table);
+      }
+    } catch (e) {
+      this.$log.error("Inserting {} {} failed", this.orm.table, entities.length === 1 ? "entity" : "entities", e);
+      this.$log.trace("Rolling back changes after failed {}[{}] insert. ", this.orm.table, dbEntity[this.orm.getPrimaryKey().name]);
+      if (dbEntity[this.orm.getPrimaryKey().name]) {
+        try {
+          this.remove(dbEntity[this.orm.getPrimaryKey().name]);
+        } catch (err) {
+          this.$log.error("Could not rollback changes after failed {}[{}] insert. ", this.orm.table, dbEntity[this.orm.getPrimaryKey().name], err);
+        }
+      }
+      throw e;
+    }
+  }
+  if (_entity.constructor !== Array)
+    return ids[0];
+  else
+    return ids;
+};
+function isNotEmptyArray(array) {
+  return Array.isArray(array) && array.length > 0;
+}
+DAO.prototype.update = function(entity) {
+  this.$log.trace("Updating {}[{}] entity", this.orm.table, entity !== void 0 ? entity[this.orm.getPrimaryKey().name] : entity);
+  if (entity === void 0 || entity === null) {
+    throw new Error("Illegal argument: entity is " + entity);
+  }
+  const ignoredProperties = this.orm.getMandatoryProperties().filter(function(property) {
+    return property.allowedOps && property.allowedOps.indexOf("update") < 0;
+  }).map(function(property) {
+    return property.name;
+  });
+  this.validateEntity(entity, ignoredProperties);
+  const parametericStatement = this.ormstatements.update.apply(this.ormstatements, [entity]);
+  const dbEntity = this.createSQLEntity(entity);
+  try {
+    this.notify("beforeUpdateEntity", dbEntity);
+    const updatedRecordsCount = this.execute(parametericStatement, dbEntity);
+    if (updatedRecordsCount > 0)
+      this.$log.trace("{}[{}] entity updated", this.orm.table, dbEntity[this.orm.getPrimaryKey().name]);
+    else
+      this.$log.trace("No changes incurred in {}", this.orm.table);
+    return this;
+  } catch (e) {
+    this.$log.error("Updating {}[{}] failed", this.orm.table, entity !== void 0 ? entity[this.orm.getPrimaryKey().name] : entity, e);
+    throw e;
+  }
+};
+DAO.prototype.remove = function() {
+  let ids = [];
+  if (arguments.length === 0) {
+    ids = this.list({
+      "$select": [this.orm.getPrimaryKey().name]
+    }).map(function(ent) {
+      return ent[this.orm.getPrimaryKey().name];
+    }.bind(this));
+  } else {
+    if (arguments[0].constructor !== Array) {
+      ids = [arguments[0]];
+    } else {
+      ids = arguments[0];
+    }
+  }
+  this.$log.trace("Deleting " + this.orm.table + (ids !== void 0 && ids.length === 1 ? "[" + ids[0] + "] entity" : ids.length + " entities"));
+  for (let i = 0; i < ids.length; i++) {
+    let id = ids[i];
+    if (this.orm.getPrimaryKey().type.toUpperCase() !== "VARCHAR")
+      id = parseInt(id, 10);
+    if (ids.length > 1)
+      this.$log.trace("Deleting {}[{}] entity", this.orm.table, id);
+    if (id === void 0 || id === null) {
+      throw new Error("Illegal argument for id parameter:" + id);
+    }
+    try {
+      this.notify("beforeRemoveEntity", id);
+      if (this.orm.associations) {
+        for (const idx in Object.keys(this.orm.associations)) {
+          const association = this.orm.associations[idx];
+          const associationName = association["name"];
+          if ([this.orm.ASSOCIATION_TYPES["MANY-TO-MANY"], this.orm.ASSOCIATION_TYPES["MANY-TO-ONE"]].indexOf(association.type) < 0) {
+            this.$log.trace("Inspecting {}[{}}] entity's dependency '{}' for entities to delete.", this.orm.table, id, associationName);
+            const associationDAO = association.targetDao ? association.targetDao() : this;
+            const settings = {};
+            let joinId = id;
+            if (association.key !== void 0) {
+              var ctxEntity = this.find(id);
+              joinId = ctxEntity[association.key];
+            }
+            settings[association.joinKey] = joinId;
+            let associatedEntities;
+            associatedEntities = associationDAO.list(settings);
+            if (associatedEntities && associatedEntities.length > 0) {
+              this.$log.trace("Deleting {}[{}] entity's {} dependent {}", this.orm.table, id, associatedEntities.length, associationName);
+              this.notify("beforeRemoveAssociationSet", associatedEntities, id);
+              for (let j = 0; j < associatedEntities.length; j++) {
+                const associatedEntity = associatedEntities[j];
+                this.notify("beforeRemoveAssociationSetEntity", associatedEntity, associatedEntities, id);
+                associationDAO.remove.apply(associationDAO, [associatedEntity[associationDAO.orm.getPrimaryKey().name]]);
+              }
+              this.$log.trace("{}[{}] entity's {} dependent {} {} deleted.", this.orm.table, id, associatedEntities.length, associationName, associatedEntities.length > 1 ? "entities" : "entity");
+            }
+          }
+        }
+      }
+      const parametericStatement = this.ormstatements["delete"].apply(this.ormstatements, [this.orm.getPrimaryKey().name]);
+      let params = {};
+      params[this.orm.getPrimaryKey().name] = id;
+      const updatedRecordsCount = this.execute(parametericStatement, params);
+      if (updatedRecordsCount > 0)
+        this.$log.trace("{}[{}] entity deleted", this.orm.table, id);
+      else
+        this.$log.trace("No changes incurred in {}", this.orm.table);
+    } catch (e) {
+      this.$log.error("Deleting {}[{}] entity failed", this.orm.table, id, e);
+      throw e;
+    }
+  }
+};
+DAO.prototype.expand = function(expansionPath, context) {
+  let i;
+  let settings;
+  let key;
+  let joinId;
+  this.$log.trace("Expanding for association path {} and context entity {}", expansionPath, (typeof arguments[1] !== "object" ? "id " : "") + JSON.stringify(arguments[1]));
+  if (!expansionPath || !expansionPath.length) {
+    throw new Error("Illegal argument: expansionPath[" + expansionPath + "]");
+  }
+  if (!context) {
+    throw new Error("Illegal argument: context[" + context + "]");
+  }
+  const associationName = expansionPath.splice ? expansionPath.splice(0, 1)[0] : expansionPath;
+  const association = this.orm.getAssociation(associationName);
+  if (!associationName || !association)
+    throw new Error("Illegal argument: Unknown association for this DAO [" + associationName + "]");
+  const joinKey = association.joinKey;
+  let contextEntity;
+  if (context[this.orm.getPrimaryKey().name] !== void 0) {
+    contextEntity = context;
+  } else {
+    contextEntity = this.find(context);
+  }
+  if (!contextEntity) {
+    throw Error("No record found for context entity [" + context + "]");
+  }
+  const associationTargetDAO = association.targetDao ? association.targetDao.apply(this) : this;
+  if (!associationTargetDAO)
+    throw Error("No target association DAO instance available for association " + associationName);
+  let expansion;
+  let associationEntities = [];
+  if (association.type === this.orm.ASSOCIATION_TYPES["ONE-TO-ONE"] || association.type === this.orm.ASSOCIATION_TYPES["MANY-TO-ONE"]) {
+    joinId = contextEntity[joinKey];
+    this.$log.trace("Expanding association type {} on {}[{}]", association.type, joinKey, joinId);
+    if (!association.key || association.key === associationTargetDAO.orm.getPrimaryKey().name)
+      expansion = associationTargetDAO.find.apply(associationTargetDAO, [joinId]);
+    else {
+      let listSettings = {};
+      listSettings["$filter"] = association.key;
+      listSettings[association.key] = joinId;
+      expansion = associationTargetDAO.list.apply(associationTargetDAO, [listSettings])[0];
+    }
+    if (expansionPath.length > 0) {
+      this.expand(expansionPath, expansion);
+    }
+  } else if (association.type === this.orm.ASSOCIATION_TYPES["ONE-TO-MANY"]) {
+    settings = {};
+    if (association.defaults)
+      settings = association.defaults;
+    key = association.key || this.orm.getPrimaryKey().name;
+    joinId = contextEntity[key];
+    this.$log.trace("Expanding association type {} on {}[{}]", association.type, joinKey, joinId);
+    settings[joinKey] = joinId;
+    associationEntities = associationEntities.concat(associationTargetDAO.list.apply(associationTargetDAO, [settings]));
+    if (expansionPath.length > 0) {
+      for (i = 0; i < associationEntities.length; i++) {
+        this.expand(expansionPath, associationEntities[i]);
+      }
+    } else {
+      expansion = associationEntities;
+    }
+  } else if (association.type === this.orm.ASSOCIATION_TYPES["MANY-TO-MANY"]) {
+    const joinDAO = association.joinDao();
+    if (!joinDAO)
+      throw Error("No join DAO instance available for association " + associationName);
+    if (!joinDAO.listJoins)
+      throw Error("No listJoins function in join DAO instance available for association " + associationName);
+    settings = {};
+    key = association.key || this.orm.getPrimaryKey().name;
+    joinId = contextEntity[key];
+    settings[association.joinKey] = joinId;
+    associationEntities = associationEntities.concat(joinDAO.listJoins.apply(joinDAO, [settings, { "sourceDao": this, "joinDao": joinDAO, "targetDao": associationTargetDAO }]));
+    if (expansionPath.length > 0) {
+      for (i = 0; i < associationEntities.length; i++) {
+        this.expand(expansionPath, associationEntities[i]);
+      }
+    } else {
+      expansion = associationEntities;
+    }
+  }
+  return expansion;
+};
+DAO.prototype.find = function(id, expand, select) {
+  if (typeof arguments[0] === "object") {
+    id = arguments[0].id;
+    expand = arguments[0].$expand || arguments[0].expand;
+    select = arguments[0].$select || arguments[0].select;
+  }
+  this.$log.trace("Finding {}[{}] entity with list parameters expand[{}], select[{}]", this.orm.table, id, expand, select);
+  if (id === void 0 || id === null) {
+    throw new Error("Illegal argument for id parameter:" + id);
+  }
+  try {
+    let entity;
+    if (select !== void 0) {
+      if (select.constructor !== Array) {
+        if (select.constructor === String) {
+          select = select.split(",").map(function(sel) {
+            if (sel.constructor !== String)
+              throw Error("Illegal argument: select array components are expected ot be strings but found " + typeof sel);
+            return sel.trim();
+          });
+        } else {
+          throw Error("Illegal argument: select is expected to be string or array of strings but was " + typeof select);
+        }
+      }
+    }
+    if (select !== void 0 && expand !== void 0) {
+      select.push(this.orm.getPrimaryKey().name);
+    }
+    let findQbParams = {
+      select
+    };
+    const parametericStatement = this.ormstatements.find.apply(this.ormstatements, [findQbParams]);
+    let params = {};
+    if (this.orm.getPrimaryKey().type.toUpperCase() !== "VARCHAR")
+      id = parseInt(id, 10);
+    params[this.orm.getPrimaryKey().name] = id;
+    const resultSet = this.execute(parametericStatement, params);
+    if (resultSet[0]) {
+      entity = this.createEntity(resultSet[0], select);
+      if (entity) {
+        this.$log.trace("{}[{}] entity found", this.orm.table, id);
+        this.notify("afterFound", entity);
+        if (expand !== void 0) {
+          if (expand.constructor !== Array) {
+            if (expand.constructor === String) {
+              expand = String(expand);
+              expand = expand.split(",").map(function(exp) {
+                if (exp.constructor !== String)
+                  throw Error("Illegal argument: expand array components are expected ot be strings but found " + typeof exp);
+                return exp.trim();
+              });
+            } else {
+              throw Error("Illegal argument: expand is expected to be string or array of strings but was " + typeof expand);
+            }
+          }
+          var associationNames = this.orm.getAssociationNames();
+          for (var idx in associationNames) {
+            var associationName = associationNames[idx];
+            if (expand.indexOf(associationName) > -1) {
+              entity[associationName] = this.expand([associationName], entity);
+            }
+          }
+        }
+      } else {
+        this.$log.trace("{}[{}] entity not found", this.orm.table, id);
+      }
+    }
+    return entity;
+  } catch (e) {
+    this.$log.error("Finding {}[{}] entity failed.", this.orm.table, id, e);
+    throw e;
+  }
+};
+DAO.prototype.count = function(settings) {
+  settings = settings || {};
+  const parametericStatement = this.ormstatements.count.apply(this.ormstatements, [settings]);
+  this.$log.trace("Counting " + this.orm.table + " entities");
+  let count = 0;
+  try {
+    const rs = this.execute(parametericStatement, settings);
+    if (rs.length > 0) {
+      const key = Object.keys(rs[0])[0];
+      count = parseInt(rs[0][key], 10);
+    }
+  } catch (e) {
+    this.$log.error("Counting {} entities failed", this.orm.table, e);
+    e.errContext = parametericStatement.toString();
+    throw e;
+  }
+  this.$log.trace("{} {} entities counted", String(count), this.orm.table);
+  return count;
+};
+DAO.prototype.list = function(settings) {
+  let key;
+  settings = settings || {};
+  const expand = settings.$expand || settings.expand;
+  if (expand !== void 0) {
+    if (expand.constructor !== Array) {
+      if (expand.constructor === String) {
+        if (expand.indexOf(",") > -1) {
+          settings.$expand = expand.split(",").map(function(exp) {
+            if (exp.constructor !== String)
+              throw Error("Illegal argument: expand array components are expected ot be strings but found " + typeof exp);
+            return exp.trim();
+          });
+        } else {
+          settings.$expand = [expand];
+        }
+      } else {
+        throw Error("Illegal argument: expand is expected to be string or array of strings but was " + typeof expand);
+      }
+    }
+  }
+  const select = settings.$select || settings.select;
+  if (select !== void 0) {
+    if (select.constructor !== Array) {
+      if (select.constructor === String) {
+        if (select.indexOf(",") > -1) {
+          settings.$select = select.split(",").map(function(exp) {
+            if (exp.constructor !== String)
+              throw Error("Illegal argument: select array components are expected ot be strings but found " + typeof exp);
+            return exp.trim();
+          });
+        } else {
+          settings.$select = [select];
+        }
+      } else {
+        throw Error("Illegal argument: select is expected to be string or array of strings but was " + typeof expand);
+      }
+    }
+  }
+  const listArgs = [];
+  for (key in settings) {
+    listArgs.push(" " + key + "[" + settings[key] + "]");
+  }
+  this.$log.trace("Listing {} entity collection with list operators: {}", this.orm.table, listArgs.join(","));
+  if (settings.$select !== void 0 && expand !== void 0) {
+    settings.$select.push(this.orm.getPrimaryKey().name);
+  }
+  var parametericStatement = this.ormstatements.list.apply(this.ormstatements, [settings]);
+  try {
+    let entities = [];
+    const resultSet = this.execute(parametericStatement, settings);
+    resultSet.forEach(function(rsEntry) {
+      var entity = this.createEntity(rsEntry, settings.$select);
+      if (expand) {
+        var associationNames = this.orm.getAssociationNames();
+        for (var idx = 0; idx < associationNames.length; idx++) {
+          var associationName = associationNames[idx];
+          if (expand.indexOf(associationName) > -1) {
+            entity[associationName] = this.expand([associationName], entity);
+          }
+        }
+      }
+      this.notify("afterFound", entity, settings);
+      entities.push(entity);
+    }.bind(this));
+    this.$log.trace("{} {} entities found", entities.length, this.orm.table);
+    return entities;
+  } catch (e) {
+    this.$log.error("Listing {} entities failed.", this.orm.table, e);
+    throw e;
+  }
+};
+DAO.prototype.existsTable = function() {
+  this.$log.trace("Check exists table " + this.orm.table);
+  try {
+    const parametericStatement = this.ormstatements.count.apply(this.ormstatements);
+    const rs = this.execute(parametericStatement);
+    return rs.length > 0;
+  } catch (e) {
+    return false;
+  }
+};
+DAO.prototype.createTable = function() {
+  this.$log.trace("Creating table {}", this.orm.table);
+  const parametericStatement = this.ormstatements.createTable.apply(this.ormstatements);
+  try {
+    this.execute(parametericStatement);
+    this.$log.trace("{} table created", this.orm.table);
+    return this;
+  } catch (e) {
+    this.$log.error("Create table {} failed", this.orm.table, e);
+    throw e;
+  }
+};
+DAO.prototype.dropTable = function(dropIdSequence) {
+  this.$log.trace("Dropping table {}.", this.orm.table);
+  const parametericStatement = this.ormstatements.dropTable.apply(this.ormstatements);
+  try {
+    this.execute(parametericStatement);
+    this.$log.trace("Table {} dropped.", this.orm.table);
+  } catch (e) {
+    this.$log.error("Dropping table {} failed.", this.orm.table, e);
+    throw e;
+  }
+  if (dropIdSequence) {
+    this.$log.trace("Dropping table {} sequence {}.", this.orm.table, this.sequenceName);
+    try {
+      this.dropIdGenerator();
+      this.$log.trace("Table {} sequence {} dropped.", this.orm.table, this.sequenceName);
+    } catch (e) {
+      this.$log.error("Dropping table {} sequence {} failed.", this.orm.table, this.sequenceName, e);
+      throw e;
+    }
+  }
+  return this;
+};
+function create(oDefinition, logCtxName, dataSourceName) {
+  let orm;
+  orm = oDefinition;
+  if (!dataSourceName || dataSourceName === null) {
+    dataSourceName = import_core.configurations.get("DIRIGIBLE_DATABASE_DATASOURCE_NAME_DEFAULT", "DefaultDB");
+  }
+  let productName = import_core.globals.get(dataSourceName);
+  if (!productName) {
+    productName = import_database.Database.getProductName(dataSourceName);
+    import_core.globals.set(dataSourceName, productName);
+  }
+  return new DAO(orm, logCtxName, dataSourceName);
+}
+;
+function dao(oDefinition, logCtxName, dataSourceName) {
+  return create(oDefinition, logCtxName, dataSourceName);
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/dao.ts"],
  "sourcesContent": ["\"use strict\";\n\nimport { ORMDefinition, get as getORM } from \"./orm\";\nimport { create as createORMStatements } from \"./ormstatements\";\nimport { Sequence } from \"./sequence\";\nimport { Database } from \"./database\";\nimport { Query } from \"@aerokit/sdk/db\";\nimport { Update } from \"./update\";\nimport { Insert } from \"./insert\";\nimport { Logging } from \"@aerokit/sdk/log\";\nimport { configurations, globals } from \"@aerokit/sdk/core\";\n\n\nexport function DAO(orm: ORMDefinition, logCtxName?: string, dataSourceName?: string) {\n\tif (orm === undefined)\n\t\tthrow Error('Illegal argument: orm[' + orm + ']');\n\n\tthis.orm = getORM(orm);\n\tthis.sequenceName = this.orm.table + '_' + this.orm.getPrimaryKey().name.toUpperCase();\n\tthis.dropIdGenerator = function () {\n\t\treturn Sequence.drop(this.sequenceName, dataSourceName);\n\t};\n\tthis.generateId = function () {\n\t\treturn Sequence.nextval(this.sequenceName, this.orm.table, dataSourceName);\n\t};\n\n\tconst conn = Database.getConnection(dataSourceName);\n\ttry {\n\t\tthis.ormstatements = createORMStatements(this.orm, conn);\n\t} finally {\n\t\tconn.close();\n\t}\n\n\t// setup loggerName\n\tlet loggerName = logCtxName;\n\tif (!loggerName) {\n\t\tloggerName = 'db.dao';\n\t\tif (this.orm.table)\n\t\t\tloggerName = 'db.dao.' + (this.orm.table.toLowerCase());\n\t}\n\tthis.$log = Logging.getLogger(loggerName);\n\n\tthis.execute = function (sqlBuilder, parameterBindings) {\n\t\tconst sql = sqlBuilder.build();\n\t\tif (sql === undefined || sql.length < 1)\n\t\t\tthrow Error(\"Illegal argument: sql from statement builder is invalid[\" + sql + \"]\");\n\t\tthis.$log.trace('Executing SQL Statement: {}', sql);\n\n\t\tconst parameters = sqlBuilder.parameters && sqlBuilder.parameters();\n\t\tconst _parameterBindings = [];\n\t\tif (parameterBindings?.$filter && parameters && parameters.length > 0) {\n\t\t\tif (parameterBindings.$filter.equals) {\n\t\t\t\tconst propertiesKeys = Object.keys(parameterBindings.$filter.equals);\n\t\t\t\tconst addedPropertiesKeys = [];\n\t\t\t\tparameters.forEach(e => {\n\t\t\t\t\tif (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {\n\t\t\t\t\t\tconst value = parameterBindings.$filter.equals[e.name];\n\t\t\t\t\t\tif (Array.isArray(value)) {\n\t\t\t\t\t\t\tvalue.forEach(v => {\n\t\t\t\t\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\t\t\t\ttype: e.type,\n\t\t\t\t\t\t\t\t\tvalue: parseValue(e.type, v)\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\t\t\ttype: e.type,\n\t\t\t\t\t\t\t\tvalue: parseValue(e.type, value)\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t\taddedPropertiesKeys.push(e.name);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (parameterBindings.$filter.notEquals) {\n\t\t\t\tconst propertiesKeys = Object.keys(parameterBindings.$filter.notEquals);\n\t\t\t\tconst addedPropertiesKeys = [];\n\t\t\t\tparameters.forEach(e => {\n\t\t\t\t\tif (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {\n\t\t\t\t\t\tconst value = parameterBindings.$filter.notEquals[e.name];\n\t\t\t\t\t\tif (Array.isArray(value)) {\n\t\t\t\t\t\t\tvalue.forEach(v => {\n\t\t\t\t\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\t\t\t\ttype: e.type,\n\t\t\t\t\t\t\t\t\tvalue: parseValue(e.type, v)\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\t\t\ttype: e.type,\n\t\t\t\t\t\t\t\tvalue: parseValue(e.type, value)\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t\taddedPropertiesKeys.push(e.name);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (parameterBindings.$filter.contains) {\n\t\t\t\tconst propertiesKeys = Object.keys(parameterBindings.$filter.contains);\n\t\t\t\tconst addedPropertiesKeys = [];\n\t\t\t\tparameters.forEach(e => {\n\t\t\t\t\tif (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {\n\t\t\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\t\ttype: e.type,\n\t\t\t\t\t\t\tvalue: `%${parameterBindings.$filter.contains[e.name]}%`\n\t\t\t\t\t\t});\n\t\t\t\t\t\taddedPropertiesKeys.push(e.name);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (parameterBindings.$filter.greaterThan) {\n\t\t\t\tconst propertiesKeys = Object.keys(parameterBindings.$filter.greaterThan);\n\t\t\t\tconst addedPropertiesKeys = [];\n\t\t\t\tparameters.forEach(e => {\n\t\t\t\t\tif (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {\n\t\t\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\t\ttype: e.type,\n\t\t\t\t\t\t\tvalue: parseValue(e.type, parameterBindings.$filter.greaterThan[e.name])\n\t\t\t\t\t\t});\n\t\t\t\t\t\taddedPropertiesKeys.push(e.name);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (parameterBindings.$filter.lessThan) {\n\t\t\t\tconst propertiesKeys = Object.keys(parameterBindings.$filter.lessThan);\n\t\t\t\tconst addedPropertiesKeys = [];\n\t\t\t\tparameters.forEach(e => {\n\t\t\t\t\tif (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {\n\t\t\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\t\ttype: e.type,\n\t\t\t\t\t\t\tvalue: parseValue(e.type, parameterBindings.$filter.lessThan[e.name])\n\t\t\t\t\t\t});\n\t\t\t\t\t\taddedPropertiesKeys.push(e.name);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (parameterBindings.$filter.greaterThanOrEqual) {\n\t\t\t\tconst propertiesKeys = Object.keys(parameterBindings.$filter.greaterThanOrEqual);\n\t\t\t\tconst addedPropertiesKeys = [];\n\t\t\t\tparameters.forEach(e => {\n\t\t\t\t\tif (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {\n\t\t\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\t\ttype: e.type,\n\t\t\t\t\t\t\tvalue: parseValue(e.type, parameterBindings.$filter.greaterThanOrEqual[e.name])\n\t\t\t\t\t\t});\n\t\t\t\t\t\taddedPropertiesKeys.push(e.name);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\tif (parameterBindings.$filter.lessThanOrEqual) {\n\t\t\t\tconst propertiesKeys = Object.keys(parameterBindings.$filter.lessThanOrEqual);\n\t\t\t\tconst addedPropertiesKeys = [];\n\t\t\t\tparameters.forEach(e => {\n\t\t\t\t\tif (propertiesKeys.includes(e.name) && !addedPropertiesKeys.includes(e.name)) {\n\t\t\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\t\ttype: e.type,\n\t\t\t\t\t\t\tvalue: parseValue(e.type, parameterBindings.$filter.lessThanOrEqual[e.name])\n\t\t\t\t\t\t});\n\t\t\t\t\t\taddedPropertiesKeys.push(e.name);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\t// Left for backward compatibility -> it seems that the find() method uses it, might be removed once refactored\n\t\tif (parameters && parameters.length > 0) {\n\t\t\tfor (var i = 0; i < parameters.length; i++) {\n\t\t\t\tvar val;\n\t\t\t\tif (parameterBindings) {\n\t\t\t\t\tif (Array.isArray(parameterBindings)) {\n\t\t\t\t\t\tval = parameterBindings[i];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tval = parameterBindings[parameters[i].name];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif ((val === null || val === undefined) && sql.toLowerCase().startsWith('select')) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst index = i + 1;\n\t\t\t\tthis.$log.trace('Binding to parameter[{}]: {}', index, val);\n\t\t\t\t_parameterBindings.push({\n\t\t\t\t\t\"type\": parameters[i].type,\n\t\t\t\t\t\"value\": parseValue(parameters[i].type, val)\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\tlet result;\n\n\t\tif (sql.toLowerCase().startsWith('select')) {\n\t\t\tresult = Query.execute(sql, _parameterBindings, dataSourceName);\n\t\t} else if (sql.toLowerCase().startsWith('insert')) {\n\t\t\tresult = Insert.execute(sql, _parameterBindings, dataSourceName);\n\t\t} else {\n\t\t\tresult = Update.execute(sql, _parameterBindings, dataSourceName);\n\t\t}\n\n\t\treturn result !== null ? result : [];\n\t};\n\n\tfunction parseValue(type, value) {\n\t\tswitch (type.toUpperCase()) {\n\t\t\tcase 'INTEGER':\n\t\t\t\treturn parseInt(value);\n\t\t\tcase 'DOUBLE':\n\t\t\tcase 'FLOAT':\n\t\t\t\treturn parseFloat(value);\n\t\t\tcase 'BOOLEAN':\n\t\t\t\treturn value ? 'true' : 'false';\n\t\t\tdefault:\n\t\t\t\treturn value;\n\t\t}\n\t}\n};\n\nDAO.prototype.notify = function (event) {\n\tconst func = this[event];\n\tif (!this[event])\n\t\treturn;\n\tif (typeof func !== 'function')\n\t\tthrow Error('Illegal argument. Not a function: ' + func);\n\tconst args = [].slice.call(arguments);\n\tfunc.apply(this, args.slice(1));\n};\n\n/**\n * Prepare a JSON object for insert into DB\n */\nDAO.prototype.createSQLEntity = function (entity) {\n\tlet i;\n\tconst persistentItem = {};\n\tconst mandatories = this.orm.getMandatoryProperties();\n\tfor (i = 0; i < mandatories.length; i++) {\n\t\tif (mandatories[i].dbValue) {\n\t\t\tpersistentItem[mandatories[i].name] = mandatories[i].dbValue.apply(this, [entity[mandatories[i].name], entity]);\n\t\t} else {\n\t\t\tpersistentItem[mandatories[i].name] = entity[mandatories[i].name];\n\t\t}\n\t}\n\tconst optionals = this.orm.getOptionalProperties();\n\tfor (i = 0; i < optionals.length; i++) {\n\t\tif (optionals[i].dbValue !== undefined) {\n\t\t\tpersistentItem[optionals[i].name] = optionals[i].dbValue.apply(this, [entity[optionals[i].name], entity]);\n\t\t} else {\n\t\t\tpersistentItem[optionals[i].name] = entity[optionals[i].name] === undefined ? null : entity[optionals[i].name];\n\t\t}\n\t}\n\treturn persistentItem;\n};\n\n/**\n * Create entity as JSON object from ResultSet current Row\n */\nDAO.prototype.createEntity = function (resultSetEntry, entityPropertyNames) {\n\tconst entity = {};\n\tlet properties = this.orm.properties;\n\tif (entityPropertyNames && entityPropertyNames.length > 0) {\n\t\tproperties = properties.filter(function (prop) {\n\t\t\treturn entityPropertyNames.indexOf(prop.name) > -1;\n\t\t});\n\t}\n\tfor (let i = 0; i < properties.length; i++) {\n\t\tconst prop = properties[i];\n\t\tentity[prop.name] = resultSetEntry[prop.columnName];\n\t\tif (prop.value) {\n\t\t\tentity[prop.name] = prop.value(entity[prop.name]);\n\t\t}\n\t}\n\tObject.keys(entity).forEach(function (propertyName) {\n\t\tif (entity[propertyName] === null)\n\t\t\tentity[propertyName] = undefined;\n\t});\n\n\tlet entitySegment = \"\";\n\tif (entity[this.orm.getPrimaryKey().name]) {\n\t\tentitySegment = \"[\" + entity[this.orm.getPrimaryKey().name] + \"]\";\n\t}\n\t// this.$log.trace(\"Transformation from {} DB JSON object finished\", (this.orm.table + entitySegment));\n\treturn entity;\n};\n\nDAO.prototype.validateEntity = function (entity, skip) {\n\tif (entity === undefined || entity === null) {\n\t\tthrow new Error('Illegal argument: entity is ' + entity);\n\t}\n\tif (skip) {\n\t\tif (skip.constructor !== Array) {\n\t\t\tskip = [skip];\n\t\t}\n\t\tfor (var j = 0; j < skip.length; j++) {\n\t\t\tskip[j];\n\t\t}\n\t}\n\tconst mandatories = this.orm.getMandatoryProperties();\n\tfor (let i = 0; i < mandatories.length; i++) {\n\t\tconst propName = mandatories[i].name;\n\t\tif ((skip && skip.indexOf(propName) > -1) || mandatories[i].type.toUpperCase() === 'BOOLEAN')\n\t\t\tcontinue;\n\t\tconst propValue = entity[propName];\n\t\tif (propValue === undefined || propValue === null) {\n\t\t\tthrow new Error('Illegal ' + propName + ' attribute value in ' + this.orm.table + ' entity: ' + propValue);\n\t\t}\n\t}\n};\n\nDAO.prototype.insert = function (_entity) {\n\n\tconst ids = [];\n\tlet entities = _entity;\n\tif (_entity.constructor !== Array) {\n\t\tentities = [_entity];\n\t}\n\n\tthis.$log.trace('Inserting {} {}', this.orm.table, (entities.length === 1 ? 'entity' : 'entities'));\n\n\tfor (let i = 0; i < entities.length; i++) {\n\t\tlet entity = entities[i];\n\t\tentity = entities[i];\n\n\t\tthis.validateEntity(entity, [this.orm.getPrimaryKey().name]);\n\n\t\t//check for unique constraint violations\n\t\tconst uniques = this.orm.getUniqueProperties();\n\t\tfor (let _i = 0; _i < uniques.length; _i++) {\n\t\t\tconst prop = uniques[_i];\n\t\t\tconst st = this.ormstatements.dialect\n\t\t\t\t.select(prop.column)\n\t\t\t\t.from(this.orm.table)\n\t\t\t\t.where(prop.column + '=?', [prop]);\n\t\t\tconst params = {};\n\t\t\tparams[prop.name] = entity[prop.name];\n\t\t\tconst rs = this.execute(st, params);\n\t\t\tif (rs.length > 0)\n\t\t\t\tthrow Error('Unique constraint violation for ' + prop.name + '[' + entity[prop.name] + ']');\n\t\t}\n\n\t\tconst dbEntity = this.createSQLEntity(entity);\n\n\t\ttry {\n\t\t\tconst parametericStatement = this.ormstatements.insert.apply(this.ormstatements);\n\n\t\t\tif (this.orm.isAutoIncrementPrimaryKey()) {\n\t\t\t\tconst id = this.generateId();\n\t\t\t\tdbEntity[this.orm.getPrimaryKey().name] = id;\n\t\t\t}\n\n\t\t\tconst updatedRecordCount = this.execute(parametericStatement, dbEntity);\n\n\t\t\tif (!this.orm.isAutoIncrementPrimaryKey() && isNotEmptyArray(updatedRecordCount)) {\n\t\t\t\tconst id = updatedRecordCount[0];\n\t\t\t\tdbEntity[this.orm.getPrimaryKey().name] = id;\n\t\t\t}\n\n\t\t\tthis.notify('afterInsert', dbEntity);\n\t\t\tthis.notify('beforeInsertAssociationSets', dbEntity);\n\t\t\tif ((updatedRecordCount > 0 || isNotEmptyArray(updatedRecordCount)) && this.orm.associations && Object.keys(this.orm.associations).length) {\n\t\t\t\t//Insert dependencies if any are provided inline with this entity\n\t\t\t\tthis.$log.trace('Inserting association sets for {}[{}]', this.orm.table, dbEntity[this.orm.getPrimaryKey().name]);\n\t\t\t\tfor (const idx in Object.keys(this.orm.associations)) {\n\t\t\t\t\tconst association = this.orm.associations[idx];\n\t\t\t\t\tconst associationName = association['name'];\n\t\t\t\t\tif ([this.orm.ASSOCIATION_TYPES['MANY-TO-MANY'], this.orm.ASSOCIATION_TYPES['MANY-TO-ONE']].indexOf(association.type) < 0) {\n\t\t\t\t\t\tif (entity[associationName] && entity[associationName].length > 0) {\n\t\t\t\t\t\t\tconst associationDaoFactoryFunc = association.targetDao || this;\n\t\t\t\t\t\t\tif (associationDaoFactoryFunc.constructor !== Function)\n\t\t\t\t\t\t\t\tthrow Error('Invalid ORM: Association ' + associationName + ' dao property is expected to be function. Instead, it is: ' + (typeof associationDaoFactoryFunc))\n\t\t\t\t\t\t\tconst associationDAO = associationDaoFactoryFunc.apply(this);\n\t\t\t\t\t\t\tthis.notify('beforeInsertAssociationSet', entity[associationName], entity);\n\t\t\t\t\t\t\tthis.$log.trace('Inserting {} inline entities into association set {}', entity[associationName].length, associationName);\n\t\t\t\t\t\t\tfor (let j = 0; j < entity[associationName].length; j++) {\n\t\t\t\t\t\t\t\tconst associatedEntity = entity[associationName][j];\n\t\t\t\t\t\t\t\tconst associatedEntityJoinKey = association.joinKey;\n\t\t\t\t\t\t\t\tconst key = association.key || this.orm.getPrimaryKey().name;\n\t\t\t\t\t\t\t\tassociatedEntity[associatedEntityJoinKey] = entity[key];\n\t\t\t\t\t\t\t\tthis.notify('beforeInsertAssociationSetEntity', entity[associationName], dbEntity);\n\n\t\t\t\t\t\t\t\tassociationDAO.insert.apply(associationDAO, [associatedEntity]);\n\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tthis.$log.trace('Inserting {} inline entities into association set {} finsihed', entity[associationName].length, associationName);\n\t\t\t\t\t\t\tthis.notify('afterInsertAssociationSet', entity[associationName], dbEntity);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (updatedRecordCount > 0 || isNotEmptyArray(updatedRecordCount)) {\n\t\t\t\tids.push(dbEntity[this.orm.getPrimaryKey().name]);\n\t\t\t\tthis.$log.trace('{}[] entity inserted', this.orm.table, dbEntity[this.orm.getPrimaryKey().name]);\n\t\t\t} else {\n\t\t\t\tthis.$log.trace('No changes incurred in {}', this.orm.table);\n\t\t\t}\n\n\n\t\t} catch (e) {\n\t\t\tthis.$log.error(\"Inserting {} {} failed\", this.orm.table, (entities.length === 1 ? 'entity' : 'entities'), e);\n\t\t\tthis.$log.trace('Rolling back changes after failed {}[{}] insert. ', this.orm.table, dbEntity[this.orm.getPrimaryKey().name]);\n\t\t\tif (dbEntity[this.orm.getPrimaryKey().name]) {\n\t\t\t\ttry {\n\t\t\t\t\tthis.remove(dbEntity[this.orm.getPrimaryKey().name]);\n\t\t\t\t} catch (err) {\n\t\t\t\t\tthis.$log.error('Could not rollback changes after failed {}[{}] insert. ', this.orm.table, dbEntity[this.orm.getPrimaryKey().name], err);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow e;\n\t\t}\n\t}\n\n\tif (_entity.constructor !== Array)\n\t\treturn ids[0];\n\telse\n\t\treturn ids;\n};\n\nfunction isNotEmptyArray(array) {\n\treturn Array.isArray(array) && array.length > 0;\n}\n\n/**\n * Update entity from a JSON object. Returns the id of the updated entity.\n */\nDAO.prototype.update = function (entity) {\n\n\tthis.$log.trace('Updating {}[{}] entity', this.orm.table, entity !== undefined ? entity[this.orm.getPrimaryKey().name] : entity);\n\n\tif (entity === undefined || entity === null) {\n\t\tthrow new Error('Illegal argument: entity is ' + entity);\n\t}\n\n\tconst ignoredProperties = this.orm.getMandatoryProperties()\n\t\t.filter(function (property) {\n\t\t\treturn property.allowedOps && property.allowedOps.indexOf('update') < 0;\n\t\t})\n\t\t.map(function (property) {\n\t\t\treturn property.name;\n\t\t});\n\tthis.validateEntity(entity, ignoredProperties);\n\n\tconst parametericStatement = this.ormstatements.update.apply(this.ormstatements, [entity]);\n\n\tconst dbEntity = this.createSQLEntity(entity);\n\n\ttry {\n\t\tthis.notify('beforeUpdateEntity', dbEntity);\n\t\tconst updatedRecordsCount = this.execute(parametericStatement, dbEntity);\n\t\tif (updatedRecordsCount > 0)\n\t\t\tthis.$log.trace('{}[{}] entity updated', this.orm.table, dbEntity[this.orm.getPrimaryKey().name]);\n\t\telse\n\t\t\tthis.$log.trace('No changes incurred in {}', this.orm.table);\n\n\t\treturn this;\n\n\t} catch (e) {\n\t\tthis.$log.error('Updating {}[{}] failed', this.orm.table, entity !== undefined ? entity[this.orm.getPrimaryKey().name] : entity, e);\n\t\tthrow e;\n\t}\n};\n\n/**\n * Delete entity by id, or array of ids, or delete all (if not argument is provided)\n */\nDAO.prototype.remove = function () {\n\n\tlet ids = [];\n\tif (arguments.length === 0) {\n\t\tids = this.list({\n\t\t\t\"$select\": [this.orm.getPrimaryKey().name]\n\t\t}).map(function (ent) {\n\t\t\treturn ent[this.orm.getPrimaryKey().name];\n\t\t}.bind(this));\n\t} else {\n\t\tif (arguments[0].constructor !== Array) {\n\t\t\tids = [arguments[0]];\n\t\t} else {\n\t\t\tids = arguments[0];\n\t\t}\n\t}\n\n\tthis.$log.trace('Deleting ' + this.orm.table + ((ids !== undefined && ids.length === 1) ? '[' + ids[0] + '] entity' : ids.length + ' entities'));\n\n\tfor (let i = 0; i < ids.length; i++) {\n\n\t\tlet id = ids[i];\n\t\t//prevent implicit type convertion\n\t\tif (this.orm.getPrimaryKey().type.toUpperCase() !== 'VARCHAR')\n\t\t\tid = parseInt(id, 10);\n\n\t\tif (ids.length > 1)\n\t\t\tthis.$log.trace('Deleting {}[{}] entity', this.orm.table, id);\n\n\t\tif (id === undefined || id === null) {\n\t\t\tthrow new Error('Illegal argument for id parameter:' + id);\n\t\t}\n\n\t\ttry {\n\n\t\t\tthis.notify('beforeRemoveEntity', id);\n\n\t\t\t//first we attempt to remove depndents if any\n\t\t\tif (this.orm.associations) {\n\t\t\t\t//Remove associated dependencies\n\t\t\t\tfor (const idx in Object.keys(this.orm.associations)) {\n\t\t\t\t\tconst association = this.orm.associations[idx];\n\t\t\t\t\tconst associationName = association['name'];\n\t\t\t\t\tif ([this.orm.ASSOCIATION_TYPES['MANY-TO-MANY'], this.orm.ASSOCIATION_TYPES['MANY-TO-ONE']].indexOf(association.type) < 0) {\n\t\t\t\t\t\tthis.$log.trace(\"Inspecting {}[{}}] entity's dependency '{}' for entities to delete.\", this.orm.table, id, associationName);\n\t\t\t\t\t\tconst associationDAO = association.targetDao ? association.targetDao() : this;\n\t\t\t\t\t\tconst settings = {};\n\t\t\t\t\t\tlet joinId = id;\n\t\t\t\t\t\t//check if we are joining on field, other than pk\n\t\t\t\t\t\tif (association.key !== undefined) {\n\t\t\t\t\t\t\tvar ctxEntity = this.find(id);\n\t\t\t\t\t\t\tjoinId = ctxEntity[association.key];\n\t\t\t\t\t\t}\n\t\t\t\t\t\tsettings[association.joinKey] = joinId;\n\t\t\t\t\t\tlet associatedEntities;\n\t\t\t\t\t\t//associatedEntities = this.expand(associationName, id);\n\t\t\t\t\t\tassociatedEntities = associationDAO.list(settings);\n\t\t\t\t\t\tif (associatedEntities && associatedEntities.length > 0) {\n\t\t\t\t\t\t\tthis.$log.trace(\"Deleting {}[{}] entity's {} dependent {}\", this.orm.table, id, associatedEntities.length, associationName);\n\t\t\t\t\t\t\tthis.notify('beforeRemoveAssociationSet', associatedEntities, id);\n\t\t\t\t\t\t\tfor (let j = 0; j < associatedEntities.length; j++) {\n\t\t\t\t\t\t\t\tconst associatedEntity = associatedEntities[j];\n\t\t\t\t\t\t\t\tthis.notify('beforeRemoveAssociationSetEntity', associatedEntity, associatedEntities, id);\n\n\t\t\t\t\t\t\t\tassociationDAO.remove.apply(associationDAO, [associatedEntity[associationDAO.orm.getPrimaryKey().name]]);\n\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tthis.$log.trace(\"{}[{}] entity's {} dependent {} {} deleted.\", this.orm.table, id, associatedEntities.length, associationName, associatedEntities.length > 1 ? 'entities' : 'entity');\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\t//Delete by primary key value\n\t\t\tconst parametericStatement = this.ormstatements[\"delete\"].apply(this.ormstatements, [this.orm.getPrimaryKey().name]);\n\t\t\tlet params = {};\n\t\t\tparams[this.orm.getPrimaryKey().name] = id;\n\n\t\t\tconst updatedRecordsCount = this.execute(parametericStatement, params);\n\n\t\t\tif (updatedRecordsCount > 0)\n\t\t\t\tthis.$log.trace('{}[{}] entity deleted', this.orm.table, id);\n\t\t\telse\n\t\t\t\tthis.$log.trace('No changes incurred in {}', this.orm.table);\n\n\t\t} catch (e) {\n\t\t\tthis.$log.error('Deleting {}[{}] entity failed',this.orm.table, id, e);\n\t\t\tthrow e;\n\t\t}\n\n\t}\n\n};\n\nDAO.prototype.expand = function (expansionPath, context) {\n\tlet i;\n\tlet settings;\n\tlet key;\n\tlet joinId;\n\tthis.$log.trace('Expanding for association path {} and context entity {}', expansionPath, (typeof arguments[1] !== 'object' ? 'id ' : '') + JSON.stringify(arguments[1]));\n\tif (!expansionPath || !expansionPath.length) {\n\t\tthrow new Error('Illegal argument: expansionPath[' + expansionPath + ']');\n\t}\n\tif (!context) {\n\t\tthrow new Error('Illegal argument: context[' + context + ']');\n\t}\n\tconst associationName = expansionPath.splice ? expansionPath.splice(0, 1)[0] : expansionPath;\n\tconst association = this.orm.getAssociation(associationName);\n\tif (!associationName || !association)\n\t\tthrow new Error('Illegal argument: Unknown association for this DAO [' + associationName + ']');\n\tconst joinKey = association.joinKey;\n\n\tlet contextEntity;\n\tif (context[this.orm.getPrimaryKey().name] !== undefined) {\n\t\tcontextEntity = context;\n\t} else {\n\t\tcontextEntity = this.find(context);\n\t}\n\n\tif (!contextEntity) {\n\t\tthrow Error('No record found for context entity [' + context + ']');\n\t}\n\n\tconst associationTargetDAO = association.targetDao ? association.targetDao.apply(this) : this;\n\tif (!associationTargetDAO)\n\t\tthrow Error('No target association DAO instance available for association ' + associationName);\n\n\tlet expansion;\n\tlet associationEntities = [];\n\n\tif (association.type === this.orm.ASSOCIATION_TYPES['ONE-TO-ONE'] || association.type === this.orm.ASSOCIATION_TYPES['MANY-TO-ONE']) {\n\t\tjoinId = contextEntity[joinKey];\n\t\tthis.$log.trace('Expanding association type {} on {}[{}]', association.type, joinKey, joinId);\n\t\tif (!association.key || association.key === associationTargetDAO.orm.getPrimaryKey().name)\n\t\t\texpansion = associationTargetDAO.find.apply(associationTargetDAO, [joinId]);\n\t\telse {\n\t\t\tlet listSettings = {};\n\t\t\tlistSettings[\"$filter\"] = association.key;\n\t\t\tlistSettings[association.key] = joinId;\n\t\t\texpansion = associationTargetDAO.list.apply(associationTargetDAO, [listSettings])[0];\n\t\t}\n\n\t\tif (expansionPath.length > 0) {\n\t\t\tthis.expand(expansionPath, expansion);\n\t\t}\n\t} else if (association.type === this.orm.ASSOCIATION_TYPES['ONE-TO-MANY']) {\n\t\tsettings = {};\n\t\tif (association.defaults)\n\t\t\tsettings = association.defaults;\n\t\tkey = association.key || this.orm.getPrimaryKey().name;\n\t\tjoinId = contextEntity[key];\n\t\tthis.$log.trace('Expanding association type {} on {}[{}]', association.type, joinKey, joinId);\n\t\tsettings[joinKey] = joinId;\n\t\tassociationEntities = associationEntities.concat(associationTargetDAO.list.apply(associationTargetDAO, [settings]));\n\n\t\tif (expansionPath.length > 0) {\n\t\t\tfor (i = 0; i < associationEntities.length; i++) {\n\t\t\t\tthis.expand(expansionPath, associationEntities[i]);\n\t\t\t}\n\t\t} else {\n\t\t\texpansion = associationEntities;\n\t\t}\n\t} else if (association.type === this.orm.ASSOCIATION_TYPES['MANY-TO-MANY']) {\n\t\tconst joinDAO = association.joinDao();\n\t\tif (!joinDAO)\n\t\t\tthrow Error('No join DAO instance available for association ' + associationName);\n\t\tif (!joinDAO.listJoins)\n\t\t\tthrow Error('No listJoins function in join DAO instance available for association ' + associationName);\n\t\tsettings = {};\n\t\tkey = association.key || this.orm.getPrimaryKey().name;\n\t\tjoinId = contextEntity[key];\n\t\tsettings[association.joinKey] = joinId;\n\t\tassociationEntities = associationEntities.concat(joinDAO.listJoins.apply(joinDAO, [settings, { \"sourceDao\": this, \"joinDao\": joinDAO, \"targetDao\": associationTargetDAO }]));\n\t\tif (expansionPath.length > 0) {\n\t\t\tfor (i = 0; i < associationEntities.length; i++) {\n\t\t\t\tthis.expand(expansionPath, associationEntities[i]);\n\t\t\t}\n\t\t} else {\n\t\t\texpansion = associationEntities;\n\t\t}\n\t}\n\treturn expansion;\n};\n\n/**\n * Reads a single entity by id, parsed into JSON object.\n * If requested as expanded the returned entity will comprise associated (dependent) entities too. \n * Expand can be a string tha tis a valid association name defined in this dao orm or an array of such names.\n */\nDAO.prototype.find = function (id, expand, select) {\n\tif (typeof arguments[0] === 'object') {\n\t\tid = arguments[0].id;\n\t\texpand = arguments[0].$expand || arguments[0].expand;\n\t\tselect = arguments[0].$select || arguments[0].select;\n\t}\n\n\tthis.$log.trace('Finding {}[{}] entity with list parameters expand[{}], select[{}]', this.orm.table, id, expand, select);\n\n\tif (id === undefined || id === null) {\n\t\tthrow new Error('Illegal argument for id parameter:' + id);\n\t}\n\n\ttry {\n\t\tlet entity;\n\t\tif (select !== undefined) {\n\t\t\tif (select.constructor !== Array) {\n\t\t\t\tif (select.constructor === String) {\n\t\t\t\t\tselect = select.split(',').map(function (sel) {\n\t\t\t\t\t\tif (sel.constructor !== String)\n\t\t\t\t\t\t\tthrow Error('Illegal argument: select array components are expected ot be strings but found ' + (typeof sel));\n\t\t\t\t\t\treturn sel.trim();\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tthrow Error('Illegal argument: select is expected to be string or array of strings but was ' + (typeof select));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t//ensure that joinkeys for required expands are available and not filtered by select\n\t\tif (select !== undefined && expand !== undefined) {\n\t\t\tselect.push(this.orm.getPrimaryKey().name);\n\t\t\t//TODO: checks\n\t\t\t/*for(var i in expand){\n\t\t\t\tvar association = this.orm.associations[expand[i]];\n\t\t\t\tif(association && select.indexOf(association.joinKey)<1){\n\t\t\t\t\tselect.push(association.joinKey);\n\t\t\t\t}\n\t\t\t}*/\n\t\t}\n\t\tlet findQbParams = {\n\t\t\tselect: select\n\t\t};\n\t\tconst parametericStatement = this.ormstatements.find.apply(this.ormstatements, [findQbParams]);\n\t\tlet params = {};\n\n\t\t//prevent implicit type convertion\n\t\tif (this.orm.getPrimaryKey().type.toUpperCase() !== 'VARCHAR')\n\t\t\tid = parseInt(id, 10);\n\n\t\tparams[this.orm.getPrimaryKey().name] = id;\n\t\tconst resultSet = this.execute(parametericStatement, params);\n\n\t\tif (resultSet[0]) {\n\t\t\tentity = this.createEntity(resultSet[0], select);\n\t\t\tif (entity) {\n\t\t\t\tthis.$log.trace('{}[{}] entity found', this.orm.table, id);\n\t\t\t\tthis.notify('afterFound', entity);\n\t\t\t\tif (expand !== undefined) {\n\t\t\t\t\tif (expand.constructor !== Array) {\n\t\t\t\t\t\tif (expand.constructor === String) {\n\t\t\t\t\t\t\texpand = String(expand);\n\t\t\t\t\t\t\texpand = expand.split(',').map(function (exp) {\n\t\t\t\t\t\t\t\tif (exp.constructor !== String)\n\t\t\t\t\t\t\t\t\tthrow Error('Illegal argument: expand array components are expected ot be strings but found ' + (typeof exp));\n\t\t\t\t\t\t\t\treturn exp.trim();\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthrow Error('Illegal argument: expand is expected to be string or array of strings but was ' + (typeof expand));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tvar associationNames = this.orm.getAssociationNames();\n\t\t\t\t\tfor (var idx in associationNames) {\n\t\t\t\t\t\tvar associationName = associationNames[idx];\n\t\t\t\t\t\tif (expand.indexOf(associationName) > -1) {\n\t\t\t\t\t\t\tentity[associationName] = this.expand([associationName], entity);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis.$log.trace('{}[{}] entity not found', this.orm.table, id);\n\t\t\t}\n\t\t}\n\t\treturn entity;\n\t} catch (e) {\n\t\tthis.$log.error(\"Finding {}[{}] entity failed.\", this.orm.table, id, e);\n\t\tthrow e;\n\t}\n};\n\nDAO.prototype.count = function (settings?) {\n\tsettings = settings || {};\n\n\tconst parametericStatement = this.ormstatements.count.apply(this.ormstatements, [settings]);\n\tthis.$log.trace('Counting ' + this.orm.table + ' entities');\n\n\tlet count = 0;\n\ttry {\n\t\tconst rs = this.execute(parametericStatement, settings);\n\t\tif (rs.length > 0) {\n\t\t\t//expectaion is that there is a single object in the result set with a single porperty\n\t\t\tconst key = Object.keys(rs[0])[0];\n\t\t\tcount = parseInt(rs[0][key], 10);\n\t\t}\n\t} catch (e) {\n\t\tthis.$log.error('Counting {} entities failed', this.orm.table, e);\n\t\te.errContext = parametericStatement.toString();\n\t\tthrow e;\n\t}\n\n\tthis.$log.trace('{} {} entities counted', String(count), this.orm.table);\n\n\treturn count;\n};\n\n/*\n * list parameters:\n * - $expand\n * - $filter\n * - $select\n * - $sort\n * - $order\n * - $limit\n * - $offset\n */\nDAO.prototype.list = function (settings) {\n\n\tlet key;\n\tsettings = settings || {};\n\n\tconst expand = settings.$expand || settings.expand;\n\tif (expand !== undefined) {\n\t\tif (expand.constructor !== Array) {\n\t\t\tif (expand.constructor === String) {\n\t\t\t\tif (expand.indexOf(',') > -1) {\n\t\t\t\t\tsettings.$expand = expand.split(',').map(function (exp) {\n\t\t\t\t\t\tif (exp.constructor !== String)\n\t\t\t\t\t\t\tthrow Error('Illegal argument: expand array components are expected ot be strings but found ' + (typeof exp));\n\t\t\t\t\t\treturn exp.trim();\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tsettings.$expand = [expand];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthrow Error('Illegal argument: expand is expected to be string or array of strings but was ' + (typeof expand));\n\t\t\t}\n\t\t}\n\t}\n\n\tconst select = settings.$select || settings.select;\n\tif (select !== undefined) {\n\t\tif (select.constructor !== Array) {\n\t\t\tif (select.constructor === String) {\n\t\t\t\tif (select.indexOf(',') > -1) {\n\t\t\t\t\tsettings.$select = select.split(',').map(function (exp) {\n\t\t\t\t\t\tif (exp.constructor !== String)\n\t\t\t\t\t\t\tthrow Error('Illegal argument: select array components are expected ot be strings but found ' + (typeof exp));\n\t\t\t\t\t\treturn exp.trim();\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tsettings.$select = [select];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthrow Error('Illegal argument: select is expected to be string or array of strings but was ' + (typeof expand));\n\t\t\t}\n\t\t}\n\t}\n\n\n\tconst listArgs = [];\n\tfor (key in settings) {\n\t\tlistArgs.push(' ' + key + '[' + settings[key] + ']');\n\t}\n\n\tthis.$log.trace('Listing {} entity collection with list operators: {}', this.orm.table, listArgs.join(','));\n\n\tif (settings.$select !== undefined && expand !== undefined) {\n\t\tsettings.$select.push(this.orm.getPrimaryKey().name);\n\t}\n\n\tvar parametericStatement = this.ormstatements.list.apply(this.ormstatements, [settings]);\n\n\ttry {\n\t\tlet entities = [];\n\n\t\tconst resultSet = this.execute(parametericStatement, settings);\n\n\t\tresultSet.forEach(function (rsEntry) {\n\t\t\tvar entity = this.createEntity(rsEntry, settings.$select);\n\t\t\tif (expand) {\n\t\t\t\tvar associationNames = this.orm.getAssociationNames();\n\t\t\t\tfor (var idx = 0; idx < associationNames.length; idx++) {\n\t\t\t\t\tvar associationName = associationNames[idx];\n\t\t\t\t\tif (expand.indexOf(associationName) > -1) {\n\t\t\t\t\t\tentity[associationName] = this.expand([associationName], entity);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.notify('afterFound', entity, settings);\n\t\t\tentities.push(entity);\n\t\t}.bind(this));\n\n\t\tthis.$log.trace('{} {} entities found', entities.length, this.orm.table);\n\n\t\treturn entities;\n\t} catch (e) {\n\t\tthis.$log.error(\"Listing {} entities failed.\", this.orm.table, e);\n\t\tthrow e;\n\t}\n};\n\nDAO.prototype.existsTable = function () {\n\tthis.$log.trace('Check exists table ' + this.orm.table);\n\ttry {\n\t\tconst parametericStatement = this.ormstatements.count.apply(this.ormstatements);\n\t\tconst rs = this.execute(parametericStatement);\n\t\treturn rs.length > 0;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nDAO.prototype.createTable = function () {\n\tthis.$log.trace('Creating table {}', this.orm.table);\n\tconst parametericStatement = this.ormstatements.createTable.apply(this.ormstatements);\n\ttry {\n\t\tthis.execute(parametericStatement);\n\t\tthis.$log.trace('{} table created', this.orm.table);\n\t\treturn this;\n\t} catch (e) {\n\t\tthis.$log.error(\"Create table {} failed\", this.orm.table, e);\n\t\tthrow e;\n\t}\n};\n\nDAO.prototype.dropTable = function (dropIdSequence) {\n\tthis.$log.trace('Dropping table {}.', this.orm.table);\n\tconst parametericStatement = this.ormstatements.dropTable.apply(this.ormstatements);\n\ttry {\n\t\tthis.execute(parametericStatement);\n\t\tthis.$log.trace('Table {} dropped.', this.orm.table);\n\t} catch (e) {\n\t\tthis.$log.error(\"Dropping table {} failed.\", this.orm.table, e);\n\t\tthrow e;\n\t}\n\n\tif (dropIdSequence) {\n\t\tthis.$log.trace('Dropping table {} sequence {}.', this.orm.table, this.sequenceName);\n\t\ttry {\n\t\t\tthis.dropIdGenerator();\n\t\t\tthis.$log.trace('Table {} sequence {} dropped.', this.orm.table, this.sequenceName);\n\t\t} catch (e) {\n\t\t\tthis.$log.error(\"Dropping table {} sequence {} failed.\", this.orm.table, this.sequenceName, e);\n\t\t\tthrow e;\n\t\t}\n\t}\n\n\treturn this;\n};\n\n\n/**\n * oDefinition can be table definition or standard orm definition object. Or it can be a valid path to\n * a .table file, or any other text file contianing a standard dao orm definition.\n */\nexport function create(oDefinition, logCtxName?: string, dataSourceName?: string) {\n\tlet orm;\n\torm = oDefinition;\n\n\tif (!dataSourceName || dataSourceName === null) {\n\t\tdataSourceName = configurations.get(\"DIRIGIBLE_DATABASE_DATASOURCE_NAME_DEFAULT\", \"DefaultDB\");\n\t}\n\n\tlet productName = globals.get(dataSourceName);\n\tif (!productName) {\n\t\tproductName = Database.getProductName(dataSourceName);\n\t\tglobals.set(dataSourceName, productName);\n\t}\n\n\t//\t}\n\treturn new DAO(orm, logCtxName, dataSourceName);\n};\n\nexport function dao(oDefinition, logCtxName?: string, dataSourceName?: string) {\n\treturn create(oDefinition, logCtxName, dataSourceName)\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,iBAA6C;AAC7C,2BAA8C;AAC9C,sBAAyB;AACzB,sBAAyB;AACzB,gBAAsB;AACtB,oBAAuB;AACvB,oBAAuB;AACvB,iBAAwB;AACxB,kBAAwC;AAGjC,SAAS,IAAI,KAAoB,YAAqB,gBAAyB;AACrF,MAAI,QAAQ;AACX,UAAM,MAAM,2BAA2B,MAAM,GAAG;AAEjD,OAAK,UAAM,WAAAA,KAAO,GAAG;AACrB,OAAK,eAAe,KAAK,IAAI,QAAQ,MAAM,KAAK,IAAI,cAAc,EAAE,KAAK,YAAY;AACrF,OAAK,kBAAkB,WAAY;AAClC,WAAO,yBAAS,KAAK,KAAK,cAAc,cAAc;AAAA,EACvD;AACA,OAAK,aAAa,WAAY;AAC7B,WAAO,yBAAS,QAAQ,KAAK,cAAc,KAAK,IAAI,OAAO,cAAc;AAAA,EAC1E;AAEA,QAAM,OAAO,yBAAS,cAAc,cAAc;AAClD,MAAI;AACH,SAAK,oBAAgB,qBAAAC,QAAoB,KAAK,KAAK,IAAI;AAAA,EACxD,UAAE;AACD,SAAK,MAAM;AAAA,EACZ;AAGA,MAAI,aAAa;AACjB,MAAI,CAAC,YAAY;AAChB,iBAAa;AACb,QAAI,KAAK,IAAI;AACZ,mBAAa,YAAa,KAAK,IAAI,MAAM,YAAY;AAAA,EACvD;AACA,OAAK,OAAO,mBAAQ,UAAU,UAAU;AAExC,OAAK,UAAU,SAAU,YAAY,mBAAmB;AACvD,UAAM,MAAM,WAAW,MAAM;AAC7B,QAAI,QAAQ,UAAa,IAAI,SAAS;AACrC,YAAM,MAAM,6DAA6D,MAAM,GAAG;AACnF,SAAK,KAAK,MAAM,+BAA+B,GAAG;AAElD,UAAM,aAAa,WAAW,cAAc,WAAW,WAAW;AAClE,UAAM,qBAAqB,CAAC;AAC5B,QAAI,mBAAmB,WAAW,cAAc,WAAW,SAAS,GAAG;AACtE,UAAI,kBAAkB,QAAQ,QAAQ;AACrC,cAAM,iBAAiB,OAAO,KAAK,kBAAkB,QAAQ,MAAM;AACnE,cAAM,sBAAsB,CAAC;AAC7B,mBAAW,QAAQ,OAAK;AACvB,cAAI,eAAe,SAAS,EAAE,IAAI,KAAK,CAAC,oBAAoB,SAAS,EAAE,IAAI,GAAG;AAC7E,kBAAM,QAAQ,kBAAkB,QAAQ,OAAO,EAAE,IAAI;AACrD,gBAAI,MAAM,QAAQ,KAAK,GAAG;AACzB,oBAAM,QAAQ,OAAK;AAClB,mCAAmB,KAAK;AAAA,kBACvB,MAAM,EAAE;AAAA,kBACR,OAAO,WAAW,EAAE,MAAM,CAAC;AAAA,gBAC5B,CAAC;AAAA,cACF,CAAC;AAAA,YACF,OAAO;AACN,iCAAmB,KAAK;AAAA,gBACvB,MAAM,EAAE;AAAA,gBACR,OAAO,WAAW,EAAE,MAAM,KAAK;AAAA,cAChC,CAAC;AAAA,YACF;AACA,gCAAoB,KAAK,EAAE,IAAI;AAAA,UAChC;AAAA,QACD,CAAC;AAAA,MACF;AACA,UAAI,kBAAkB,QAAQ,WAAW;AACxC,cAAM,iBAAiB,OAAO,KAAK,kBAAkB,QAAQ,SAAS;AACtE,cAAM,sBAAsB,CAAC;AAC7B,mBAAW,QAAQ,OAAK;AACvB,cAAI,eAAe,SAAS,EAAE,IAAI,KAAK,CAAC,oBAAoB,SAAS,EAAE,IAAI,GAAG;AAC7E,kBAAM,QAAQ,kBAAkB,QAAQ,UAAU,EAAE,IAAI;AACxD,gBAAI,MAAM,QAAQ,KAAK,GAAG;AACzB,oBAAM,QAAQ,OAAK;AAClB,mCAAmB,KAAK;AAAA,kBACvB,MAAM,EAAE;AAAA,kBACR,OAAO,WAAW,EAAE,MAAM,CAAC;AAAA,gBAC5B,CAAC;AAAA,cACF,CAAC;AAAA,YACF,OAAO;AACN,iCAAmB,KAAK;AAAA,gBACvB,MAAM,EAAE;AAAA,gBACR,OAAO,WAAW,EAAE,MAAM,KAAK;AAAA,cAChC,CAAC;AAAA,YACF;AACA,gCAAoB,KAAK,EAAE,IAAI;AAAA,UAChC;AAAA,QACD,CAAC;AAAA,MACF;AACA,UAAI,kBAAkB,QAAQ,UAAU;AACvC,cAAM,iBAAiB,OAAO,KAAK,kBAAkB,QAAQ,QAAQ;AACrE,cAAM,sBAAsB,CAAC;AAC7B,mBAAW,QAAQ,OAAK;AACvB,cAAI,eAAe,SAAS,EAAE,IAAI,KAAK,CAAC,oBAAoB,SAAS,EAAE,IAAI,GAAG;AAC7E,+BAAmB,KAAK;AAAA,cACvB,MAAM,EAAE;AAAA,cACR,OAAO,IAAI,kBAAkB,QAAQ,SAAS,EAAE,IAAI,CAAC;AAAA,YACtD,CAAC;AACD,gCAAoB,KAAK,EAAE,IAAI;AAAA,UAChC;AAAA,QACD,CAAC;AAAA,MACF;AACA,UAAI,kBAAkB,QAAQ,aAAa;AAC1C,cAAM,iBAAiB,OAAO,KAAK,kBAAkB,QAAQ,WAAW;AACxE,cAAM,sBAAsB,CAAC;AAC7B,mBAAW,QAAQ,OAAK;AACvB,cAAI,eAAe,SAAS,EAAE,IAAI,KAAK,CAAC,oBAAoB,SAAS,EAAE,IAAI,GAAG;AAC7E,+BAAmB,KAAK;AAAA,cACvB,MAAM,EAAE;AAAA,cACR,OAAO,WAAW,EAAE,MAAM,kBAAkB,QAAQ,YAAY,EAAE,IAAI,CAAC;AAAA,YACxE,CAAC;AACD,gCAAoB,KAAK,EAAE,IAAI;AAAA,UAChC;AAAA,QACD,CAAC;AAAA,MACF;AACA,UAAI,kBAAkB,QAAQ,UAAU;AACvC,cAAM,iBAAiB,OAAO,KAAK,kBAAkB,QAAQ,QAAQ;AACrE,cAAM,sBAAsB,CAAC;AAC7B,mBAAW,QAAQ,OAAK;AACvB,cAAI,eAAe,SAAS,EAAE,IAAI,KAAK,CAAC,oBAAoB,SAAS,EAAE,IAAI,GAAG;AAC7E,+BAAmB,KAAK;AAAA,cACvB,MAAM,EAAE;AAAA,cACR,OAAO,WAAW,EAAE,MAAM,kBAAkB,QAAQ,SAAS,EAAE,IAAI,CAAC;AAAA,YACrE,CAAC;AACD,gCAAoB,KAAK,EAAE,IAAI;AAAA,UAChC;AAAA,QACD,CAAC;AAAA,MACF;AACA,UAAI,kBAAkB,QAAQ,oBAAoB;AACjD,cAAM,iBAAiB,OAAO,KAAK,kBAAkB,QAAQ,kBAAkB;AAC/E,cAAM,sBAAsB,CAAC;AAC7B,mBAAW,QAAQ,OAAK;AACvB,cAAI,eAAe,SAAS,EAAE,IAAI,KAAK,CAAC,oBAAoB,SAAS,EAAE,IAAI,GAAG;AAC7E,+BAAmB,KAAK;AAAA,cACvB,MAAM,EAAE;AAAA,cACR,OAAO,WAAW,EAAE,MAAM,kBAAkB,QAAQ,mBAAmB,EAAE,IAAI,CAAC;AAAA,YAC/E,CAAC;AACD,gCAAoB,KAAK,EAAE,IAAI;AAAA,UAChC;AAAA,QACD,CAAC;AAAA,MACF;AACA,UAAI,kBAAkB,QAAQ,iBAAiB;AAC9C,cAAM,iBAAiB,OAAO,KAAK,kBAAkB,QAAQ,eAAe;AAC5E,cAAM,sBAAsB,CAAC;AAC7B,mBAAW,QAAQ,OAAK;AACvB,cAAI,eAAe,SAAS,EAAE,IAAI,KAAK,CAAC,oBAAoB,SAAS,EAAE,IAAI,GAAG;AAC7E,+BAAmB,KAAK;AAAA,cACvB,MAAM,EAAE;AAAA,cACR,OAAO,WAAW,EAAE,MAAM,kBAAkB,QAAQ,gBAAgB,EAAE,IAAI,CAAC;AAAA,YAC5E,CAAC;AACD,gCAAoB,KAAK,EAAE,IAAI;AAAA,UAChC;AAAA,QACD,CAAC;AAAA,MACF;AAAA,IACD;AAGA,QAAI,cAAc,WAAW,SAAS,GAAG;AACxC,eAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AAC3C,YAAI;AACJ,YAAI,mBAAmB;AACtB,cAAI,MAAM,QAAQ,iBAAiB,GAAG;AACrC,kBAAM,kBAAkB,CAAC;AAAA,UAC1B,OAAO;AACN,kBAAM,kBAAkB,WAAW,CAAC,EAAE,IAAI;AAAA,UAC3C;AAAA,QACD;AACA,aAAK,QAAQ,QAAQ,QAAQ,WAAc,IAAI,YAAY,EAAE,WAAW,QAAQ,GAAG;AAClF;AAAA,QACD;AACA,cAAM,QAAQ,IAAI;AAClB,aAAK,KAAK,MAAM,gCAAgC,OAAO,GAAG;AAC1D,2BAAmB,KAAK;AAAA,UACvB,QAAQ,WAAW,CAAC,EAAE;AAAA,UACtB,SAAS,WAAW,WAAW,CAAC,EAAE,MAAM,GAAG;AAAA,QAC5C,CAAC;AAAA,MACF;AAAA,IACD;AAEA,QAAI;AAEJ,QAAI,IAAI,YAAY,EAAE,WAAW,QAAQ,GAAG;AAC3C,eAAS,gBAAM,QAAQ,KAAK,oBAAoB,cAAc;AAAA,IAC/D,WAAW,IAAI,YAAY,EAAE,WAAW,QAAQ,GAAG;AAClD,eAAS,qBAAO,QAAQ,KAAK,oBAAoB,cAAc;AAAA,IAChE,OAAO;AACN,eAAS,qBAAO,QAAQ,KAAK,oBAAoB,cAAc;AAAA,IAChE;AAEA,WAAO,WAAW,OAAO,SAAS,CAAC;AAAA,EACpC;AAEA,WAAS,WAAW,MAAM,OAAO;AAChC,YAAQ,KAAK,YAAY,GAAG;AAAA,MAC3B,KAAK;AACJ,eAAO,SAAS,KAAK;AAAA,MACtB,KAAK;AAAA,MACL,KAAK;AACJ,eAAO,WAAW,KAAK;AAAA,MACxB,KAAK;AACJ,eAAO,QAAQ,SAAS;AAAA,MACzB;AACC,eAAO;AAAA,IACT;AAAA,EACD;AACD;AAAC;AAED,IAAI,UAAU,SAAS,SAAU,OAAO;AACvC,QAAM,OAAO,KAAK,KAAK;AACvB,MAAI,CAAC,KAAK,KAAK;AACd;AACD,MAAI,OAAO,SAAS;AACnB,UAAM,MAAM,uCAAuC,IAAI;AACxD,QAAM,OAAO,CAAC,EAAE,MAAM,KAAK,SAAS;AACpC,OAAK,MAAM,MAAM,KAAK,MAAM,CAAC,CAAC;AAC/B;AAKA,IAAI,UAAU,kBAAkB,SAAU,QAAQ;AACjD,MAAI;AACJ,QAAM,iBAAiB,CAAC;AACxB,QAAM,cAAc,KAAK,IAAI,uBAAuB;AACpD,OAAK,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AACxC,QAAI,YAAY,CAAC,EAAE,SAAS;AAC3B,qBAAe,YAAY,CAAC,EAAE,IAAI,IAAI,YAAY,CAAC,EAAE,QAAQ,MAAM,MAAM,CAAC,OAAO,YAAY,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;AAAA,IAC/G,OAAO;AACN,qBAAe,YAAY,CAAC,EAAE,IAAI,IAAI,OAAO,YAAY,CAAC,EAAE,IAAI;AAAA,IACjE;AAAA,EACD;AACA,QAAM,YAAY,KAAK,IAAI,sBAAsB;AACjD,OAAK,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACtC,QAAI,UAAU,CAAC,EAAE,YAAY,QAAW;AACvC,qBAAe,UAAU,CAAC,EAAE,IAAI,IAAI,UAAU,CAAC,EAAE,QAAQ,MAAM,MAAM,CAAC,OAAO,UAAU,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;AAAA,IACzG,OAAO;AACN,qBAAe,UAAU,CAAC,EAAE,IAAI,IAAI,OAAO,UAAU,CAAC,EAAE,IAAI,MAAM,SAAY,OAAO,OAAO,UAAU,CAAC,EAAE,IAAI;AAAA,IAC9G;AAAA,EACD;AACA,SAAO;AACR;AAKA,IAAI,UAAU,eAAe,SAAU,gBAAgB,qBAAqB;AAC3E,QAAM,SAAS,CAAC;AAChB,MAAI,aAAa,KAAK,IAAI;AAC1B,MAAI,uBAAuB,oBAAoB,SAAS,GAAG;AAC1D,iBAAa,WAAW,OAAO,SAAU,MAAM;AAC9C,aAAO,oBAAoB,QAAQ,KAAK,IAAI,IAAI;AAAA,IACjD,CAAC;AAAA,EACF;AACA,WAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AAC3C,UAAM,OAAO,WAAW,CAAC;AACzB,WAAO,KAAK,IAAI,IAAI,eAAe,KAAK,UAAU;AAClD,QAAI,KAAK,OAAO;AACf,aAAO,KAAK,IAAI,IAAI,KAAK,MAAM,OAAO,KAAK,IAAI,CAAC;AAAA,IACjD;AAAA,EACD;AACA,SAAO,KAAK,MAAM,EAAE,QAAQ,SAAU,cAAc;AACnD,QAAI,OAAO,YAAY,MAAM;AAC5B,aAAO,YAAY,IAAI;AAAA,EACzB,CAAC;AAED,MAAI,gBAAgB;AACpB,MAAI,OAAO,KAAK,IAAI,cAAc,EAAE,IAAI,GAAG;AAC1C,oBAAgB,MAAM,OAAO,KAAK,IAAI,cAAc,EAAE,IAAI,IAAI;AAAA,EAC/D;AAEA,SAAO;AACR;AAEA,IAAI,UAAU,iBAAiB,SAAU,QAAQ,MAAM;AACtD,MAAI,WAAW,UAAa,WAAW,MAAM;AAC5C,UAAM,IAAI,MAAM,iCAAiC,MAAM;AAAA,EACxD;AACA,MAAI,MAAM;AACT,QAAI,KAAK,gBAAgB,OAAO;AAC/B,aAAO,CAAC,IAAI;AAAA,IACb;AACA,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACrC,WAAK,CAAC;AAAA,IACP;AAAA,EACD;AACA,QAAM,cAAc,KAAK,IAAI,uBAAuB;AACpD,WAAS,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AAC5C,UAAM,WAAW,YAAY,CAAC,EAAE;AAChC,QAAK,QAAQ,KAAK,QAAQ,QAAQ,IAAI,MAAO,YAAY,CAAC,EAAE,KAAK,YAAY,MAAM;AAClF;AACD,UAAM,YAAY,OAAO,QAAQ;AACjC,QAAI,cAAc,UAAa,cAAc,MAAM;AAClD,YAAM,IAAI,MAAM,aAAa,WAAW,yBAAyB,KAAK,IAAI,QAAQ,cAAc,SAAS;AAAA,IAC1G;AAAA,EACD;AACD;AAEA,IAAI,UAAU,SAAS,SAAU,SAAS;AAEzC,QAAM,MAAM,CAAC;AACb,MAAI,WAAW;AACf,MAAI,QAAQ,gBAAgB,OAAO;AAClC,eAAW,CAAC,OAAO;AAAA,EACpB;AAEA,OAAK,KAAK,MAAM,mBAAmB,KAAK,IAAI,OAAQ,SAAS,WAAW,IAAI,WAAW,UAAW;AAElG,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACzC,QAAI,SAAS,SAAS,CAAC;AACvB,aAAS,SAAS,CAAC;AAEnB,SAAK,eAAe,QAAQ,CAAC,KAAK,IAAI,cAAc,EAAE,IAAI,CAAC;AAG3D,UAAM,UAAU,KAAK,IAAI,oBAAoB;AAC7C,aAAS,KAAK,GAAG,KAAK,QAAQ,QAAQ,MAAM;AAC3C,YAAM,OAAO,QAAQ,EAAE;AACvB,YAAM,KAAK,KAAK,cAAc,QAC5B,OAAO,KAAK,MAAM,EAClB,KAAK,KAAK,IAAI,KAAK,EACnB,MAAM,KAAK,SAAS,MAAM,CAAC,IAAI,CAAC;AAClC,YAAM,SAAS,CAAC;AAChB,aAAO,KAAK,IAAI,IAAI,OAAO,KAAK,IAAI;AACpC,YAAM,KAAK,KAAK,QAAQ,IAAI,MAAM;AAClC,UAAI,GAAG,SAAS;AACf,cAAM,MAAM,qCAAqC,KAAK,OAAO,MAAM,OAAO,KAAK,IAAI,IAAI,GAAG;AAAA,IAC5F;AAEA,UAAM,WAAW,KAAK,gBAAgB,MAAM;AAE5C,QAAI;AACH,YAAM,uBAAuB,KAAK,cAAc,OAAO,MAAM,KAAK,aAAa;AAE/E,UAAI,KAAK,IAAI,0BAA0B,GAAG;AACzC,cAAM,KAAK,KAAK,WAAW;AAC3B,iBAAS,KAAK,IAAI,cAAc,EAAE,IAAI,IAAI;AAAA,MAC3C;AAEA,YAAM,qBAAqB,KAAK,QAAQ,sBAAsB,QAAQ;AAEtE,UAAI,CAAC,KAAK,IAAI,0BAA0B,KAAK,gBAAgB,kBAAkB,GAAG;AACjF,cAAM,KAAK,mBAAmB,CAAC;AAC/B,iBAAS,KAAK,IAAI,cAAc,EAAE,IAAI,IAAI;AAAA,MAC3C;AAEA,WAAK,OAAO,eAAe,QAAQ;AACnC,WAAK,OAAO,+BAA+B,QAAQ;AACnD,WAAK,qBAAqB,KAAK,gBAAgB,kBAAkB,MAAM,KAAK,IAAI,gBAAgB,OAAO,KAAK,KAAK,IAAI,YAAY,EAAE,QAAQ;AAE1I,aAAK,KAAK,MAAM,yCAAyC,KAAK,IAAI,OAAO,SAAS,KAAK,IAAI,cAAc,EAAE,IAAI,CAAC;AAChH,mBAAW,OAAO,OAAO,KAAK,KAAK,IAAI,YAAY,GAAG;AACrD,gBAAM,cAAc,KAAK,IAAI,aAAa,GAAG;AAC7C,gBAAM,kBAAkB,YAAY,MAAM;AAC1C,cAAI,CAAC,KAAK,IAAI,kBAAkB,cAAc,GAAG,KAAK,IAAI,kBAAkB,aAAa,CAAC,EAAE,QAAQ,YAAY,IAAI,IAAI,GAAG;AAC1H,gBAAI,OAAO,eAAe,KAAK,OAAO,eAAe,EAAE,SAAS,GAAG;AAClE,oBAAM,4BAA4B,YAAY,aAAa;AAC3D,kBAAI,0BAA0B,gBAAgB;AAC7C,sBAAM,MAAM,8BAA8B,kBAAkB,+DAAgE,OAAO,yBAA0B;AAC9J,oBAAM,iBAAiB,0BAA0B,MAAM,IAAI;AAC3D,mBAAK,OAAO,8BAA8B,OAAO,eAAe,GAAG,MAAM;AACzE,mBAAK,KAAK,MAAM,wDAAwD,OAAO,eAAe,EAAE,QAAQ,eAAe;AACvH,uBAAS,IAAI,GAAG,IAAI,OAAO,eAAe,EAAE,QAAQ,KAAK;AACxD,sBAAM,mBAAmB,OAAO,eAAe,EAAE,CAAC;AAClD,sBAAM,0BAA0B,YAAY;AAC5C,sBAAM,MAAM,YAAY,OAAO,KAAK,IAAI,cAAc,EAAE;AACxD,iCAAiB,uBAAuB,IAAI,OAAO,GAAG;AACtD,qBAAK,OAAO,oCAAoC,OAAO,eAAe,GAAG,QAAQ;AAEjF,+BAAe,OAAO,MAAM,gBAAgB,CAAC,gBAAgB,CAAC;AAAA,cAE/D;AACA,mBAAK,KAAK,MAAM,iEAAiE,OAAO,eAAe,EAAE,QAAQ,eAAe;AAChI,mBAAK,OAAO,6BAA6B,OAAO,eAAe,GAAG,QAAQ;AAAA,YAC3E;AAAA,UACD;AAAA,QACD;AAAA,MACD;AAEA,UAAI,qBAAqB,KAAK,gBAAgB,kBAAkB,GAAG;AAClE,YAAI,KAAK,SAAS,KAAK,IAAI,cAAc,EAAE,IAAI,CAAC;AAChD,aAAK,KAAK,MAAM,wBAAwB,KAAK,IAAI,OAAO,SAAS,KAAK,IAAI,cAAc,EAAE,IAAI,CAAC;AAAA,MAChG,OAAO;AACN,aAAK,KAAK,MAAM,6BAA6B,KAAK,IAAI,KAAK;AAAA,MAC5D;AAAA,IAGD,SAAS,GAAG;AACX,WAAK,KAAK,MAAM,0BAA0B,KAAK,IAAI,OAAQ,SAAS,WAAW,IAAI,WAAW,YAAa,CAAC;AAC5G,WAAK,KAAK,MAAM,qDAAqD,KAAK,IAAI,OAAO,SAAS,KAAK,IAAI,cAAc,EAAE,IAAI,CAAC;AAC5H,UAAI,SAAS,KAAK,IAAI,cAAc,EAAE,IAAI,GAAG;AAC5C,YAAI;AACH,eAAK,OAAO,SAAS,KAAK,IAAI,cAAc,EAAE,IAAI,CAAC;AAAA,QACpD,SAAS,KAAK;AACb,eAAK,KAAK,MAAM,2DAA2D,KAAK,IAAI,OAAO,SAAS,KAAK,IAAI,cAAc,EAAE,IAAI,GAAG,GAAG;AAAA,QACxI;AAAA,MACD;AACA,YAAM;AAAA,IACP;AAAA,EACD;AAEA,MAAI,QAAQ,gBAAgB;AAC3B,WAAO,IAAI,CAAC;AAAA;AAEZ,WAAO;AACT;AAEA,SAAS,gBAAgB,OAAO;AAC/B,SAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS;AAC/C;AAKA,IAAI,UAAU,SAAS,SAAU,QAAQ;AAExC,OAAK,KAAK,MAAM,0BAA0B,KAAK,IAAI,OAAO,WAAW,SAAY,OAAO,KAAK,IAAI,cAAc,EAAE,IAAI,IAAI,MAAM;AAE/H,MAAI,WAAW,UAAa,WAAW,MAAM;AAC5C,UAAM,IAAI,MAAM,iCAAiC,MAAM;AAAA,EACxD;AAEA,QAAM,oBAAoB,KAAK,IAAI,uBAAuB,EACxD,OAAO,SAAU,UAAU;AAC3B,WAAO,SAAS,cAAc,SAAS,WAAW,QAAQ,QAAQ,IAAI;AAAA,EACvE,CAAC,EACA,IAAI,SAAU,UAAU;AACxB,WAAO,SAAS;AAAA,EACjB,CAAC;AACF,OAAK,eAAe,QAAQ,iBAAiB;AAE7C,QAAM,uBAAuB,KAAK,cAAc,OAAO,MAAM,KAAK,eAAe,CAAC,MAAM,CAAC;AAEzF,QAAM,WAAW,KAAK,gBAAgB,MAAM;AAE5C,MAAI;AACH,SAAK,OAAO,sBAAsB,QAAQ;AAC1C,UAAM,sBAAsB,KAAK,QAAQ,sBAAsB,QAAQ;AACvE,QAAI,sBAAsB;AACzB,WAAK,KAAK,MAAM,yBAAyB,KAAK,IAAI,OAAO,SAAS,KAAK,IAAI,cAAc,EAAE,IAAI,CAAC;AAAA;AAEhG,WAAK,KAAK,MAAM,6BAA6B,KAAK,IAAI,KAAK;AAE5D,WAAO;AAAA,EAER,SAAS,GAAG;AACX,SAAK,KAAK,MAAM,0BAA0B,KAAK,IAAI,OAAO,WAAW,SAAY,OAAO,KAAK,IAAI,cAAc,EAAE,IAAI,IAAI,QAAQ,CAAC;AAClI,UAAM;AAAA,EACP;AACD;AAKA,IAAI,UAAU,SAAS,WAAY;AAElC,MAAI,MAAM,CAAC;AACX,MAAI,UAAU,WAAW,GAAG;AAC3B,UAAM,KAAK,KAAK;AAAA,MACf,WAAW,CAAC,KAAK,IAAI,cAAc,EAAE,IAAI;AAAA,IAC1C,CAAC,EAAE,IAAI,SAAU,KAAK;AACrB,aAAO,IAAI,KAAK,IAAI,cAAc,EAAE,IAAI;AAAA,IACzC,EAAE,KAAK,IAAI,CAAC;AAAA,EACb,OAAO;AACN,QAAI,UAAU,CAAC,EAAE,gBAAgB,OAAO;AACvC,YAAM,CAAC,UAAU,CAAC,CAAC;AAAA,IACpB,OAAO;AACN,YAAM,UAAU,CAAC;AAAA,IAClB;AAAA,EACD;AAEA,OAAK,KAAK,MAAM,cAAc,KAAK,IAAI,SAAU,QAAQ,UAAa,IAAI,WAAW,IAAK,MAAM,IAAI,CAAC,IAAI,aAAa,IAAI,SAAS,YAAY;AAE/I,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AAEpC,QAAI,KAAK,IAAI,CAAC;AAEd,QAAI,KAAK,IAAI,cAAc,EAAE,KAAK,YAAY,MAAM;AACnD,WAAK,SAAS,IAAI,EAAE;AAErB,QAAI,IAAI,SAAS;AAChB,WAAK,KAAK,MAAM,0BAA0B,KAAK,IAAI,OAAO,EAAE;AAE7D,QAAI,OAAO,UAAa,OAAO,MAAM;AACpC,YAAM,IAAI,MAAM,uCAAuC,EAAE;AAAA,IAC1D;AAEA,QAAI;AAEH,WAAK,OAAO,sBAAsB,EAAE;AAGpC,UAAI,KAAK,IAAI,cAAc;AAE1B,mBAAW,OAAO,OAAO,KAAK,KAAK,IAAI,YAAY,GAAG;AACrD,gBAAM,cAAc,KAAK,IAAI,aAAa,GAAG;AAC7C,gBAAM,kBAAkB,YAAY,MAAM;AAC1C,cAAI,CAAC,KAAK,IAAI,kBAAkB,cAAc,GAAG,KAAK,IAAI,kBAAkB,aAAa,CAAC,EAAE,QAAQ,YAAY,IAAI,IAAI,GAAG;AAC1H,iBAAK,KAAK,MAAM,uEAAuE,KAAK,IAAI,OAAO,IAAI,eAAe;AAC1H,kBAAM,iBAAiB,YAAY,YAAY,YAAY,UAAU,IAAI;AACzE,kBAAM,WAAW,CAAC;AAClB,gBAAI,SAAS;AAEb,gBAAI,YAAY,QAAQ,QAAW;AAClC,kBAAI,YAAY,KAAK,KAAK,EAAE;AAC5B,uBAAS,UAAU,YAAY,GAAG;AAAA,YACnC;AACA,qBAAS,YAAY,OAAO,IAAI;AAChC,gBAAI;AAEJ,iCAAqB,eAAe,KAAK,QAAQ;AACjD,gBAAI,sBAAsB,mBAAmB,SAAS,GAAG;AACxD,mBAAK,KAAK,MAAM,4CAA4C,KAAK,IAAI,OAAO,IAAI,mBAAmB,QAAQ,eAAe;AAC1H,mBAAK,OAAO,8BAA8B,oBAAoB,EAAE;AAChE,uBAAS,IAAI,GAAG,IAAI,mBAAmB,QAAQ,KAAK;AACnD,sBAAM,mBAAmB,mBAAmB,CAAC;AAC7C,qBAAK,OAAO,oCAAoC,kBAAkB,oBAAoB,EAAE;AAExF,+BAAe,OAAO,MAAM,gBAAgB,CAAC,iBAAiB,eAAe,IAAI,cAAc,EAAE,IAAI,CAAC,CAAC;AAAA,cAExG;AACA,mBAAK,KAAK,MAAM,+CAA+C,KAAK,IAAI,OAAO,IAAI,mBAAmB,QAAQ,iBAAiB,mBAAmB,SAAS,IAAI,aAAa,QAAQ;AAAA,YACrL;AAAA,UACD;AAAA,QACD;AAAA,MACD;AAEA,YAAM,uBAAuB,KAAK,cAAc,QAAQ,EAAE,MAAM,KAAK,eAAe,CAAC,KAAK,IAAI,cAAc,EAAE,IAAI,CAAC;AACnH,UAAI,SAAS,CAAC;AACd,aAAO,KAAK,IAAI,cAAc,EAAE,IAAI,IAAI;AAExC,YAAM,sBAAsB,KAAK,QAAQ,sBAAsB,MAAM;AAErE,UAAI,sBAAsB;AACzB,aAAK,KAAK,MAAM,yBAAyB,KAAK,IAAI,OAAO,EAAE;AAAA;AAE3D,aAAK,KAAK,MAAM,6BAA6B,KAAK,IAAI,KAAK;AAAA,IAE7D,SAAS,GAAG;AACX,WAAK,KAAK,MAAM,iCAAgC,KAAK,IAAI,OAAO,IAAI,CAAC;AACrE,YAAM;AAAA,IACP;AAAA,EAED;AAED;AAEA,IAAI,UAAU,SAAS,SAAU,eAAe,SAAS;AACxD,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,OAAK,KAAK,MAAM,2DAA2D,gBAAgB,OAAO,UAAU,CAAC,MAAM,WAAW,QAAQ,MAAM,KAAK,UAAU,UAAU,CAAC,CAAC,CAAC;AACxK,MAAI,CAAC,iBAAiB,CAAC,cAAc,QAAQ;AAC5C,UAAM,IAAI,MAAM,qCAAqC,gBAAgB,GAAG;AAAA,EACzE;AACA,MAAI,CAAC,SAAS;AACb,UAAM,IAAI,MAAM,+BAA+B,UAAU,GAAG;AAAA,EAC7D;AACA,QAAM,kBAAkB,cAAc,SAAS,cAAc,OAAO,GAAG,CAAC,EAAE,CAAC,IAAI;AAC/E,QAAM,cAAc,KAAK,IAAI,eAAe,eAAe;AAC3D,MAAI,CAAC,mBAAmB,CAAC;AACxB,UAAM,IAAI,MAAM,yDAAyD,kBAAkB,GAAG;AAC/F,QAAM,UAAU,YAAY;AAE5B,MAAI;AACJ,MAAI,QAAQ,KAAK,IAAI,cAAc,EAAE,IAAI,MAAM,QAAW;AACzD,oBAAgB;AAAA,EACjB,OAAO;AACN,oBAAgB,KAAK,KAAK,OAAO;AAAA,EAClC;AAEA,MAAI,CAAC,eAAe;AACnB,UAAM,MAAM,yCAAyC,UAAU,GAAG;AAAA,EACnE;AAEA,QAAM,uBAAuB,YAAY,YAAY,YAAY,UAAU,MAAM,IAAI,IAAI;AACzF,MAAI,CAAC;AACJ,UAAM,MAAM,kEAAkE,eAAe;AAE9F,MAAI;AACJ,MAAI,sBAAsB,CAAC;AAE3B,MAAI,YAAY,SAAS,KAAK,IAAI,kBAAkB,YAAY,KAAK,YAAY,SAAS,KAAK,IAAI,kBAAkB,aAAa,GAAG;AACpI,aAAS,cAAc,OAAO;AAC9B,SAAK,KAAK,MAAM,2CAA2C,YAAY,MAAM,SAAS,MAAM;AAC5F,QAAI,CAAC,YAAY,OAAO,YAAY,QAAQ,qBAAqB,IAAI,cAAc,EAAE;AACpF,kBAAY,qBAAqB,KAAK,MAAM,sBAAsB,CAAC,MAAM,CAAC;AAAA,SACtE;AACJ,UAAI,eAAe,CAAC;AACpB,mBAAa,SAAS,IAAI,YAAY;AACtC,mBAAa,YAAY,GAAG,IAAI;AAChC,kBAAY,qBAAqB,KAAK,MAAM,sBAAsB,CAAC,YAAY,CAAC,EAAE,CAAC;AAAA,IACpF;AAEA,QAAI,cAAc,SAAS,GAAG;AAC7B,WAAK,OAAO,eAAe,SAAS;AAAA,IACrC;AAAA,EACD,WAAW,YAAY,SAAS,KAAK,IAAI,kBAAkB,aAAa,GAAG;AAC1E,eAAW,CAAC;AACZ,QAAI,YAAY;AACf,iBAAW,YAAY;AACxB,UAAM,YAAY,OAAO,KAAK,IAAI,cAAc,EAAE;AAClD,aAAS,cAAc,GAAG;AAC1B,SAAK,KAAK,MAAM,2CAA2C,YAAY,MAAM,SAAS,MAAM;AAC5F,aAAS,OAAO,IAAI;AACpB,0BAAsB,oBAAoB,OAAO,qBAAqB,KAAK,MAAM,sBAAsB,CAAC,QAAQ,CAAC,CAAC;AAElH,QAAI,cAAc,SAAS,GAAG;AAC7B,WAAK,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;AAChD,aAAK,OAAO,eAAe,oBAAoB,CAAC,CAAC;AAAA,MAClD;AAAA,IACD,OAAO;AACN,kBAAY;AAAA,IACb;AAAA,EACD,WAAW,YAAY,SAAS,KAAK,IAAI,kBAAkB,cAAc,GAAG;AAC3E,UAAM,UAAU,YAAY,QAAQ;AACpC,QAAI,CAAC;AACJ,YAAM,MAAM,oDAAoD,eAAe;AAChF,QAAI,CAAC,QAAQ;AACZ,YAAM,MAAM,0EAA0E,eAAe;AACtG,eAAW,CAAC;AACZ,UAAM,YAAY,OAAO,KAAK,IAAI,cAAc,EAAE;AAClD,aAAS,cAAc,GAAG;AAC1B,aAAS,YAAY,OAAO,IAAI;AAChC,0BAAsB,oBAAoB,OAAO,QAAQ,UAAU,MAAM,SAAS,CAAC,UAAU,EAAE,aAAa,MAAM,WAAW,SAAS,aAAa,qBAAqB,CAAC,CAAC,CAAC;AAC3K,QAAI,cAAc,SAAS,GAAG;AAC7B,WAAK,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;AAChD,aAAK,OAAO,eAAe,oBAAoB,CAAC,CAAC;AAAA,MAClD;AAAA,IACD,OAAO;AACN,kBAAY;AAAA,IACb;AAAA,EACD;AACA,SAAO;AACR;AAOA,IAAI,UAAU,OAAO,SAAU,IAAI,QAAQ,QAAQ;AAClD,MAAI,OAAO,UAAU,CAAC,MAAM,UAAU;AACrC,SAAK,UAAU,CAAC,EAAE;AAClB,aAAS,UAAU,CAAC,EAAE,WAAW,UAAU,CAAC,EAAE;AAC9C,aAAS,UAAU,CAAC,EAAE,WAAW,UAAU,CAAC,EAAE;AAAA,EAC/C;AAEA,OAAK,KAAK,MAAM,qEAAqE,KAAK,IAAI,OAAO,IAAI,QAAQ,MAAM;AAEvH,MAAI,OAAO,UAAa,OAAO,MAAM;AACpC,UAAM,IAAI,MAAM,uCAAuC,EAAE;AAAA,EAC1D;AAEA,MAAI;AACH,QAAI;AACJ,QAAI,WAAW,QAAW;AACzB,UAAI,OAAO,gBAAgB,OAAO;AACjC,YAAI,OAAO,gBAAgB,QAAQ;AAClC,mBAAS,OAAO,MAAM,GAAG,EAAE,IAAI,SAAU,KAAK;AAC7C,gBAAI,IAAI,gBAAgB;AACvB,oBAAM,MAAM,oFAAqF,OAAO,GAAI;AAC7G,mBAAO,IAAI,KAAK;AAAA,UACjB,CAAC;AAAA,QACF,OAAO;AACN,gBAAM,MAAM,mFAAoF,OAAO,MAAO;AAAA,QAC/G;AAAA,MACD;AAAA,IACD;AAEA,QAAI,WAAW,UAAa,WAAW,QAAW;AACjD,aAAO,KAAK,KAAK,IAAI,cAAc,EAAE,IAAI;AAAA,IAQ1C;AACA,QAAI,eAAe;AAAA,MAClB;AAAA,IACD;AACA,UAAM,uBAAuB,KAAK,cAAc,KAAK,MAAM,KAAK,eAAe,CAAC,YAAY,CAAC;AAC7F,QAAI,SAAS,CAAC;AAGd,QAAI,KAAK,IAAI,cAAc,EAAE,KAAK,YAAY,MAAM;AACnD,WAAK,SAAS,IAAI,EAAE;AAErB,WAAO,KAAK,IAAI,cAAc,EAAE,IAAI,IAAI;AACxC,UAAM,YAAY,KAAK,QAAQ,sBAAsB,MAAM;AAE3D,QAAI,UAAU,CAAC,GAAG;AACjB,eAAS,KAAK,aAAa,UAAU,CAAC,GAAG,MAAM;AAC/C,UAAI,QAAQ;AACX,aAAK,KAAK,MAAM,uBAAuB,KAAK,IAAI,OAAO,EAAE;AACzD,aAAK,OAAO,cAAc,MAAM;AAChC,YAAI,WAAW,QAAW;AACzB,cAAI,OAAO,gBAAgB,OAAO;AACjC,gBAAI,OAAO,gBAAgB,QAAQ;AAClC,uBAAS,OAAO,MAAM;AACtB,uBAAS,OAAO,MAAM,GAAG,EAAE,IAAI,SAAU,KAAK;AAC7C,oBAAI,IAAI,gBAAgB;AACvB,wBAAM,MAAM,oFAAqF,OAAO,GAAI;AAC7G,uBAAO,IAAI,KAAK;AAAA,cACjB,CAAC;AAAA,YACF,OAAO;AACN,oBAAM,MAAM,mFAAoF,OAAO,MAAO;AAAA,YAC/G;AAAA,UACD;AACA,cAAI,mBAAmB,KAAK,IAAI,oBAAoB;AACpD,mBAAS,OAAO,kBAAkB;AACjC,gBAAI,kBAAkB,iBAAiB,GAAG;AAC1C,gBAAI,OAAO,QAAQ,eAAe,IAAI,IAAI;AACzC,qBAAO,eAAe,IAAI,KAAK,OAAO,CAAC,eAAe,GAAG,MAAM;AAAA,YAChE;AAAA,UACD;AAAA,QACD;AAAA,MACD,OAAO;AACN,aAAK,KAAK,MAAM,2BAA2B,KAAK,IAAI,OAAO,EAAE;AAAA,MAC9D;AAAA,IACD;AACA,WAAO;AAAA,EACR,SAAS,GAAG;AACX,SAAK,KAAK,MAAM,iCAAiC,KAAK,IAAI,OAAO,IAAI,CAAC;AACtE,UAAM;AAAA,EACP;AACD;AAEA,IAAI,UAAU,QAAQ,SAAU,UAAW;AAC1C,aAAW,YAAY,CAAC;AAExB,QAAM,uBAAuB,KAAK,cAAc,MAAM,MAAM,KAAK,eAAe,CAAC,QAAQ,CAAC;AAC1F,OAAK,KAAK,MAAM,cAAc,KAAK,IAAI,QAAQ,WAAW;AAE1D,MAAI,QAAQ;AACZ,MAAI;AACH,UAAM,KAAK,KAAK,QAAQ,sBAAsB,QAAQ;AACtD,QAAI,GAAG,SAAS,GAAG;AAElB,YAAM,MAAM,OAAO,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC;AAChC,cAAQ,SAAS,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE;AAAA,IAChC;AAAA,EACD,SAAS,GAAG;AACX,SAAK,KAAK,MAAM,+BAA+B,KAAK,IAAI,OAAO,CAAC;AAChE,MAAE,aAAa,qBAAqB,SAAS;AAC7C,UAAM;AAAA,EACP;AAEA,OAAK,KAAK,MAAM,0BAA0B,OAAO,KAAK,GAAG,KAAK,IAAI,KAAK;AAEvE,SAAO;AACR;AAYA,IAAI,UAAU,OAAO,SAAU,UAAU;AAExC,MAAI;AACJ,aAAW,YAAY,CAAC;AAExB,QAAM,SAAS,SAAS,WAAW,SAAS;AAC5C,MAAI,WAAW,QAAW;AACzB,QAAI,OAAO,gBAAgB,OAAO;AACjC,UAAI,OAAO,gBAAgB,QAAQ;AAClC,YAAI,OAAO,QAAQ,GAAG,IAAI,IAAI;AAC7B,mBAAS,UAAU,OAAO,MAAM,GAAG,EAAE,IAAI,SAAU,KAAK;AACvD,gBAAI,IAAI,gBAAgB;AACvB,oBAAM,MAAM,oFAAqF,OAAO,GAAI;AAC7G,mBAAO,IAAI,KAAK;AAAA,UACjB,CAAC;AAAA,QACF,OAAO;AACN,mBAAS,UAAU,CAAC,MAAM;AAAA,QAC3B;AAAA,MACD,OAAO;AACN,cAAM,MAAM,mFAAoF,OAAO,MAAO;AAAA,MAC/G;AAAA,IACD;AAAA,EACD;AAEA,QAAM,SAAS,SAAS,WAAW,SAAS;AAC5C,MAAI,WAAW,QAAW;AACzB,QAAI,OAAO,gBAAgB,OAAO;AACjC,UAAI,OAAO,gBAAgB,QAAQ;AAClC,YAAI,OAAO,QAAQ,GAAG,IAAI,IAAI;AAC7B,mBAAS,UAAU,OAAO,MAAM,GAAG,EAAE,IAAI,SAAU,KAAK;AACvD,gBAAI,IAAI,gBAAgB;AACvB,oBAAM,MAAM,oFAAqF,OAAO,GAAI;AAC7G,mBAAO,IAAI,KAAK;AAAA,UACjB,CAAC;AAAA,QACF,OAAO;AACN,mBAAS,UAAU,CAAC,MAAM;AAAA,QAC3B;AAAA,MACD,OAAO;AACN,cAAM,MAAM,mFAAoF,OAAO,MAAO;AAAA,MAC/G;AAAA,IACD;AAAA,EACD;AAGA,QAAM,WAAW,CAAC;AAClB,OAAK,OAAO,UAAU;AACrB,aAAS,KAAK,MAAM,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG;AAAA,EACpD;AAEA,OAAK,KAAK,MAAM,wDAAwD,KAAK,IAAI,OAAO,SAAS,KAAK,GAAG,CAAC;AAE1G,MAAI,SAAS,YAAY,UAAa,WAAW,QAAW;AAC3D,aAAS,QAAQ,KAAK,KAAK,IAAI,cAAc,EAAE,IAAI;AAAA,EACpD;AAEA,MAAI,uBAAuB,KAAK,cAAc,KAAK,MAAM,KAAK,eAAe,CAAC,QAAQ,CAAC;AAEvF,MAAI;AACH,QAAI,WAAW,CAAC;AAEhB,UAAM,YAAY,KAAK,QAAQ,sBAAsB,QAAQ;AAE7D,cAAU,QAAQ,SAAU,SAAS;AACpC,UAAI,SAAS,KAAK,aAAa,SAAS,SAAS,OAAO;AACxD,UAAI,QAAQ;AACX,YAAI,mBAAmB,KAAK,IAAI,oBAAoB;AACpD,iBAAS,MAAM,GAAG,MAAM,iBAAiB,QAAQ,OAAO;AACvD,cAAI,kBAAkB,iBAAiB,GAAG;AAC1C,cAAI,OAAO,QAAQ,eAAe,IAAI,IAAI;AACzC,mBAAO,eAAe,IAAI,KAAK,OAAO,CAAC,eAAe,GAAG,MAAM;AAAA,UAChE;AAAA,QACD;AAAA,MACD;AACA,WAAK,OAAO,cAAc,QAAQ,QAAQ;AAC1C,eAAS,KAAK,MAAM;AAAA,IACrB,EAAE,KAAK,IAAI,CAAC;AAEZ,SAAK,KAAK,MAAM,wBAAwB,SAAS,QAAQ,KAAK,IAAI,KAAK;AAEvE,WAAO;AAAA,EACR,SAAS,GAAG;AACX,SAAK,KAAK,MAAM,+BAA+B,KAAK,IAAI,OAAO,CAAC;AAChE,UAAM;AAAA,EACP;AACD;AAEA,IAAI,UAAU,cAAc,WAAY;AACvC,OAAK,KAAK,MAAM,wBAAwB,KAAK,IAAI,KAAK;AACtD,MAAI;AACH,UAAM,uBAAuB,KAAK,cAAc,MAAM,MAAM,KAAK,aAAa;AAC9E,UAAM,KAAK,KAAK,QAAQ,oBAAoB;AAC5C,WAAO,GAAG,SAAS;AAAA,EACpB,SAAS,GAAG;AACX,WAAO;AAAA,EACR;AACD;AAEA,IAAI,UAAU,cAAc,WAAY;AACvC,OAAK,KAAK,MAAM,qBAAqB,KAAK,IAAI,KAAK;AACnD,QAAM,uBAAuB,KAAK,cAAc,YAAY,MAAM,KAAK,aAAa;AACpF,MAAI;AACH,SAAK,QAAQ,oBAAoB;AACjC,SAAK,KAAK,MAAM,oBAAoB,KAAK,IAAI,KAAK;AAClD,WAAO;AAAA,EACR,SAAS,GAAG;AACX,SAAK,KAAK,MAAM,0BAA0B,KAAK,IAAI,OAAO,CAAC;AAC3D,UAAM;AAAA,EACP;AACD;AAEA,IAAI,UAAU,YAAY,SAAU,gBAAgB;AACnD,OAAK,KAAK,MAAM,sBAAsB,KAAK,IAAI,KAAK;AACpD,QAAM,uBAAuB,KAAK,cAAc,UAAU,MAAM,KAAK,aAAa;AAClF,MAAI;AACH,SAAK,QAAQ,oBAAoB;AACjC,SAAK,KAAK,MAAM,qBAAqB,KAAK,IAAI,KAAK;AAAA,EACpD,SAAS,GAAG;AACX,SAAK,KAAK,MAAM,6BAA6B,KAAK,IAAI,OAAO,CAAC;AAC9D,UAAM;AAAA,EACP;AAEA,MAAI,gBAAgB;AACnB,SAAK,KAAK,MAAM,kCAAkC,KAAK,IAAI,OAAO,KAAK,YAAY;AACnF,QAAI;AACH,WAAK,gBAAgB;AACrB,WAAK,KAAK,MAAM,iCAAiC,KAAK,IAAI,OAAO,KAAK,YAAY;AAAA,IACnF,SAAS,GAAG;AACX,WAAK,KAAK,MAAM,yCAAyC,KAAK,IAAI,OAAO,KAAK,cAAc,CAAC;AAC7F,YAAM;AAAA,IACP;AAAA,EACD;AAEA,SAAO;AACR;AAOO,SAAS,OAAO,aAAa,YAAqB,gBAAyB;AACjF,MAAI;AACJ,QAAM;AAEN,MAAI,CAAC,kBAAkB,mBAAmB,MAAM;AAC/C,qBAAiB,2BAAe,IAAI,8CAA8C,WAAW;AAAA,EAC9F;AAEA,MAAI,cAAc,oBAAQ,IAAI,cAAc;AAC5C,MAAI,CAAC,aAAa;AACjB,kBAAc,yBAAS,eAAe,cAAc;AACpD,wBAAQ,IAAI,gBAAgB,WAAW;AAAA,EACxC;AAGA,SAAO,IAAI,IAAI,KAAK,YAAY,cAAc;AAC/C;AAAC;AAEM,SAAS,IAAI,aAAa,YAAqB,gBAAyB;AAC9E,SAAO,OAAO,aAAa,YAAY,cAAc;AACtD;",
  "names": ["getORM", "createORMStatements"]
}
