@aerokit/sdk 12.44.0

package/dist/esm/db/ormstatements.mjs

@@ -0,0 +1,223 @@
+import { Logging } from "@aerokit/sdk/log";
+import { SQLBuilder } from "./sql";
+function ORMStatements(orm, dialect) {
+  this.$log = Logging.getLogger("db.dao.ormstatements");
+  this.orm = orm;
+  this.orm.tableName = this.orm.table;
+  this.orm.properties.forEach(function(property) {
+    property.columnName = property.column;
+  });
+  this.dialect = dialect || SQLBuilder.getDialect();
+}
+;
+ORMStatements.prototype.constructor = ORMStatements;
+ORMStatements.prototype.createTable = function() {
+  const builder = this.dialect.create().table(this.orm.table);
+  this.orm.properties.forEach(function(property) {
+    const column = this.orm.toColumn(property);
+    if (property.type.toUpperCase() === "VARCHAR") {
+      if (property.length === void 0)
+        property.length = 255;
+      builder.columnVarchar(column.name, property.length, column.primaryKey === "true", column.nullable === "true", property.unique);
+    } else if (property.type.toUpperCase() === "CHAR") {
+      if (property.length === void 0)
+        property.length = 1;
+      property.length = parseInt(property.length, 10);
+      builder.columnChar(column.name, property.length, column.primaryKey === "true", column.nullable === "true", property.unique);
+    } else {
+      builder.column(column.name, column.type, column.primaryKey === "true", column.nullable === "true", property.unique);
+    }
+  }.bind(this));
+  return builder;
+};
+ORMStatements.prototype.dropTable = function() {
+  return this.dialect.drop().table(this.orm.table);
+};
+ORMStatements.prototype.insert = function() {
+  const builder = this.dialect.insert().into(this.orm.table);
+  this.orm.properties.forEach(function(property) {
+    builder.column(property.column).value("?", property);
+  });
+  return builder;
+};
+ORMStatements.prototype.update = function(entity) {
+  if (!entity)
+    throw Error("Illegal argument: entity[" + entity + "]");
+  const builder = this.dialect.update().table(this.orm.table);
+  this.orm.properties.filter(function(property) {
+    return Object.keys(entity).indexOf(property.name) > -1 && (!property.allowedOps || property.allowedOps.indexOf("update") > -1);
+  }).forEach(function(property) {
+    if (!property.id)
+      builder.set(property.column, "?", property);
+  });
+  const pkProperty = this.orm.getPrimaryKey();
+  builder.where(pkProperty.column + "=?", [pkProperty]);
+  return builder;
+};
+ORMStatements.prototype["delete"] = ORMStatements.prototype.remove = function() {
+  const builder = this.dialect.delete().from(this.orm.table);
+  if (arguments[0] !== void 0) {
+    let filterFieldNames = arguments[0];
+    if (filterFieldNames.constructor !== Array)
+      filterFieldNames = [filterFieldNames];
+    for (let i = 0; i < filterFieldNames.length; i++) {
+      const property = this.orm.getProperty(filterFieldNames[i]);
+      if (!property)
+        throw Error("Unknown property name: " + filterFieldNames[i] + " in $filter");
+      builder.where(property.column + "=?", [property]);
+    }
+  }
+  return builder;
+};
+ORMStatements.prototype.find = function(params) {
+  let builder = this.dialect.select();
+  if (params !== void 0 && params.select !== void 0) {
+    const selectedFields = params.select.constructor === Array ? params.select : [params.select];
+    for (let i = 0; i < selectedFields.length; i++) {
+      const property = this.orm.getProperty(selectedFields[i]);
+      if (!property)
+        throw Error("Unknown field name [" + selectedFields[i] + "] in $select");
+      builder = builder.column(property.column);
+    }
+  }
+  builder = builder.from(this.orm.table).where(this.orm.getPrimaryKey().column + "=?", [this.orm.getPrimaryKey()]);
+  return builder;
+};
+ORMStatements.prototype.count = function(settings) {
+  const builder = this.dialect.select().column("COUNT(*)").from(this.orm.table);
+  addFilter(this.orm, builder, settings);
+  return builder;
+};
+ORMStatements.prototype.list = function(settings) {
+  let i;
+  settings = settings || {};
+  const sort = settings.$sort || settings.sort;
+  const order = settings.$order || settings.order;
+  const selectedFields = settings.$select || settings.select;
+  const builder = this.dialect.select().from(this.orm.table);
+  if (selectedFields) {
+    for (i = 0; i < selectedFields.length; i++) {
+      const property = this.orm.getProperty(selectedFields[i]);
+      if (!property)
+        throw Error("Unknown field name [" + selectedFields[i] + "] in $select");
+      builder.column(property.column);
+    }
+  }
+  addFilter(this.orm, builder, settings);
+  const propertyDefinitions = this.orm.properties.filter(function(property) {
+    for (var settingName in settings) {
+      if (settingName === property.name)
+        return true;
+    }
+    return false;
+  });
+  if (propertyDefinitions.length > 0) {
+    for (i = 0; i < propertyDefinitions.length; i++) {
+      const def = propertyDefinitions[i];
+      if (settings?.$filter && settings.$filter?.indexOf(def.name) > -1) {
+        builder.where(def.column + " LIKE ?", [def]);
+      } else {
+        const val = settings[def.name];
+        if (val === null || val === void 0) {
+          builder.where(def.column + " IS NULL", [def]);
+        } else {
+          if (val.indexOf && val.indexOf(">") > -1) {
+            builder.where(def.column + " > ?", [def]);
+          } else if (val.indexOf && val.indexOf("<") > -1) {
+            builder.where(def.column + " < ?", [def]);
+          } else {
+            builder.where(def.column + "=?", [def]);
+          }
+        }
+      }
+    }
+  }
+  if (sort !== void 0) {
+    var _sort = sort.split(",");
+    for (i = 0; i < _sort.length; i++) {
+      let _order = true;
+      if (order !== void 0) {
+        if (["asc", "desc"].indexOf(String(order).toLowerCase()) > -1) {
+          _order = order.toLowerCase() === "desc" ? false : true;
+        }
+      }
+      if (this.orm.getProperty(_sort[i])) {
+        builder.order(this.orm.getProperty(_sort[i]).column, _order);
+      } else {
+        console.error("Column: " + _sort[i] + " not present in " + JSON.stringify(this.orm));
+      }
+    }
+  }
+  addLimit(builder, settings);
+  addOffset(builder, settings);
+  return builder;
+};
+function addFilter(orm, builder, settings) {
+  if (settings?.$filter) {
+    const equalsPropertiesKeys = Object.keys(settings.$filter.equals ?? []);
+    const notEqualsPropertiesKeys = Object.keys(settings.$filter.notEquals ?? []);
+    const containsPropertiesKeys = Object.keys(settings.$filter.contains ?? []);
+    const greaterThanPropertiesKeys = Object.keys(settings.$filter.greaterThan ?? []);
+    const lessThanPropertiesKeys = Object.keys(settings.$filter.lessThan ?? []);
+    const greaterThanOrEqualPropertiesKeys = Object.keys(settings.$filter.greaterThanOrEqual ?? []);
+    const lessThanOrEqualPropertiesKeys = Object.keys(settings.$filter.lessThanOrEqual ?? []);
+    const equalsProperties = orm.properties.filter((e) => equalsPropertiesKeys.includes(e.name));
+    const notEqualsProperties = orm.properties.filter((e) => notEqualsPropertiesKeys.includes(e.name));
+    const containsProperties = orm.properties.filter((e) => containsPropertiesKeys.includes(e.name));
+    const greaterThanProperties = orm.properties.filter((e) => greaterThanPropertiesKeys.includes(e.name));
+    const lessThanProperties = orm.properties.filter((e) => lessThanPropertiesKeys.includes(e.name));
+    const greaterThanOrEqualProperties = orm.properties.filter((e) => greaterThanOrEqualPropertiesKeys.includes(e.name));
+    const lessThanOrEqualProperties = orm.properties.filter((e) => lessThanOrEqualPropertiesKeys.includes(e.name));
+    equalsProperties.forEach((e) => {
+      const value = settings.$filter.equals[e.name];
+      if (value === null || value === void 0) {
+        builder.where(e.column + " IS NULL", [e]);
+      } else if (Array.isArray(value)) {
+        builder.where(`${e.column} IN (${value.map((v) => "?").join(", ")})`, [e]);
+      } else {
+        builder.where(`${e.column} = ?`, [e]);
+      }
+    });
+    notEqualsProperties.forEach((e) => {
+      const value = settings.$filter.notEquals[e.name];
+      if (value === null || value === void 0) {
+        builder.where(e.column + " IS NOT NULL", [e]);
+      } else if (Array.isArray(value)) {
+        builder.where(`${e.column} NOT IN (${value.map((v) => "?").join(", ")})`, [e]);
+      } else {
+        builder.where(`${e.column} != ?`, [e]);
+      }
+    });
+    containsProperties.forEach((e) => builder.where(`${e.column} LIKE ?`, [e]));
+    greaterThanProperties.forEach((e) => builder.where(`${e.column} > ?`, [e]));
+    lessThanProperties.forEach((e) => builder.where(`${e.column} < ?`, [e]));
+    greaterThanOrEqualProperties.forEach((e) => builder.where(`${e.column} >= ?`, [e]));
+    lessThanOrEqualProperties.forEach((e) => builder.where(`${e.column} <= ?`, [e]));
+  }
+}
+function addLimit(builder, settings) {
+  const limit = settings.$limit ?? settings.limit;
+  if (limit !== void 0) {
+    builder.limit(parseInt(limit, 10));
+  }
+}
+function addOffset(builder, settings) {
+  const offset = settings.$offset ?? settings.offset;
+  if (offset !== void 0) {
+    builder.offset(parseInt(offset, 10));
+  }
+}
+function create(orm, connection) {
+  let dialect;
+  if (connection) {
+    dialect = SQLBuilder.getDialect(connection);
+  }
+  const stmnts = new ORMStatements(orm, dialect);
+  return stmnts;
+}
+;
+export {
+  ORMStatements,
+  create
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/ormstatements.ts"],
  "sourcesContent": ["\"use strict\";\n\nimport { Logging } from \"@aerokit/sdk/log\";\nimport { CreateTableBuilder, DeleteBuilder, DropTableBuilder, InsertBuilder, SelectBuilder, SQLBuilder, UpdateBuilder } from \"./sql\";\nimport { Connection } from \"./database\";\n\nexport function ORMStatements(orm, dialect: SQLBuilder) {\n\tthis.$log = Logging.getLogger('db.dao.ormstatements');\n\tthis.orm = orm;\n\tthis.orm.tableName = this.orm.table;\n\tthis.orm.properties.forEach(function (property) {\n\t\tproperty.columnName = property.column;\n\t});\n\tthis.dialect = dialect || SQLBuilder.getDialect();\n};\nORMStatements.prototype.constructor = ORMStatements;\n\nORMStatements.prototype.createTable = function (): CreateTableBuilder {\n\tconst builder = this.dialect.create().table(this.orm.table);\n\n\tthis.orm.properties.forEach(function (property) {\n\t\tconst column = this.orm.toColumn(property);\n\t\tif (property.type.toUpperCase() === 'VARCHAR') {\n\t\t\tif (property.length === undefined)\n\t\t\t\tproperty.length = 255;\n\t\t\tbuilder.columnVarchar(column.name, property.length, column.primaryKey === 'true', column.nullable === 'true', property.unique);\n\t\t} else if (property.type.toUpperCase() === 'CHAR') {\n\t\t\tif (property.length === undefined)\n\t\t\t\tproperty.length = 1;\n\t\t\tproperty.length = parseInt(property.length, 10);\n\t\t\tbuilder.columnChar(column.name, property.length, column.primaryKey === 'true', column.nullable === 'true', property.unique);\n\t\t} else {\n\t\t\tbuilder.column(column.name, column.type, column.primaryKey === 'true', column.nullable === 'true', property.unique);\n\t\t}\n\t}.bind(this));\n\n\treturn builder;\n};\n\nORMStatements.prototype.dropTable = function (): DropTableBuilder {\n\treturn this.dialect.drop().table(this.orm.table);\n};\n\nORMStatements.prototype.insert = function (): InsertBuilder {\n\tconst builder = this.dialect.insert().into(this.orm.table);\n\tthis.orm.properties.forEach(function (property) {\n\t\tbuilder.column(property.column).value('?', property);\n\t});\n\treturn builder;\n};\n\nORMStatements.prototype.update = function (entity): UpdateBuilder {\n\tif (!entity)\n\t\tthrow Error('Illegal argument: entity[' + entity + ']');\n\n\tconst builder = this.dialect.update().table(this.orm.table);\n\tthis.orm.properties.filter(function (property) {\n\t\treturn Object.keys(entity).indexOf(property.name) > -1 && (!property.allowedOps || property.allowedOps.indexOf('update') > -1);\n\t}).forEach(function (property) {\n\t\tif (!property.id)\n\t\t\tbuilder.set(property.column, '?', property);\n\t});\n\tconst pkProperty = this.orm.getPrimaryKey();\n\tbuilder.where(pkProperty.column + '=?', [pkProperty]);\n\treturn builder;\n};\n\nORMStatements.prototype[\"delete\"] = ORMStatements.prototype.remove = function (): DeleteBuilder {\n\tconst builder = this.dialect.delete().from(this.orm.table);\n\tif (arguments[0] !== undefined) {\n\t\tlet filterFieldNames = arguments[0];\n\t\tif (filterFieldNames.constructor !== Array)\n\t\t\tfilterFieldNames = [filterFieldNames];\n\t\tfor (let i = 0; i < filterFieldNames.length; i++) {\n\t\t\tconst property = this.orm.getProperty(filterFieldNames[i]);\n\t\t\tif (!property)\n\t\t\t\tthrow Error('Unknown property name: ' + filterFieldNames[i] + \" in $filter\");\n\t\t\tbuilder.where(property.column + \"=?\", [property]);\n\t\t}\n\t}\n\treturn builder;\n};\n\nORMStatements.prototype.find = function (params): SelectBuilder {\n\tlet builder = this.dialect.select();\n\tif (params !== undefined && params.select !== undefined) {\n\t\tconst selectedFields = params.select.constructor === Array ? params.select : [params.select];\n\t\tfor (let i = 0; i < selectedFields.length; i++) {\n\t\t\tconst property = this.orm.getProperty(selectedFields[i]);\n\t\t\tif (!property)\n\t\t\t\tthrow Error('Unknown field name [' + selectedFields[i] + '] in $select');\n\t\t\tbuilder = builder.column(property.column);\n\t\t}\n\t}\n\tbuilder = builder.from(this.orm.table)\n\t\t.where(this.orm.getPrimaryKey().column + \"=?\", [this.orm.getPrimaryKey()]);\n\treturn builder;\n};\n\nORMStatements.prototype.count = function (settings): SelectBuilder {\n\tconst builder = this.dialect.select().column('COUNT(*)').from(this.orm.table);\n\taddFilter(this.orm, builder, settings);\n\treturn builder;\n};\n\nORMStatements.prototype.list = function (settings): SelectBuilder {\n\tlet i;\n\tsettings = settings || {};\n\tconst sort = settings.$sort || settings.sort;\n\tconst order = settings.$order || settings.order;\n\tconst selectedFields = settings.$select || settings.select;\n\n\tconst builder = this.dialect.select().from(this.orm.table);\n\n\t//add selected fields if any\n\tif (selectedFields) {\n\t\tfor (i = 0; i < selectedFields.length; i++) {\n\t\t\tconst property = this.orm.getProperty(selectedFields[i]);\n\t\t\tif (!property)\n\t\t\t\tthrow Error('Unknown field name [' + selectedFields[i] + '] in $select');\n\t\t\tbuilder.column(property.column);\n\t\t}\n\t}\n\n\t//add where clause for any fields\n\taddFilter(this.orm, builder, settings);\n\n\t// TODO: The following code might not be needed anymore\n\tconst propertyDefinitions = this.orm.properties.filter(function (property) {\n\t\tfor (var settingName in settings) {\n\t\t\tif (settingName === property.name)\n\t\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t});\n\tif (propertyDefinitions.length > 0) {\n\t\tfor (i = 0; i < propertyDefinitions.length; i++) {\n\t\t\tconst def = propertyDefinitions[i];\n\t\t\tif (settings?.$filter && settings.$filter?.indexOf(def.name) > -1) {\n\t\t\t\tbuilder.where(def.column + ' LIKE ?', [def]);\n\t\t\t} else {\n\t\t\t\tconst val = settings[def.name];\n\t\t\t\tif (val === null || val === undefined) {\n\t\t\t\t\tbuilder.where(def.column + ' IS NULL', [def]);\n\t\t\t\t} else {\n\t\t\t\t\tif (val.indexOf && val.indexOf('>') > -1) {\n\t\t\t\t\t\tbuilder.where(def.column + ' > ?', [def]);\n\t\t\t\t\t} else if (val.indexOf && val.indexOf('<') > -1) {\n\t\t\t\t\t\tbuilder.where(def.column + ' < ?', [def]);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbuilder.where(def.column + '=?', [def]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tif (sort !== undefined) {\n\t\tvar _sort = sort.split(',');\n\t\tfor (i = 0; i < _sort.length; i++) {\n\t\t\tlet _order = true;//ASC\n\t\t\t//TODO: change to be able to order per sort property\n\t\t\tif (order !== undefined) {\n\t\t\t\tif (['asc', 'desc'].indexOf(String(order).toLowerCase()) > -1) {\n\t\t\t\t\t_order = order.toLowerCase() === 'desc' ? false : true;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (this.orm.getProperty(_sort[i])) {\n\t\t\t\tbuilder.order(this.orm.getProperty(_sort[i]).column, _order);\n\t\t\t} else {\n\t\t\t\tconsole.error('Column: ' + _sort[i] + ' not present in ' + JSON.stringify(this.orm));\n\t\t\t}\n\n\t\t}\n\t}\n\taddLimit(builder, settings);\n\taddOffset(builder, settings);\n\treturn builder;\n};\n\nfunction addFilter(orm, builder, settings) {\n\t//add where clause for any fields\n\tif (settings?.$filter) {\n\t\tconst equalsPropertiesKeys = Object.keys(settings.$filter.equals ?? []);\n\t\tconst notEqualsPropertiesKeys = Object.keys(settings.$filter.notEquals ?? []);\n\t\tconst containsPropertiesKeys = Object.keys(settings.$filter.contains ?? []);\n\t\tconst greaterThanPropertiesKeys = Object.keys(settings.$filter.greaterThan ?? []);\n\t\tconst lessThanPropertiesKeys = Object.keys(settings.$filter.lessThan ?? []);\n\t\tconst greaterThanOrEqualPropertiesKeys = Object.keys(settings.$filter.greaterThanOrEqual ?? []);\n\t\tconst lessThanOrEqualPropertiesKeys = Object.keys(settings.$filter.lessThanOrEqual ?? []);\n\n\t\tconst equalsProperties = orm.properties.filter(e => equalsPropertiesKeys.includes(e.name));\n\t\tconst notEqualsProperties = orm.properties.filter(e => notEqualsPropertiesKeys.includes(e.name));\n\t\tconst containsProperties = orm.properties.filter(e => containsPropertiesKeys.includes(e.name));\n\t\tconst greaterThanProperties = orm.properties.filter(e => greaterThanPropertiesKeys.includes(e.name));\n\t\tconst lessThanProperties = orm.properties.filter(e => lessThanPropertiesKeys.includes(e.name));\n\t\tconst greaterThanOrEqualProperties = orm.properties.filter(e => greaterThanOrEqualPropertiesKeys.includes(e.name));\n\t\tconst lessThanOrEqualProperties = orm.properties.filter(e => lessThanOrEqualPropertiesKeys.includes(e.name));\n\n\t\tequalsProperties.forEach(e => {\n\t\t\tconst value = settings.$filter.equals[e.name];\n\t\t\tif (value === null || value === undefined) {\n\t\t\t\tbuilder.where(e.column + ' IS NULL', [e]);\n\t\t\t} else if (Array.isArray(value)) {\n\t\t\t\tbuilder.where(`${e.column} IN (${value.map(v => '?').join(', ')})`, [e])\n\t\t\t} else {\n\t\t\t\tbuilder.where(`${e.column} = ?`, [e])\n\t\t\t}\n\t\t});\n\t\tnotEqualsProperties.forEach(e => {\n\t\t\tconst value = settings.$filter.notEquals[e.name];\n\t\t\tif (value === null || value === undefined) {\n\t\t\t\tbuilder.where(e.column + ' IS NOT NULL', [e]);\n\t\t\t} else if (Array.isArray(value)) {\n\t\t\t\tbuilder.where(`${e.column} NOT IN (${value.map(v => '?').join(', ')})`, [e])\n\t\t\t} else {\n\t\t\t\tbuilder.where(`${e.column} != ?`, [e])\n\t\t\t}\n\t\t});\n\t\tcontainsProperties.forEach(e => builder.where(`${e.column} LIKE ?`, [e]));\n\t\tgreaterThanProperties.forEach(e => builder.where(`${e.column} > ?`, [e]));\n\t\tlessThanProperties.forEach(e => builder.where(`${e.column} < ?`, [e]));\n\t\tgreaterThanOrEqualProperties.forEach(e => builder.where(`${e.column} >= ?`, [e]));\n\t\tlessThanOrEqualProperties.forEach(e => builder.where(`${e.column} <= ?`, [e]));\n\t}\n}\n\nfunction addLimit(builder, settings) {\n\tconst limit = settings.$limit ?? settings.limit;\n\tif (limit !== undefined) {\n\t\tbuilder.limit(parseInt(limit, 10));\n\t}\n}\n\nfunction addOffset(builder, settings) {\n\tconst offset = settings.$offset ?? settings.offset;\n\tif (offset !== undefined) {\n\t\tbuilder.offset(parseInt(offset, 10));\n\t}\n}\n\nexport function create(orm, connection?: Connection) {\n\tlet dialect;\n\tif (connection) {\n\t\tdialect = SQLBuilder.getDialect(connection);\n\t}\n\n\tconst stmnts = new ORMStatements(orm, dialect);\n\treturn stmnts;\n};\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/db/procedure.mjs

@@ -0,0 +1,93 @@
+import { Update } from "./update";
+import { Database } from "./database";
+class Procedure {
+  /**
+   * Executes a DDL/DML statement to create or modify a stored procedure without results.
+   * * @param {string} sql The SQL statement (e.g., CREATE PROCEDURE).
+   * @param {string} [datasourceName] Optional name of the data source to use.
+   */
+  static create(sql, datasourceName) {
+    Update.execute(sql, [], datasourceName);
+  }
+  /**
+   * Executes a stored procedure call and returns the result set(s).
+   * * @param {string} sql The callable statement (e.g., {CALL my_procedure(?, ?)}).
+   * @param {(string | number | ProcedureParameter)[]} [parameters=[]] An array of parameters. Primitives (string/number) are automatically typed. Use ProcedureParameter for explicit types.
+   * @param {string} [datasourceName] Optional name of the data source to use.
+   * @returns {any[]} An array of JSON objects representing the result set(s).
+   */
+  static execute(sql, parameters = [], datasourceName) {
+    const result = [];
+    let connection = null;
+    let callableStatement = null;
+    let resultSet = null;
+    try {
+      let hasMoreResults = false;
+      connection = Database.getConnection(datasourceName);
+      callableStatement = connection.prepareCall(sql);
+      const mappedParameters = parameters.map((parameter) => {
+        if (parameter && typeof parameter === "object" && "type" in parameter && "value" in parameter) {
+          return parameter;
+        }
+        let type;
+        let value;
+        if (typeof parameter === "string") {
+          type = "string";
+          value = parameter;
+        } else if (typeof parameter === "number") {
+          type = parameter % 1 === 0 ? "int" : "double";
+          value = parameter;
+        } else {
+          throw new Error(`Procedure Call - Unsupported parameter type [${typeof parameter}]`);
+        }
+        return { value, type };
+      });
+      for (let i = 0; i < mappedParameters.length; i++) {
+        switch (mappedParameters[i].type) {
+          case "string":
+            callableStatement.setString(i + 1, mappedParameters[i].value);
+            break;
+          case "int":
+          case "integer":
+          case "number":
+            callableStatement.setInt(i + 1, mappedParameters[i].value);
+            break;
+          case "float":
+            callableStatement.setFloat(i + 1, mappedParameters[i].value);
+            break;
+          case "double":
+            callableStatement.setDouble(i + 1, mappedParameters[i].value);
+            break;
+        }
+      }
+      resultSet = callableStatement.executeQuery();
+      do {
+        result.push(JSON.parse(resultSet.toJson()));
+        hasMoreResults = callableStatement.getMoreResults();
+        if (hasMoreResults) {
+          resultSet.close();
+          resultSet = callableStatement.getResultSet();
+        }
+      } while (hasMoreResults);
+      callableStatement.close();
+    } finally {
+      if (resultSet != null) {
+        resultSet.close();
+      }
+      if (callableStatement != null) {
+        callableStatement.close();
+      }
+      if (connection != null) {
+        connection.close();
+      }
+    }
+    return result;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Procedure;
+}
+export {
+  Procedure
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/procedure.ts"],
  "sourcesContent": ["/**\n * API Procedure\n *\n */\nimport { Update } from \"./update\";\nimport { Database } from \"./database\";\n\n/**\n * @interface ProcedureParameter\n * @description Defines a structured parameter for procedure calls, allowing the type \n * to be explicitly defined when the natural JavaScript type mapping is insufficient.\n */\nexport interface ProcedureParameter {\n\ttype: string; // Removed readonly to allow assignment during parameter mapping\n\tvalue: any;   // Removed readonly\n}\n\nexport class Procedure {\n\n    /**\n     * Executes a DDL/DML statement to create or modify a stored procedure without results.\n     * * @param {string} sql The SQL statement (e.g., CREATE PROCEDURE).\n     * @param {string} [datasourceName] Optional name of the data source to use.\n     */\n    public static create(sql: string, datasourceName?: string): void {\n        Update.execute(sql, [], datasourceName);\n    }\n\n    /**\n     * Executes a stored procedure call and returns the result set(s).\n     * * @param {string} sql The callable statement (e.g., {CALL my_procedure(?, ?)}).\n     * @param {(string | number | ProcedureParameter)[]} [parameters=[]] An array of parameters. Primitives (string/number) are automatically typed. Use ProcedureParameter for explicit types.\n     * @param {string} [datasourceName] Optional name of the data source to use.\n     * @returns {any[]} An array of JSON objects representing the result set(s).\n     */\n    public static execute(sql: string, parameters: (string | number | ProcedureParameter)[] = [], datasourceName?: string): any[] {\n        const result = [];\n\n        let connection = null;\n        let callableStatement = null;\n        let resultSet = null;\n\n        try {\n            let hasMoreResults = false;\n\n            connection = Database.getConnection(datasourceName);\n            callableStatement = connection.prepareCall(sql);\n            \n            const mappedParameters: ProcedureParameter[] = parameters.map((parameter) => {\n                \n                // 1. If the parameter is an object and looks like a ProcedureParameter, use it directly.\n                if (parameter && typeof parameter === \"object\" && 'type' in parameter && 'value' in parameter) {\n                    return parameter as ProcedureParameter;\n                }\n\n                // 2. Handle primitive types (string or number) by explicitly narrowing the type.\n                let type: string;\n                let value: string | number;\n\n                if (typeof parameter === \"string\") {\n                    type = \"string\";\n                    value = parameter;\n                } else if (typeof parameter === \"number\") {\n                    // Type is correctly narrowed to 'number' here, resolving the TS2362 error.\n                    type = parameter % 1 === 0 ? \"int\" : \"double\";\n                    value = parameter;\n                } else {\n                    // Throw error if the parameter is not a recognized type.\n                    throw new Error(`Procedure Call - Unsupported parameter type [${typeof parameter}]`);\n                }\n\n                return { value, type };\n            });\n\n            for (let i = 0; i < mappedParameters.length; i++) {\n                switch (mappedParameters[i].type) {\n                    case \"string\":\n                        callableStatement.setString(i + 1, mappedParameters[i].value);\n                        break;\n                    case \"int\":\n                    case \"integer\":\n                    case \"number\":\n                        callableStatement.setInt(i + 1, mappedParameters[i].value);\n                        break;\n                    case \"float\":\n                        callableStatement.setFloat(i + 1, mappedParameters[i].value);\n                        break;\n                    case \"double\":\n                        callableStatement.setDouble(i + 1, mappedParameters[i].value);\n                        break;\n                }\n            }\n            resultSet = callableStatement.executeQuery();\n\n            do {\n                result.push(JSON.parse(resultSet.toJson()));\n                hasMoreResults = callableStatement.getMoreResults();\n                if (hasMoreResults) {\n                    resultSet.close();\n                    resultSet = callableStatement.getResultSet();\n                }\n            } while (hasMoreResults)\n\n            callableStatement.close();\n        } finally {\n            if (resultSet != null) {\n                resultSet.close();\n            }\n            if (callableStatement != null) {\n                callableStatement.close();\n            }\n            if (connection != null) {\n                connection.close();\n            }\n        }\n        return result;\n    }\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Procedure;\n}"],
  "mappings": "AAIA,SAAS,cAAc;AACvB,SAAS,gBAAgB;AAYlB,MAAM,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOnB,OAAc,OAAO,KAAa,gBAA+B;AAC7D,WAAO,QAAQ,KAAK,CAAC,GAAG,cAAc;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAc,QAAQ,KAAa,aAAuD,CAAC,GAAG,gBAAgC;AAC1H,UAAM,SAAS,CAAC;AAEhB,QAAI,aAAa;AACjB,QAAI,oBAAoB;AACxB,QAAI,YAAY;AAEhB,QAAI;AACA,UAAI,iBAAiB;AAErB,mBAAa,SAAS,cAAc,cAAc;AAClD,0BAAoB,WAAW,YAAY,GAAG;AAE9C,YAAM,mBAAyC,WAAW,IAAI,CAAC,cAAc;AAGzE,YAAI,aAAa,OAAO,cAAc,YAAY,UAAU,aAAa,WAAW,WAAW;AAC3F,iBAAO;AAAA,QACX;AAGA,YAAI;AACJ,YAAI;AAEJ,YAAI,OAAO,cAAc,UAAU;AAC/B,iBAAO;AACP,kBAAQ;AAAA,QACZ,WAAW,OAAO,cAAc,UAAU;AAEtC,iBAAO,YAAY,MAAM,IAAI,QAAQ;AACrC,kBAAQ;AAAA,QACZ,OAAO;AAEH,gBAAM,IAAI,MAAM,gDAAgD,OAAO,SAAS,GAAG;AAAA,QACvF;AAEA,eAAO,EAAE,OAAO,KAAK;AAAA,MACzB,CAAC;AAED,eAAS,IAAI,GAAG,IAAI,iBAAiB,QAAQ,KAAK;AAC9C,gBAAQ,iBAAiB,CAAC,EAAE,MAAM;AAAA,UAC9B,KAAK;AACD,8BAAkB,UAAU,IAAI,GAAG,iBAAiB,CAAC,EAAE,KAAK;AAC5D;AAAA,UACJ,KAAK;AAAA,UACL,KAAK;AAAA,UACL,KAAK;AACD,8BAAkB,OAAO,IAAI,GAAG,iBAAiB,CAAC,EAAE,KAAK;AACzD;AAAA,UACJ,KAAK;AACD,8BAAkB,SAAS,IAAI,GAAG,iBAAiB,CAAC,EAAE,KAAK;AAC3D;AAAA,UACJ,KAAK;AACD,8BAAkB,UAAU,IAAI,GAAG,iBAAiB,CAAC,EAAE,KAAK;AAC5D;AAAA,QACR;AAAA,MACJ;AACA,kBAAY,kBAAkB,aAAa;AAE3C,SAAG;AACC,eAAO,KAAK,KAAK,MAAM,UAAU,OAAO,CAAC,CAAC;AAC1C,yBAAiB,kBAAkB,eAAe;AAClD,YAAI,gBAAgB;AAChB,oBAAU,MAAM;AAChB,sBAAY,kBAAkB,aAAa;AAAA,QAC/C;AAAA,MACJ,SAAS;AAET,wBAAkB,MAAM;AAAA,IAC5B,UAAE;AACE,UAAI,aAAa,MAAM;AACnB,kBAAU,MAAM;AAAA,MACpB;AACA,UAAI,qBAAqB,MAAM;AAC3B,0BAAkB,MAAM;AAAA,MAC5B;AACA,UAAI,cAAc,MAAM;AACpB,mBAAW,MAAM;AAAA,MACrB;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AACJ;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}


package/dist/esm/db/query.mjs

@@ -0,0 +1,38 @@
+const DatabaseFacade = Java.type("org.eclipse.dirigible.components.api.db.DatabaseFacade");
+class Query {
+  /**
+   * Executes a standard SQL query with positional parameters ('?').
+   *
+   * @param sql The SQL query to execute.
+   * @param parameters An optional array of values (primitives or QueryParameter objects) to replace '?' placeholders.
+   * @param datasourceName The name of the database connection to use (optional).
+   * @param resultParameter Optional formatting parameters for the result set (e.g., date format).
+   * @returns An array of records representing the query results.
+   */
+  static execute(sql, parameters, datasourceName, resultParameter) {
+    const paramsJson = parameters ? JSON.stringify(parameters) : void 0;
+    const resultParamsJson = resultParameter ? JSON.stringify(resultParameter) : void 0;
+    const resultset = DatabaseFacade.query(sql, paramsJson, datasourceName, resultParamsJson);
+    return JSON.parse(resultset);
+  }
+  /**
+   * Executes a SQL query with named parameters (e.g., ":name", ":id").
+   *
+   * @param sql The SQL query to execute.
+   * @param parameters An optional array of NamedQueryParameter objects.
+   * @param datasourceName The name of the database connection to use (optional).
+   * @returns An array of records representing the query results.
+   */
+  static executeNamed(sql, parameters, datasourceName) {
+    const paramsJson = parameters ? JSON.stringify(parameters) : void 0;
+    const resultset = DatabaseFacade.queryNamed(sql, paramsJson, datasourceName);
+    return JSON.parse(resultset);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Query;
+}
+export {
+  Query
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/db/repository.mjs

@@ -0,0 +1,129 @@
+import { store, translator } from "@aerokit/sdk/db";
+class Repository {
+  constructor(entityConstructor) {
+    this.entityConstructor = entityConstructor;
+    if (!this.entityConstructor.$entity_name) {
+      this.entityConstructor.$entity_name = store.getEntityName(this.entityConstructor.name);
+      this.entityConstructor.$table_name = store.getTableName(this.entityConstructor.name);
+      this.entityConstructor.$id_name = store.getIdName(this.entityConstructor.name);
+      this.entityConstructor.$id_column = store.getIdColumn(this.entityConstructor.name);
+    }
+  }
+  getEntityName() {
+    return this.entityConstructor.$entity_name;
+  }
+  getTableName() {
+    return this.entityConstructor.$table_name;
+  }
+  getIdName() {
+    return this.entityConstructor.$id_name;
+  }
+  getIdColumn() {
+    return this.entityConstructor.$id_column;
+  }
+  /**
+   * Finds all entities matching the given options.
+   */
+  findAll(options = {}) {
+    const list = store.list(this.getEntityName(), options);
+    translator.translateList(list, options.language, this.getTableName());
+    return list;
+  }
+  /**
+   * Finds a single entity by its primary key ID.
+   */
+  findById(id, options = {}) {
+    const entity = store.get(this.getEntityName(), id);
+    translator.translateEntity(entity, id, options.language, this.getTableName());
+    return entity ?? void 0;
+  }
+  /**
+   * Creates a new entity in the database.
+   * @returns The generated ID (string or number).
+   */
+  create(entity) {
+    const id = store.save(this.getEntityName(), entity);
+    this.triggerEvent({
+      operation: "create",
+      table: this.getTableName(),
+      entity,
+      key: {
+        name: this.getIdName(),
+        column: this.getIdColumn(),
+        value: id
+      }
+    });
+    return id;
+  }
+  /**
+   * Updates an existing entity.
+   * The entity must contain the primary key.
+   */
+  update(entity) {
+    const idName = this.getIdName();
+    const id = entity[idName];
+    const previousEntity = this.findById(id);
+    store.update(this.getEntityName(), entity);
+    this.triggerEvent({
+      operation: "update",
+      table: this.getTableName(),
+      entity,
+      previousEntity,
+      key: {
+        name: idName,
+        column: this.getIdColumn(),
+        value: id
+      }
+    });
+  }
+  /**
+   * Creates the entity if the ID is null/undefined, otherwise updates it.
+   * If an ID is provided but the entity doesn't exist, it creates it.
+   * @returns The entity's ID.
+   */
+  upsert(entity) {
+    const id = entity[this.getIdName()];
+    if (id === null || id === void 0) {
+      return store.save(this.getEntityName(), entity);
+    }
+    const existingEntity = store.get(this.getEntityName(), id);
+    if (existingEntity) {
+      this.update(entity);
+      return id;
+    } else {
+      return store.save(this.getEntityName(), entity);
+    }
+  }
+  /**
+   * Deletes an entity by its primary key ID.
+   */
+  deleteById(id) {
+    const entity = store.get(this.getEntityName(), id);
+    store.remove(this.getEntityName(), id);
+    this.triggerEvent({
+      operation: "delete",
+      table: this.getTableName(),
+      entity,
+      key: {
+        name: this.getIdName(),
+        column: this.getIdColumn(),
+        value: id
+      }
+    });
+  }
+  /**
+   * Counts the number of entities matching the given options.
+   */
+  count(options) {
+    return store.count(this.getEntityName(), options);
+  }
+  /**
+   * Protected method intended for subclass overriding or internal event handling.
+   */
+  async triggerEvent(_data) {
+  }
+}
+export {
+  Repository
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/repository.ts"],
  "sourcesContent": ["import { store, translator, EntityConstructor, Options } from \"@aerokit/sdk/db\";\n\n/**\n * Represents the data structure passed to the event trigger method before/after an operation.\n */\nexport interface EntityEvent<T> {\n    readonly operation: 'create' | 'update' | 'delete';\n    readonly table: string;\n    readonly entity: Partial<T>; // Use Partial<T> for create/delete where some fields might be missing\n    readonly key: {\n        name: string;\n        column: string;\n        value: string | number;\n    }\n    readonly previousEntity?: T;\n}\n\n\n// --- Repository Class ---\n\n/**\n * Abstract base class for data access/business logic, wrapping the `store` API.\n * It handles entity metadata lookup, CRUD operations, translation, and event triggering.\n * @template T The entity type (must be an object).\n */\nexport abstract class Repository<T extends Record<string, any>> {\n\n    private entityConstructor: EntityConstructor;\n\n    constructor(entityConstructor: EntityConstructor) {\n        this.entityConstructor = entityConstructor;\n        \n        // Caches entity metadata (name, table, id) onto the constructor function for static access\n\t\tif (!this.entityConstructor.$entity_name) {\n            // Assumes store methods return non-null strings\n\t\t\tthis.entityConstructor.$entity_name = (store as any).getEntityName(this.entityConstructor.name);\n\t\t\tthis.entityConstructor.$table_name = (store as any).getTableName(this.entityConstructor.name);\n\t\t\tthis.entityConstructor.$id_name = (store as any).getIdName(this.entityConstructor.name);\n\t\t\tthis.entityConstructor.$id_column = (store as any).getIdColumn(this.entityConstructor.name);\n\t\t}\n    }\n\n    protected getEntityName(): string {\n        // Use non-null assertion since the constructor guarantees these properties exist\n        return this.entityConstructor.$entity_name!;\n    }\n\n    protected getTableName(): string {\n        return this.entityConstructor.$table_name!;\n    }\n\n    protected getIdName(): string {\n        return this.entityConstructor.$id_name!;\n    }\n\n    protected getIdColumn(): string {\n        return this.entityConstructor.$id_column!;\n    }\n\n    /**\n     * Finds all entities matching the given options.\n     */\n    public findAll(options: Options = {}): T[] {\n        // Assume store.list returns T[] but we explicitly cast it to T[]\n        const list: T[] = (store as any).list(this.getEntityName(), options);\n        (translator as any).translateList(list, options.language, this.getTableName());\n        return list;\n    }\n\n    /**\n     * Finds a single entity by its primary key ID.\n     */\n    public findById(id: number | string, options: Options = {}): T | undefined {\n        // Assume store.get returns T or null/undefined\n        const entity: T | null = (store as any).get(this.getEntityName(), id);\n        (translator as any).translateEntity(entity, id, options.language, this.getTableName());\n        return entity ?? undefined;\n    }\n\n    /**\n     * Creates a new entity in the database.\n     * @returns The generated ID (string or number).\n     */\n    public create(entity: T): string | number {\n        const id = (store as any).save(this.getEntityName(), entity);\n        this.triggerEvent({\n            operation: \"create\",\n            table: this.getTableName(),\n            entity: entity,\n            key: {\n                name: this.getIdName(),\n                column: this.getIdColumn(),\n                value: id\n            }\n        });\n        return id;\n    }\n\n    /**\n     * Updates an existing entity.\n     * The entity must contain the primary key.\n     */\n    public update(entity: T): void {\n        const idName = this.getIdName();\n        const id = entity[idName] as (number | string);\n        \n        // Retrieve the entity state before update for the event payload\n        const previousEntity = this.findById(id);\n\n        (store as any).update(this.getEntityName(), entity);\n        \n        this.triggerEvent({\n            operation: \"update\",\n            table: this.getTableName(),\n            entity: entity,\n            previousEntity: previousEntity,\n            key: {\n                name: idName,\n                column: this.getIdColumn(),\n                value: id\n            }\n        });\n    }\n\n    /**\n     * Creates the entity if the ID is null/undefined, otherwise updates it.\n     * If an ID is provided but the entity doesn't exist, it creates it.\n     * @returns The entity's ID.\n     */\n    public upsert(entity: T): string | number {\n        const id = entity[this.getIdName()];\n        \n        // If no ID is present, save (create)\n        if (id === null || id === undefined) {\n            return (store as any).save(this.getEntityName(), entity);\n        }\n\n        // If ID is present, check existence\n        const existingEntity = (store as any).get(this.getEntityName(), id);\n        \n        if (existingEntity) {\n            this.update(entity);\n            return id;\n        } else {\n            // ID exists, but entity does not -> save (create with provided ID)\n            return (store as any).save(this.getEntityName(), entity);\n        }\n    }\n\n    /**\n     * Deletes an entity by its primary key ID.\n     */\n    public deleteById(id: number | string): void {\n        // Retrieve entity before removal for the event payload\n        const entity = (store as any).get(this.getEntityName(), id);\n        \n        (store as any).remove(this.getEntityName(), id);\n\n        this.triggerEvent({\n            operation: \"delete\",\n            table: this.getTableName(),\n            entity: entity,\n            key: {\n                name: this.getIdName(),\n                column: this.getIdColumn(),\n                value: id\n            }\n        });\n    }\n\n    /**\n     * Counts the number of entities matching the given options.\n     */\n    public count(options?: Options): number {\n        return (store as any).count(this.getEntityName(), options);\n    }\n\n    /**\n     * Protected method intended for subclass overriding or internal event handling.\n     */\n    protected async triggerEvent(_data: EntityEvent<T>): Promise<void> {\n        // Empty body as in the original code\n    }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/db/sequence.mjs

@@ -0,0 +1,40 @@
+const DatabaseFacade = Java.type("org.eclipse.dirigible.components.api.db.DatabaseFacade");
+class Sequence {
+  /**
+   * Retrieves the next available value from a specified sequence.
+   *
+   * @param sequence The name of the database sequence.
+   * @param tableName Optional: The name of the table associated with the sequence (depends on database dialect/facade implementation).
+   * @param datasourceName Optional: The name of the database connection to use.
+   * @returns The next sequence value as a number.
+   */
+  static nextval(sequence, tableName, datasourceName) {
+    return DatabaseFacade.nextval(sequence, datasourceName, tableName);
+  }
+  /**
+   * Creates a new database sequence.
+   *
+   * @param sequence The name of the sequence to create.
+   * @param start Optional: The starting value for the sequence (defaults to 1 if not provided).
+   * @param datasourceName Optional: The name of the database connection to use.
+   */
+  static create(sequence, start, datasourceName) {
+    DatabaseFacade.createSequence(sequence, start, datasourceName);
+  }
+  /**
+   * Drops (deletes) an existing database sequence.
+   *
+   * @param sequence The name of the sequence to drop.
+   * @param datasourceName Optional: The name of the database connection to use.
+   */
+  static drop(sequence, datasourceName) {
+    DatabaseFacade.dropSequence(sequence, datasourceName);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Sequence;
+}
+export {
+  Sequence
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2RiL3NlcXVlbmNlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEFQSSBTZXF1ZW5jZVxuICpcbiAqIFByb3ZpZGVzIHN0YXRpYyBtZXRob2RzIGZvciBtYW5hZ2luZyBhbmQgYWNjZXNzaW5nIGRhdGFiYXNlIHNlcXVlbmNlcy5cbiAqL1xuXG4vLyBJbXBvcnQgdGhlIEphdmEgdHlwZSB1c2VkIHRvIGJyaWRnZSB0byB0aGUgdW5kZXJseWluZyBkYXRhYmFzZSBmdW5jdGlvbmFsaXR5LlxuY29uc3QgRGF0YWJhc2VGYWNhZGUgPSBKYXZhLnR5cGUoXCJvcmcuZWNsaXBzZS5kaXJpZ2libGUuY29tcG9uZW50cy5hcGkuZGIuRGF0YWJhc2VGYWNhZGVcIik7XG5cbi8qKlxuICogVXRpbGl0eSBjbGFzcyBmb3IgaW50ZXJhY3Rpbmcgd2l0aCBkYXRhYmFzZSBzZXF1ZW5jZSBvYmplY3RzLlxuICovXG5leHBvcnQgY2xhc3MgU2VxdWVuY2Uge1xuXG5cdC8qKlxuXHQgKiBSZXRyaWV2ZXMgdGhlIG5leHQgYXZhaWxhYmxlIHZhbHVlIGZyb20gYSBzcGVjaWZpZWQgc2VxdWVuY2UuXG5cdCAqXG5cdCAqIEBwYXJhbSBzZXF1ZW5jZSBUaGUgbmFtZSBvZiB0aGUgZGF0YWJhc2Ugc2VxdWVuY2UuXG5cdCAqIEBwYXJhbSB0YWJsZU5hbWUgT3B0aW9uYWw6IFRoZSBuYW1lIG9mIHRoZSB0YWJsZSBhc3NvY2lhdGVkIHdpdGggdGhlIHNlcXVlbmNlIChkZXBlbmRzIG9uIGRhdGFiYXNlIGRpYWxlY3QvZmFjYWRlIGltcGxlbWVudGF0aW9uKS5cblx0ICogQHBhcmFtIGRhdGFzb3VyY2VOYW1lIE9wdGlvbmFsOiBUaGUgbmFtZSBvZiB0aGUgZGF0YWJhc2UgY29ubmVjdGlvbiB0byB1c2UuXG5cdCAqIEByZXR1cm5zIFRoZSBuZXh0IHNlcXVlbmNlIHZhbHVlIGFzIGEgbnVtYmVyLlxuXHQgKi9cblx0cHVibGljIHN0YXRpYyBuZXh0dmFsKHNlcXVlbmNlOiBzdHJpbmcsIHRhYmxlTmFtZT86IHN0cmluZywgZGF0YXNvdXJjZU5hbWU/OiBzdHJpbmcpOiBudW1iZXIge1xuXHRcdC8vIE5vdGU6IFRoZSBvcmlnaW5hbCBKYXZhU2NyaXB0IG9yZGVyIG9mIGFyZ3VtZW50cyBmb3IgRGF0YWJhc2VGYWNhZGUubmV4dHZhbCBpczpcblx0XHQvLyBEYXRhYmFzZUZhY2FkZS5uZXh0dmFsKHNlcXVlbmNlLCBkYXRhc291cmNlTmFtZSwgdGFibGVOYW1lKTtcblx0XHRyZXR1cm4gRGF0YWJhc2VGYWNhZGUubmV4dHZhbChzZXF1ZW5jZSwgZGF0YXNvdXJjZU5hbWUsIHRhYmxlTmFtZSk7XG5cdH1cblxuXHQvKipcblx0ICogQ3JlYXRlcyBhIG5ldyBkYXRhYmFzZSBzZXF1ZW5jZS5cblx0ICpcblx0ICogQHBhcmFtIHNlcXVlbmNlIFRoZSBuYW1lIG9mIHRoZSBzZXF1ZW5jZSB0byBjcmVhdGUuXG5cdCAqIEBwYXJhbSBzdGFydCBPcHRpb25hbDogVGhlIHN0YXJ0aW5nIHZhbHVlIGZvciB0aGUgc2VxdWVuY2UgKGRlZmF1bHRzIHRvIDEgaWYgbm90IHByb3ZpZGVkKS5cblx0ICogQHBhcmFtIGRhdGFzb3VyY2VOYW1lIE9wdGlvbmFsOiBUaGUgbmFtZSBvZiB0aGUgZGF0YWJhc2UgY29ubmVjdGlvbiB0byB1c2UuXG5cdCAqL1xuXHRwdWJsaWMgc3RhdGljIGNyZWF0ZShzZXF1ZW5jZTogc3RyaW5nLCBzdGFydD86IG51bWJlciwgZGF0YXNvdXJjZU5hbWU/OiBzdHJpbmcpOiB2b2lkIHtcblx0XHREYXRhYmFzZUZhY2FkZS5jcmVhdGVTZXF1ZW5jZShzZXF1ZW5jZSwgc3RhcnQsIGRhdGFzb3VyY2VOYW1lKTtcblx0fVxuXG5cdC8qKlxuXHQgKiBEcm9wcyAoZGVsZXRlcykgYW4gZXhpc3RpbmcgZGF0YWJhc2Ugc2VxdWVuY2UuXG5cdCAqXG5cdCAqIEBwYXJhbSBzZXF1ZW5jZSBUaGUgbmFtZSBvZiB0aGUgc2VxdWVuY2UgdG8gZHJvcC5cblx0ICogQHBhcmFtIGRhdGFzb3VyY2VOYW1lIE9wdGlvbmFsOiBUaGUgbmFtZSBvZiB0aGUgZGF0YWJhc2UgY29ubmVjdGlvbiB0byB1c2UuXG5cdCAqL1xuXHRwdWJsaWMgc3RhdGljIGRyb3Aoc2VxdWVuY2U6IHN0cmluZywgZGF0YXNvdXJjZU5hbWU/OiBzdHJpbmcpOiB2b2lkIHtcblx0XHREYXRhYmFzZUZhY2FkZS5kcm9wU2VxdWVuY2Uoc2VxdWVuY2UsIGRhdGFzb3VyY2VOYW1lKTtcblx0fVxufVxuXG4vLyBAdHMtaWdub3JlXG5pZiAodHlwZW9mIG1vZHVsZSAhPT0gJ3VuZGVmaW5lZCcpIHtcblx0Ly8gQHRzLWlnbm9yZVxuXHRtb2R1bGUuZXhwb3J0cyA9IFNlcXVlbmNlO1xufSJdLAogICJtYXBwaW5ncyI6ICJBQU9BLE1BQU0saUJBQWlCLEtBQUssS0FBSyx3REFBd0Q7QUFLbEYsTUFBTSxTQUFTO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBVXJCLE9BQWMsUUFBUSxVQUFrQixXQUFvQixnQkFBaUM7QUFHNUYsV0FBTyxlQUFlLFFBQVEsVUFBVSxnQkFBZ0IsU0FBUztBQUFBLEVBQ2xFO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQVNBLE9BQWMsT0FBTyxVQUFrQixPQUFnQixnQkFBK0I7QUFDckYsbUJBQWUsZUFBZSxVQUFVLE9BQU8sY0FBYztBQUFBLEVBQzlEO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFRQSxPQUFjLEtBQUssVUFBa0IsZ0JBQStCO0FBQ25FLG1CQUFlLGFBQWEsVUFBVSxjQUFjO0FBQUEsRUFDckQ7QUFDRDtBQUdBLElBQUksT0FBTyxXQUFXLGFBQWE7QUFFbEMsU0FBTyxVQUFVO0FBQ2xCOyIsCiAgIm5hbWVzIjogW10KfQo=