@aerokit/sdk 12.44.0

package/dist/esm/db/store.mjs

@@ -0,0 +1,153 @@
+const DataStoreFacade = Java.type("org.eclipse.dirigible.components.api.db.DataStoreFacade");
+var Operator = /* @__PURE__ */ ((Operator2) => {
+  Operator2["EQ"] = "=";
+  Operator2["NE"] = "<>";
+  Operator2["GT"] = ">";
+  Operator2["LT"] = "<";
+  Operator2["GE"] = ">=";
+  Operator2["LE"] = "<=";
+  Operator2["LIKE"] = "LIKE";
+  Operator2["BETWEEN"] = "BETWEEN";
+  Operator2["IN"] = "IN";
+  return Operator2;
+})(Operator || {});
+var Direction = /* @__PURE__ */ ((Direction2) => {
+  Direction2["ASC"] = "ASC";
+  Direction2["DESC"] = "DESC";
+  return Direction2;
+})(Direction || {});
+class Store {
+  /**
+   * Saves a new entry to the data store.
+   * @param name The entity/table name.
+   * @param entry The JavaScript object to save.
+   * @returns The ID of the newly created entry (string or number).
+   */
+  static save(name, entry) {
+    return DataStoreFacade.save(name, JSON.stringify(entry));
+  }
+  /**
+   * Inserts a new entry or updates an existing one if the ID is present.
+   * @param name The entity/table name.
+   * @param entry The JavaScript object to insert/update.
+   */
+  static upsert(name, entry) {
+    DataStoreFacade.upsert(name, JSON.stringify(entry));
+  }
+  /**
+   * Updates an existing entry.
+   * @param name The entity/table name.
+   * @param entry The JavaScript object with the ID and updated data.
+   */
+  static update(name, entry) {
+    DataStoreFacade.update(name, JSON.stringify(entry));
+  }
+  /**
+   * Lists entries based on optional filtering, sorting, and pagination options.
+   * @param name The entity/table name.
+   * @param options Optional {@link Options} for query execution.
+   * @returns An array of JavaScript objects.
+   */
+  static list(name, options) {
+    const result = DataStoreFacade.list(name, options ? JSON.stringify(options) : null);
+    return JSON.parse(result);
+  }
+  /**
+   * Counts the number of entries based on optional filtering options.
+   * @param name The entity/table name.
+   * @param options Optional {@link Options} for query execution.
+   * @returns The count of matching entries.
+   */
+  static count(name, options) {
+    const optionsString = options ? JSON.stringify(options) : null;
+    const result = DataStoreFacade.count(name, optionsString);
+    return result;
+  }
+  /**
+   * Retrieves a single entry by its ID.
+   * @param name The entity/table name.
+   * @param id The ID of the entry.
+   * @returns The entry object, or undefined if not found.
+   */
+  static get(name, id) {
+    const result = DataStoreFacade.get(name, id);
+    if (result === null || result === void 0 || result === "") {
+      return void 0;
+    }
+    return JSON.parse(result);
+  }
+  /**
+   * Deletes an entry by its ID.
+   * @param name The entity/table name.
+   * @param id The ID of the entry to remove.
+   */
+  static remove(name, id) {
+    DataStoreFacade.deleteEntry(name, id);
+  }
+  /**
+   * Finds entries matching an example object (query-by-example).
+   * @param name The entity/table name.
+   * @param example An object containing properties to match.
+   * @param limit Maximum number of results to return.
+   * @param offset Number of results to skip.
+   * @returns An array of matching JavaScript objects.
+   */
+  static find(name, example, limit = 100, offset = 0) {
+    const result = DataStoreFacade.find(name, JSON.stringify(example), limit, offset);
+    return JSON.parse(result);
+  }
+  /**
+   * Queries all entries for a given entity name with pagination.
+   * @param name The entity/table name.
+   * @param limit Maximum number of results to return.
+   * @param offset Number of results to skip.
+   * @returns An array of JavaScript objects.
+   */
+  static query(name, limit = 100, offset = 0) {
+    const result = DataStoreFacade.query(name, limit, offset);
+    return JSON.parse(result);
+  }
+  /**
+   * Queries all entries for a given entity name without pagination.
+   * @param name The entity/table name.
+   * @returns An array of all JavaScript objects.
+   */
+  static queryNative(name) {
+    const result = DataStoreFacade.queryNative(name);
+    return JSON.parse(result);
+  }
+  // --- Metadata Getters ---
+  /**
+   * Gets the name of the entity associated with the store name.
+   */
+  static getEntityName(name) {
+    return DataStoreFacade.getEntityName(name);
+  }
+  /**
+   * Gets the underlying database table name for the entity.
+   */
+  static getTableName(name) {
+    return DataStoreFacade.getTableName(name);
+  }
+  /**
+   * Gets the property name used as the ID field in the entity object.
+   */
+  static getIdName(name) {
+    return DataStoreFacade.getIdName(name);
+  }
+  /**
+   * Gets the underlying database column name used for the ID field.
+   */
+  static getIdColumn(name) {
+    return DataStoreFacade.getIdColumn(name);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Store;
+}
+export {
+  Direction,
+  Operator,
+  Store
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/store.ts"],
  "sourcesContent": ["const DataStoreFacade = Java.type(\"org.eclipse.dirigible.components.api.db.DataStoreFacade\");\n\n/**\n * Defines the available comparison operators for query conditions.\n */\nexport enum Operator {\n\tEQ = \"=\", // Equals\n\tNE = \"<>\", // Not Equals\n\tGT = \">\", // Greater Than\n\tLT = \"<\", // Less Than\n\tGE = \">=\", // Greater Than or Equals\n\tLE = \"<=\", // Less Than or Equals\n\tLIKE = \"LIKE\", // SQL LIKE operator\n\tBETWEEN = \"BETWEEN\", // SQL BETWEEN operator (requires two values)\n\tIN = \"IN\" // SQL IN operator (requires a List or Array of values)\n}\n\n/**\n * Defines the direction for sorting.\n */\nexport enum Direction {\n\tASC = \"ASC\", // Ascending\n\tDESC = \"DESC\" // Descending\n}\n\n/**\n * Represents a single condition for filtering data.\n */\nexport interface Condition {\n\tpropertyName: string,\n\toperator: Operator,\n\tvalue: any | any[]\n}\n\n/**\n * Represents a single sorting instruction.\n */\nexport interface Sort {\n\tpropertyName: string,\n\tdirection: Direction\n}\n\n/**\n * Defines optional parameters for list and count operations.\n */\nexport interface Options {\n\tconditions?: Condition[],\n\tsorts?: Sort[],\n\tlimit?: number,\n\toffset?: number,\n\tlanguage?: string\n}\n\n/**\n * Facade class for interacting with the underlying Dirigible Data Store.\n * All methods serialize/deserialize JavaScript objects to/from JSON strings\n * before interacting with the native Java facade.\n */\nexport class Store {\n\n\t/**\n\t * Saves a new entry to the data store.\n\t * @param name The entity/table name.\n\t * @param entry The JavaScript object to save.\n\t * @returns The ID of the newly created entry (string or number).\n\t */\n\tpublic static save(name: string, entry: any): string | number {\n\t\treturn DataStoreFacade.save(name, JSON.stringify(entry));\n\t}\n\t\n\t/**\n\t * Inserts a new entry or updates an existing one if the ID is present.\n\t * @param name The entity/table name.\n\t * @param entry The JavaScript object to insert/update.\n\t */\n\tpublic static upsert(name: string, entry: any): void {\n\t\tDataStoreFacade.upsert(name, JSON.stringify(entry));\n\t}\n\t\n\t/**\n\t * Updates an existing entry.\n\t * @param name The entity/table name.\n\t * @param entry The JavaScript object with the ID and updated data.\n\t */\n\tpublic static update(name: string, entry: any): void {\n\t\tDataStoreFacade.update(name, JSON.stringify(entry));\n\t}\n\t\n\t/**\n\t * Lists entries based on optional filtering, sorting, and pagination options.\n\t * @param name The entity/table name.\n\t * @param options Optional {@link Options} for query execution.\n\t * @returns An array of JavaScript objects.\n\t */\n\tpublic static list(name: string, options?: Options): any[] {\n\t\tconst result = DataStoreFacade.list(name, options ? JSON.stringify(options) : null);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t/**\n\t * Counts the number of entries based on optional filtering options.\n\t * @param name The entity/table name.\n\t * @param options Optional {@link Options} for query execution.\n\t * @returns The count of matching entries.\n\t */\n\tpublic static count(name: string, options?: Options): number {\n\t\tconst optionsString = options ? JSON.stringify(options) : null;\n\t\tconst result = DataStoreFacade.count(name, optionsString);\n\t\treturn result;\n\t}\n\n\t/**\n\t * Retrieves a single entry by its ID.\n\t * @param name The entity/table name.\n\t * @param id The ID of the entry.\n\t * @returns The entry object, or undefined if not found.\n\t */\n\tpublic static get(name: string, id: any): any | undefined {\n\t\tconst result = DataStoreFacade.get(name, id);\n\t\t// Assuming the native API returns null/undefined or an empty JSON string if not found, \n\t\t// otherwise JSON.parse handles the conversion.\n\t\tif (result === null || result === undefined || result === \"\") {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn JSON.parse(result);\n\t};\n\n\t/**\n\t * Deletes an entry by its ID.\n\t * @param name The entity/table name.\n\t * @param id The ID of the entry to remove.\n\t */\n\tpublic static remove(name: string, id: any): void {\n\t\tDataStoreFacade.deleteEntry(name, id);\n\t}\n\t\n\t/**\n\t * Finds entries matching an example object (query-by-example).\n\t * @param name The entity/table name.\n\t * @param example An object containing properties to match.\n\t * @param limit Maximum number of results to return.\n\t * @param offset Number of results to skip.\n\t * @returns An array of matching JavaScript objects.\n\t */\n\tpublic static find(name: string, example: any, limit: number = 100, offset: number = 0): any[] {\n\t\tconst result = DataStoreFacade.find(name, JSON.stringify(example), limit, offset);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t/**\n\t * Queries all entries for a given entity name with pagination.\n\t * @param name The entity/table name.\n\t * @param limit Maximum number of results to return.\n\t * @param offset Number of results to skip.\n\t * @returns An array of JavaScript objects.\n\t */\n\tpublic static query(name: string, limit: number = 100, offset: number = 0): any[] {\n\t\tconst result = DataStoreFacade.query(name, limit, offset);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t/**\n\t * Queries all entries for a given entity name without pagination.\n\t * @param name The entity/table name.\n\t * @returns An array of all JavaScript objects.\n\t */\n\tpublic static queryNative(name: string): any[] {\n\t\tconst result = DataStoreFacade.queryNative(name);\n\t\treturn JSON.parse(result);\n\t}\n\t\n\t// --- Metadata Getters ---\n\n\t/**\n\t * Gets the name of the entity associated with the store name.\n\t */\n\tpublic static getEntityName(name: string): string {\n\t\treturn DataStoreFacade.getEntityName(name);\n\t}\n\t\n\t/**\n\t * Gets the underlying database table name for the entity.\n\t */\n\tpublic static getTableName(name: string): string {\n\t\treturn DataStoreFacade.getTableName(name);\n\t}\n\t\t\n\t/**\n\t * Gets the property name used as the ID field in the entity object.\n\t */\n\tpublic static getIdName(name: string): string {\n\t\treturn DataStoreFacade.getIdName(name);\n\t}\n\t\t\t\n\t/**\n\t * Gets the underlying database column name used for the ID field.\n\t */\n\tpublic static getIdColumn(name: string): string {\n\t\treturn DataStoreFacade.getIdColumn(name);\n\t}\n\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Store;\n}"],
  "mappings": "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",
  "names": ["Operator", "Direction"]
}


package/dist/esm/db/translator.mjs

@@ -0,0 +1,81 @@
+import { sql, query } from "@aerokit/sdk/db";
+class Translator {
+  /**
+   * Translates properties for a list of entities by querying the corresponding language table.
+   *
+   * @param list The array of entities to be translated.
+   * @param language The target language code (e.g., 'en', 'de'). If undefined, no translation occurs.
+   * @param basetTable The name of the base entity table (used to derive the language table name).
+   * @returns The translated array of entities.
+   */
+  static translateList(list, language, basetTable) {
+    if (list && language) {
+      try {
+        const script = sql.getDialect().select().column("*").from('"' + basetTable + '_LANG"').where("Language = ?").build();
+        const resultSet = query.execute(script, [language]);
+        if (resultSet && resultSet.length > 0) {
+          const translatedProperties = Object.getOwnPropertyNames(resultSet[0]);
+          const ID_PROPERTY_NAME = translatedProperties[0];
+          const NUM_TRANSLATED_PROPERTIES = translatedProperties.length - 2;
+          const translationMaps = Array(NUM_TRANSLATED_PROPERTIES).fill(null).map(() => ({}));
+          resultSet.forEach((r) => {
+            const idValue = r[ID_PROPERTY_NAME];
+            for (let i = 0; i < NUM_TRANSLATED_PROPERTIES; i++) {
+              translationMaps[i][idValue] = r[translatedProperties[i + 1]];
+            }
+          });
+          list.forEach((r) => {
+            const idValue = r[ID_PROPERTY_NAME];
+            for (let i = 0; i < NUM_TRANSLATED_PROPERTIES; i++) {
+              const translatedKey = translatedProperties[i + 1];
+              const translatedValue = translationMaps[i][idValue];
+              if (translatedValue !== void 0 && translatedValue !== null) {
+                r[translatedKey] = translatedValue;
+              }
+            }
+          });
+        }
+      } catch (error) {
+        console.error("Entity is marked as language dependent, but no language table present for: " + basetTable, error);
+      }
+    }
+    return list;
+  }
+  /**
+   * Translates properties for a single entity by querying the corresponding language table.
+   *
+   * @param entity The entity object to be translated.
+   * @param id The ID of the entity.
+   * @param language The target language code (e.g., 'en', 'de'). If undefined, no translation occurs.
+   * @param basetTable The name of the base entity table.
+   * @returns The translated entity object.
+   */
+  static translateEntity(entity, id, language, basetTable) {
+    if (entity && language) {
+      try {
+        const script = sql.getDialect().select().column("*").from('"' + basetTable + '_LANG"').where("Language = ?").where("Id = ?").build();
+        const resultSet = query.execute(script, [language, id]);
+        if (resultSet && resultSet.length > 0) {
+          const translationRow = resultSet[0];
+          for (const key in translationRow) {
+            if (translationRow.hasOwnProperty(key)) {
+              if (key !== "Id" && key !== "Language") {
+                entity[key] = translationRow[key];
+              }
+            }
+          }
+        }
+      } catch (error) {
+        console.error("Entity is marked as language dependent, but no language table present for: " + basetTable, error);
+      }
+    }
+    return entity;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Translator;
+}
+export {
+  Translator
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/db/translator.ts"],
  "sourcesContent": ["import { sql, query } from \"@aerokit/sdk/db\";\n\n/**\n * Provides static methods for translating entity properties based on a dedicated language table.\n * Translation is achieved by querying a separate table (e.g., 'BASE_TABLE_LANG') and merging\n * the translated fields back into the original data.\n */\nexport class Translator {\n\n\t/**\n\t * Translates properties for a list of entities by querying the corresponding language table.\n\t *\n\t * @param list The array of entities to be translated.\n\t * @param language The target language code (e.g., 'en', 'de'). If undefined, no translation occurs.\n\t * @param basetTable The name of the base entity table (used to derive the language table name).\n\t * @returns The translated array of entities.\n\t */\n\tpublic static translateList(list: any[], language: string | undefined, basetTable: string): any[] {\n        if (list && language) {\n            try {\n\t\t\t\t// Construct the query for all translated columns in the target language.\n\t\t\t\t// Assumes the language table is named 'BASE_TABLE_LANG'.\n                const script = sql.getDialect()\n                    .select()\n                    .column(\"*\")\n                    .from('\"' + basetTable + '_LANG\"')\n                    .where('Language = ?')\n                    .build();\n\n                const resultSet: any[] = query.execute(script, [language]);\n\n\t\t\t\t// Check if any translations were found\n                if (resultSet && resultSet.length > 0) {\n                    const translatedProperties = Object.getOwnPropertyNames(resultSet[0]);\n                    \n\t\t\t\t\t// Assumption: translatedProperties[0] is the entity ID property name.\n\t\t\t\t\t// Assumption: The last two properties are the ID property and the Language property, leaving N-2 for translated data.\n                    const ID_PROPERTY_NAME = translatedProperties[0];\n                    const NUM_TRANSLATED_PROPERTIES = translatedProperties.length - 2;\n                    \n\t\t\t\t\t// Create an array of maps, one map per translated property name: { ID_value -> translated_value }\n                    const translationMaps: Record<any, any>[] = Array(NUM_TRANSLATED_PROPERTIES).fill(null).map(() => ({}));\n                    \n                    // Populate the translation maps from the result set\n                    resultSet.forEach((r) => {\n                        const idValue = r[ID_PROPERTY_NAME];\n                        for (let i = 0; i < NUM_TRANSLATED_PROPERTIES; i++) {\n\t\t\t\t\t\t\t// translatedProperties[i + 1] holds the actual translated field name\n                            translationMaps[i][idValue] = r[translatedProperties[i + 1]];\n                        }\n                    });\n\n\t\t\t\t\t// Apply the translations to the original list\n                    list.forEach((r) => {\n                        const idValue = r[ID_PROPERTY_NAME];\n                        for (let i = 0; i < NUM_TRANSLATED_PROPERTIES; i++) {\n                            const translatedKey = translatedProperties[i + 1];\n                            const translatedValue = translationMaps[i][idValue];\n                            \n                            if (translatedValue !== undefined && translatedValue !== null) {\n\t\t\t\t\t\t\t\t// Overwrite the base property with the translated value\n                                r[translatedKey] = translatedValue;\n                            }\n                        }\n                    });\n                }\n            } catch (error) {\n                console.error(\"Entity is marked as language dependent, but no language table present for: \" + basetTable, error);\n            }\n        }\n        return list;\n    }\n\t\n\t/**\n\t * Translates properties for a single entity by querying the corresponding language table.\n\t *\n\t * @param entity The entity object to be translated.\n\t * @param id The ID of the entity.\n\t * @param language The target language code (e.g., 'en', 'de'). If undefined, no translation occurs.\n\t * @param basetTable The name of the base entity table.\n\t * @returns The translated entity object.\n\t */\n\tpublic static translateEntity(entity: any, id: string | number, language: string | undefined, basetTable: string): any {\n        if (entity && language) {\n            try {\n\t\t\t\t// Construct the query for a specific ID and Language\n                const script = sql.getDialect()\n                    .select()\n                    .column(\"*\")\n                    .from('\"' + basetTable + '_LANG\"')\n                    .where('Language = ?')\n                    .where('Id = ?')\n                    .build();\n\n                const resultSet: any[] = query.execute(script, [language, id]);\n\n\t\t\t\t// Since we query by Id and Language, we expect at most one row.\n                if (resultSet && resultSet.length > 0) {\n                    const translationRow = resultSet[0];\n                    \n\t\t\t\t\t// Iterate through the properties of the translation row and merge them into the entity.\n\t\t\t\t\t// We must assume that the base table columns (except ID and Language keys) align with the translation table columns.\n                    for (const key in translationRow) {\n                        if (translationRow.hasOwnProperty(key)) {\n\t\t\t\t\t\t\t// Avoid overwriting the entity's ID and Language key if they exist, \n\t\t\t\t\t\t\t// although typically the language key is not present in the base entity.\n                            if (key !== 'Id' && key !== 'Language') {\n                                entity[key] = translationRow[key];\n                            }\n                        }\n                    }\n                }\n            } catch (error) {\n                console.error(\"Entity is marked as language dependent, but no language table present for: \" + basetTable, error);\n            }\n        }\n        return entity;\n    }\n\t\t\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Translator;\n}\n"],
  "mappings": "AAAA,SAAS,KAAK,aAAa;AAOpB,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUvB,OAAc,cAAc,MAAa,UAA8B,YAA2B;AAC3F,QAAI,QAAQ,UAAU;AAClB,UAAI;AAGA,cAAM,SAAS,IAAI,WAAW,EACzB,OAAO,EACP,OAAO,GAAG,EACV,KAAK,MAAM,aAAa,QAAQ,EAChC,MAAM,cAAc,EACpB,MAAM;AAEX,cAAM,YAAmB,MAAM,QAAQ,QAAQ,CAAC,QAAQ,CAAC;AAGzD,YAAI,aAAa,UAAU,SAAS,GAAG;AACnC,gBAAM,uBAAuB,OAAO,oBAAoB,UAAU,CAAC,CAAC;AAIpE,gBAAM,mBAAmB,qBAAqB,CAAC;AAC/C,gBAAM,4BAA4B,qBAAqB,SAAS;AAGhE,gBAAM,kBAAsC,MAAM,yBAAyB,EAAE,KAAK,IAAI,EAAE,IAAI,OAAO,CAAC,EAAE;AAGtG,oBAAU,QAAQ,CAAC,MAAM;AACrB,kBAAM,UAAU,EAAE,gBAAgB;AAClC,qBAAS,IAAI,GAAG,IAAI,2BAA2B,KAAK;AAEhD,8BAAgB,CAAC,EAAE,OAAO,IAAI,EAAE,qBAAqB,IAAI,CAAC,CAAC;AAAA,YAC/D;AAAA,UACJ,CAAC;AAGD,eAAK,QAAQ,CAAC,MAAM;AAChB,kBAAM,UAAU,EAAE,gBAAgB;AAClC,qBAAS,IAAI,GAAG,IAAI,2BAA2B,KAAK;AAChD,oBAAM,gBAAgB,qBAAqB,IAAI,CAAC;AAChD,oBAAM,kBAAkB,gBAAgB,CAAC,EAAE,OAAO;AAElD,kBAAI,oBAAoB,UAAa,oBAAoB,MAAM;AAE3D,kBAAE,aAAa,IAAI;AAAA,cACvB;AAAA,YACJ;AAAA,UACJ,CAAC;AAAA,QACL;AAAA,MACJ,SAAS,OAAO;AACZ,gBAAQ,MAAM,gFAAgF,YAAY,KAAK;AAAA,MACnH;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWH,OAAc,gBAAgB,QAAa,IAAqB,UAA8B,YAAyB;AAChH,QAAI,UAAU,UAAU;AACpB,UAAI;AAEA,cAAM,SAAS,IAAI,WAAW,EACzB,OAAO,EACP,OAAO,GAAG,EACV,KAAK,MAAM,aAAa,QAAQ,EAChC,MAAM,cAAc,EACpB,MAAM,QAAQ,EACd,MAAM;AAEX,cAAM,YAAmB,MAAM,QAAQ,QAAQ,CAAC,UAAU,EAAE,CAAC;AAG7D,YAAI,aAAa,UAAU,SAAS,GAAG;AACnC,gBAAM,iBAAiB,UAAU,CAAC;AAIlC,qBAAW,OAAO,gBAAgB;AAC9B,gBAAI,eAAe,eAAe,GAAG,GAAG;AAGpC,kBAAI,QAAQ,QAAQ,QAAQ,YAAY;AACpC,uBAAO,GAAG,IAAI,eAAe,GAAG;AAAA,cACpC;AAAA,YACJ;AAAA,UACJ;AAAA,QACJ;AAAA,MACJ,SAAS,OAAO;AACZ,gBAAQ,MAAM,gFAAgF,YAAY,KAAK;AAAA,MACnH;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AAEJ;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": []
}


package/dist/esm/db/update.mjs

@@ -0,0 +1,24 @@
+const DatabaseFacade = Java.type("org.eclipse.dirigible.components.api.db.DatabaseFacade");
+class Update {
+  /**
+   * Executes a parameterized SQL update statement (INSERT, UPDATE, or DELETE).
+   *
+   * @param sql The SQL statement to execute.
+   * @param parameters Optional array of parameters to bind to the SQL statement (replaces '?').
+   * These are serialized to JSON before being passed to the native API.
+   * @param datasourceName Optional name of the data source to use. Defaults to the primary data source.
+   * @returns The number of rows affected by the statement.
+   */
+  static execute(sql, parameters, datasourceName) {
+    const parametersJson = parameters ? JSON.stringify(parameters) : void 0;
+    const result = DatabaseFacade.update(sql, parametersJson, datasourceName);
+    return result;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Update;
+}
+export {
+  Update
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/etcd/client.mjs

@@ -0,0 +1,155 @@
+const EtcdFacade = Java.type("org.eclipse.dirigible.components.api.etcd.EtcdFacade");
+function StringToByteSequence(str) {
+  return EtcdFacade.stringToByteSequence(str);
+}
+function ByteArrayToByteSequence(arr) {
+  return EtcdFacade.byteArrayToByteSequence(arr);
+}
+function ByteSequenceToString(value) {
+  return EtcdFacade.byteSequenceToString(value);
+}
+function BytesToArray(value) {
+  const array = value.getBytes();
+  const result = new Int8Array(array.length);
+  for (let i = 0; i < array.length; i++) {
+    result[i] = parseInt(array[i], 10);
+  }
+  return result;
+}
+function KeyValueObject(kvsList, func) {
+  const kvObject = {};
+  kvsList.forEach((kvs) => {
+    const key = ByteSequenceToString(kvs.getKey());
+    const value = func(kvs.getValue());
+    kvObject[key] = value;
+  });
+  return kvObject;
+}
+function KeyValueObjectString(kvsList) {
+  return KeyValueObject(kvsList, ByteSequenceToString);
+}
+function KeyValueObjectByteArray(kvsList) {
+  return KeyValueObject(kvsList, BytesToArray);
+}
+class Header {
+  constructor(native) {
+    this.native = native;
+  }
+  /** The revision of the key-value store when the request was processed. */
+  getRevision() {
+    return this.native.getRevision();
+  }
+  /** The ID of the cluster which the request was sent to. */
+  getClusterId() {
+    return this.native.getClusterId();
+  }
+  /** The ID of the member which the request was handled by. */
+  getMemberId() {
+    return this.native.getMemberId();
+  }
+  /** The Raft term. */
+  getRaftTerm() {
+    return this.native.getRaftTerm();
+  }
+}
+class GetResponse {
+  constructor(native) {
+    this.native = native;
+  }
+  /** Retrieves the response header containing cluster metadata. */
+  getHeader() {
+    const nativeHeader = this.native.getHeader();
+    return new Header(nativeHeader);
+  }
+  /** Retrieves the Key-Value pairs with values converted to strings. */
+  getKvsString() {
+    return KeyValueObjectString(this.native.getKvs());
+  }
+  /** Retrieves the Key-Value pairs with values converted to Int8Array (byte arrays). */
+  getKvsByteArray() {
+    return KeyValueObjectByteArray(this.native.getKvs());
+  }
+  /** Retrieves the number of Key-Value pairs returned. */
+  getCount() {
+    return this.native.getCount();
+  }
+}
+class Client {
+  constructor() {
+    this.native = EtcdFacade.getClient();
+  }
+  /**
+   * Executes a blocking GET request on the specified key.
+   * @param key The key to retrieve.
+   * @returns The processed GetResponse object.
+   */
+  get(key) {
+    const etcdCompletableFuture = this.native.get(StringToByteSequence(key));
+    const nativeResponse = etcdCompletableFuture.get();
+    return new GetResponse(nativeResponse);
+  }
+  /**
+   * Puts (writes) a string value to the specified key.
+   * @param key The key to write to.
+   * @param value The string value.
+   */
+  putStringValue(key, value) {
+    this.native.put(StringToByteSequence(key), StringToByteSequence(value));
+  }
+  /**
+   * Puts (writes) a byte array value to the specified key.
+   * @param key The key to write to.
+   * @param value The Int8Array (byte array) value.
+   */
+  putByteArrayValue(key, value) {
+    this.native.put(StringToByteSequence(key), ByteArrayToByteSequence(value));
+  }
+  /**
+   * Retrieves the response header metadata for a key.
+   * @param key The key to query.
+   * @returns The {@link Header} object.
+   */
+  getHeader(key) {
+    return this.get(key).getHeader();
+  }
+  /**
+   * Retrieves the Key-Value pairs as a JavaScript object with string values.
+   * @param key The key (or key prefix) to query.
+   * @returns An object mapping keys to string values.
+   */
+  getKvsStringValue(key) {
+    return this.get(key).getKvsString();
+  }
+  /**
+   * Retrieves the Key-Value pairs as a JavaScript object with Int8Array values.
+   * @param key The key (or key prefix) to query.
+   * @returns An object mapping keys to Int8Array values.
+   */
+  getKvsByteArrayValue(key) {
+    return this.get(key).getKvsByteArray();
+  }
+  /**
+   * Retrieves the count of Key-Value pairs matching the key (or key prefix).
+   * @param key The key (or key prefix) to query.
+   * @returns The count of matching entries.
+   */
+  getCount(key) {
+    return this.get(key).getCount();
+  }
+  /**
+   * Deletes the specified key.
+   * @param key The key to delete.
+   */
+  delete(key) {
+    this.native.delete(StringToByteSequence(key));
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Client;
+}
+export {
+  Client,
+  GetResponse,
+  Header
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/etcd/client.ts"],
  "sourcesContent": ["const EtcdFacade = Java.type(\"org.eclipse.dirigible.components.api.etcd.EtcdFacade\");\n\n// =============================================================================\n// UTILITY FUNCTIONS\n// These functions handle the conversion between JavaScript/TypeScript types (string, Int8Array)\n// and the native Java/Etcd types (ByteSequence, native byte arrays).\n// =============================================================================\n\n/**\n * Converts a string to a native Etcd ByteSequence object.\n * @param str The string to convert.\n * @returns The native ByteSequence object (Java type).\n */\nfunction StringToByteSequence(str: string): any {\n    return EtcdFacade.stringToByteSequence(str);\n}\n\n/**\n * Converts a JavaScript Int8Array (byte array) to a native Etcd ByteSequence object.\n * @param arr The Int8Array to convert.\n * @returns The native ByteSequence object (Java type).\n */\nfunction ByteArrayToByteSequence(arr: Int8Array): any {\n    return EtcdFacade.byteArrayToByteSequence(arr);\n}\n\n/**\n * Converts a native Etcd ByteSequence object back to a string.\n * @param value The native ByteSequence object.\n * @returns The decoded string.\n */\nfunction ByteSequenceToString(value: any): string {\n    return EtcdFacade.byteSequenceToString(value);\n}\n\n/**\n * Converts a native Java array of bytes into a JavaScript Int8Array.\n * @param value The native ByteSequence object containing the bytes.\n * @returns A JavaScript Int8Array.\n */\nfunction BytesToArray(value: any): Int8Array {\n    const array = value.getBytes(); // Get the native byte array\n    const result = new Int8Array(array.length);\n    for (let i = 0; i < array.length; i++) {\n        // Conversion from Java byte to JavaScript Int8 value\n        result[i] = parseInt(array[i], 10); \n    }\n    return result;\n}\n\n/**\n * Helper to process a list of Key-Value (KV) objects into a standard JavaScript object.\n * @param kvsList The native list of KV objects.\n * @param func The conversion function for the value (e.g., ByteSequenceToString or BytesToArray).\n * @returns A standard JavaScript object mapping string keys to specified values.\n */\nfunction KeyValueObject<T>(kvsList: any[], func: (value: any) => T): { [key: string]: T } {\n    const kvObject: { [key: string]: T } = {};\n    kvsList.forEach((kvs: any) => {\n        const key: string = ByteSequenceToString(kvs.getKey());\n        const value: T = func(kvs.getValue());\n        kvObject[key] = value;\n    });\n\n    return kvObject;\n}\n\n/**\n * Processes native KVS list to a JavaScript object with string values.\n */\nfunction KeyValueObjectString(kvsList: any[]): { [key: string]: string } {\n    return KeyValueObject(kvsList, ByteSequenceToString);\n}\n\n/**\n * Processes native KVS list to a JavaScript object with Int8Array values.\n */\nfunction KeyValueObjectByteArray(kvsList: any[]): { [key: string]: Int8Array } {\n    return KeyValueObject(kvsList, BytesToArray);\n}\n\n// =============================================================================\n// ETCD RESPONSE CLASSES\n// =============================================================================\n\n/**\n * Represents the header metadata of an Etcd response.\n */\nexport class Header {\n    private readonly native: any;\n\n    constructor(native: any) {\n        this.native = native;\n    }\n\n    /** The revision of the key-value store when the request was processed. */\n    public getRevision(): string {\n        return this.native.getRevision();\n    }\n\n    /** The ID of the cluster which the request was sent to. */\n    public getClusterId(): string {\n        return this.native.getClusterId();\n    }\n\n    /** The ID of the member which the request was handled by. */\n    public getMemberId(): string {\n        return this.native.getMemberId();\n    }\n\n    /** The Raft term. */\n    public getRaftTerm(): string {\n        return this.native.getRaftTerm();\n    }\n}\n\n/**\n * Represents the response object for a Get operation from Etcd.\n */\nexport class GetResponse {\n    private readonly native: any;\n\n    constructor(native: any) {\n        this.native = native;\n    }\n\n    /** Retrieves the response header containing cluster metadata. */\n    public getHeader(): Header {\n        const nativeHeader = this.native.getHeader();\n        return new Header(nativeHeader);\n    }\n\n    /** Retrieves the Key-Value pairs with values converted to strings. */\n    public getKvsString(): { [key: string]: string } {\n        return KeyValueObjectString(this.native.getKvs());\n    }\n\n    /** Retrieves the Key-Value pairs with values converted to Int8Array (byte arrays). */\n    public getKvsByteArray(): { [key: string]: Int8Array } {\n        return KeyValueObjectByteArray(this.native.getKvs());\n    }\n\n    /** Retrieves the number of Key-Value pairs returned. */\n    public getCount(): number {\n        return this.native.getCount();\n    }\n}\n\n\n// =============================================================================\n// ETCD CLIENT FACADE\n// =============================================================================\n\n/**\n * Client facade for interacting with the Etcd key-value store.\n */\nexport class Client {\n\n    private readonly native: any;\n\n    constructor() {\n        this.native = EtcdFacade.getClient();\n    }\n\n    /**\n     * Executes a blocking GET request on the specified key.\n     * @param key The key to retrieve.\n     * @returns The processed GetResponse object.\n     */\n    private get(key: string): GetResponse {\n        // Etcd client returns a CompletableFuture which is blocked here using .get()\n        const etcdCompletableFuture = this.native.get(StringToByteSequence(key));\n        const nativeResponse = etcdCompletableFuture.get();\n        return new GetResponse(nativeResponse);\n    }\n\n    /**\n     * Puts (writes) a string value to the specified key.\n     * @param key The key to write to.\n     * @param value The string value.\n     */\n    public putStringValue(key: string, value: string): void {\n        this.native.put(StringToByteSequence(key), StringToByteSequence(value));\n    }\n\n    /**\n     * Puts (writes) a byte array value to the specified key.\n     * @param key The key to write to.\n     * @param value The Int8Array (byte array) value.\n     */\n    public putByteArrayValue(key: string, value: Int8Array): void {\n        this.native.put(StringToByteSequence(key), ByteArrayToByteSequence(value));\n    }\n\n    /**\n     * Retrieves the response header metadata for a key.\n     * @param key The key to query.\n     * @returns The {@link Header} object.\n     */\n    public getHeader(key: string): Header {\n        return this.get(key).getHeader();\n    }\n\n    /**\n     * Retrieves the Key-Value pairs as a JavaScript object with string values.\n     * @param key The key (or key prefix) to query.\n     * @returns An object mapping keys to string values.\n     */\n    public getKvsStringValue(key: string): { [key: string]: string } {\n        return this.get(key).getKvsString();\n    }\n\n    /**\n     * Retrieves the Key-Value pairs as a JavaScript object with Int8Array values.\n     * @param key The key (or key prefix) to query.\n     * @returns An object mapping keys to Int8Array values.\n     */\n    public getKvsByteArrayValue(key: string): { [key: string]: Int8Array } {\n        return this.get(key).getKvsByteArray();\n    }\n\n    /**\n     * Retrieves the count of Key-Value pairs matching the key (or key prefix).\n     * @param key The key (or key prefix) to query.\n     * @returns The count of matching entries.\n     */\n    public getCount(key: string): number {\n        return this.get(key).getCount();\n    }\n\n    /**\n     * Deletes the specified key.\n     * @param key The key to delete.\n     */\n    public delete(key: string): void {\n        this.native.delete(StringToByteSequence(key));\n    }\n}\n\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Client;\n}"],
  "mappings": "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",
  "names": []
}


package/dist/esm/etcd/index.mjs

@@ -0,0 +1,6 @@
+export * from "./client";
+import { Client } from "./client";
+export {
+  Client as client
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2V0Y2QvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImV4cG9ydCAqIGZyb20gXCIuL2NsaWVudFwiO1xuZXhwb3J0IHsgQ2xpZW50IGFzIGNsaWVudCB9IGZyb20gXCIuL2NsaWVudFwiO1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsY0FBYztBQUNkLFNBQW1CLGNBQWM7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/esm/extensions/decorators.mjs

@@ -0,0 +1,21 @@
+const EXTENSION_METADATA_KEY = Symbol("extension:metadata");
+function Extension(options) {
+  return function(target, context) {
+    if (context.kind !== "class") {
+      throw new Error(`@Extension can only be used on classes.`);
+    }
+    Object.defineProperty(target, EXTENSION_METADATA_KEY, {
+      value: {
+        name: options.name,
+        to: options.to
+      },
+      writable: false,
+      configurable: false,
+      enumerable: true
+    });
+  };
+}
+export {
+  Extension
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2V4dGVuc2lvbnMvZGVjb3JhdG9ycy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiY29uc3QgRVhURU5TSU9OX01FVEFEQVRBX0tFWSA9IFN5bWJvbChcImV4dGVuc2lvbjptZXRhZGF0YVwiKTtcblxuZXhwb3J0IGludGVyZmFjZSBFeHRlbnNpb25PcHRpb25zIHtcbiAgICBuYW1lOiBzdHJpbmc7IC8vIGUuZy4sIFwiTXlFeHRlbnNpb25cIlxuICAgIHRvOiBzdHJpbmc7ICAgICAgLy8gZS5nLiwgXCJteS1leHRlbnNpb24tcG9pbnRcIlxufVxuXG4vKipcbiAqIEBFeHRlbnNpb24gZGVjb3JhdG9yXG4gKiBNYXJrcyBhbiBlbnRpcmUgY2xhc3MgYXMgYSBleHRlbnNpb25cbiAqXG4gKiBpbnRyb2R1Y2VkIGluIFR5cGVTY3JpcHQgNS4wLCB3aGljaCBleHBlY3RzIGEgQ2xhc3NEZWNvcmF0b3JDb250ZXh0IG9iamVjdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIEV4dGVuc2lvbihvcHRpb25zOiBFeHRlbnNpb25PcHRpb25zKSB7XG4gICAgXG4gICAgcmV0dXJuIGZ1bmN0aW9uIDxUIGV4dGVuZHMgYWJzdHJhY3QgbmV3ICguLi5hcmdzOiBhbnkpID0+IGFueT4odGFyZ2V0OiBULCBjb250ZXh0OiBDbGFzc0RlY29yYXRvckNvbnRleHQ8VD4pIHtcbiAgICAgICAgXG4gICAgICAgIGlmIChjb250ZXh0LmtpbmQgIT09ICdjbGFzcycpIHtcbiAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihgQEV4dGVuc2lvbiBjYW4gb25seSBiZSB1c2VkIG9uIGNsYXNzZXMuYCk7XG4gICAgICAgIH1cblxuICAgICAgICBPYmplY3QuZGVmaW5lUHJvcGVydHkodGFyZ2V0LCBFWFRFTlNJT05fTUVUQURBVEFfS0VZLCB7XG4gICAgICAgICAgICB2YWx1ZToge1xuICAgICAgICAgICAgICAgIG5hbWU6IG9wdGlvbnMubmFtZSxcbiAgICAgICAgICAgICAgICB0bzogb3B0aW9ucy50b1xuICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIHdyaXRhYmxlOiBmYWxzZSxcbiAgICAgICAgICAgIGNvbmZpZ3VyYWJsZTogZmFsc2UsXG4gICAgICAgICAgICBlbnVtZXJhYmxlOiB0cnVlXG4gICAgICAgIH0pO1xuICAgIH07XG59XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxNQUFNLHlCQUF5QixPQUFPLG9CQUFvQjtBQWFuRCxTQUFTLFVBQVUsU0FBMkI7QUFFakQsU0FBTyxTQUF3RCxRQUFXLFNBQW1DO0FBRXpHLFFBQUksUUFBUSxTQUFTLFNBQVM7QUFDMUIsWUFBTSxJQUFJLE1BQU0seUNBQXlDO0FBQUEsSUFDN0Q7QUFFQSxXQUFPLGVBQWUsUUFBUSx3QkFBd0I7QUFBQSxNQUNsRCxPQUFPO0FBQUEsUUFDSCxNQUFNLFFBQVE7QUFBQSxRQUNkLElBQUksUUFBUTtBQUFBLE1BQ2hCO0FBQUEsTUFDQSxVQUFVO0FBQUEsTUFDVixjQUFjO0FBQUEsTUFDZCxZQUFZO0FBQUEsSUFDaEIsQ0FBQztBQUFBLEVBQ0w7QUFDSjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/esm/extensions/extensions.mjs

@@ -0,0 +1,89 @@
+const ExtensionsFacade = Java.type("org.eclipse.dirigible.components.api.extensions.ExtensionsFacade");
+class Extensions {
+  /**
+   * Retrieves the list of extension module paths registered for a specific extension point.
+   *
+   * @param extensionPoint The unique identifier of the extension point (e.g., "my.extension.point").
+   * @returns An array of string paths (modules) registered for the given extension point.
+   */
+  static getExtensions(extensionPoint) {
+    const extensions = ExtensionsFacade.getExtensions(extensionPoint);
+    return JSON.parse(JSON.stringify(extensions));
+  }
+  /**
+   * Retrieves all available extension point identifiers.
+   *
+   * @returns An array of strings representing all registered extension point IDs.
+   */
+  static getExtensionPoints() {
+    const extensionPoints = ExtensionsFacade.getExtensionPoints();
+    return JSON.parse(JSON.stringify(extensionPoints));
+  }
+  /**
+   * Loads extension modules registered for a specific extension point.
+   * It handles both synchronous (require) and asynchronous (import) loading.
+   *
+   * @param extensionPoint The unique identifier of the extension point.
+   * @param requiredFunctions An optional list of function names that the extension module must export to be included.
+   * @param throwError If true, throws an error on failure; otherwise, logs the error and continues.
+   * @returns A Promise that resolves to an array of successfully loaded and validated extension modules (exports).
+   */
+  static async loadExtensionModules(extensionPoint, requiredFunctions = [], throwError = false) {
+    const extensionModules = [];
+    const extensions = this.getExtensions(extensionPoint);
+    for (let i = 0; i < extensions?.length; i++) {
+      const module2 = extensions[i];
+      try {
+        let extensionModule;
+        try {
+          extensionModule = dirigibleRequire(module2);
+        } catch (e) {
+          extensionModule = await import(`../../../../${module2}`);
+        }
+        if (!extensionModule || Object.keys(extensionModule).length === 0) {
+          const errorMessage = `Extension '${module2}' for extension point '${extensionPoint}' doesn't provide any function(s) or was not properly loaded, consider publishing it.`;
+          this.logError(throwError, errorMessage);
+          continue;
+        }
+        let requiredFunctionsFound = true;
+        requiredFunctions.forEach((f) => {
+          requiredFunctionsFound &&= typeof extensionModule[f] === "function";
+        });
+        if (!requiredFunctionsFound) {
+          const errorMessage = `Extension '${module2}' for extension point '${extensionPoint}', doesn't provide the following required function(s): [
+	${requiredFunctions.join("(),\n	")}()
+]`;
+          this.logError(throwError, errorMessage);
+          continue;
+        }
+        extensionModules.push(extensionModule);
+      } catch (e) {
+        const errorMessage = `Error occurred while importing extension '${module2}' for extension point '${extensionPoint}'.`;
+        this.logError(throwError, errorMessage, e);
+      }
+    }
+    return extensionModules;
+  }
+  /**
+   * Logs an error to the console and optionally throws an exception.
+   * @param throwError If true, an exception is thrown.
+   * @param errorData The data/message to log and/or use for the error message.
+   */
+  static logError(throwError, ...errorData) {
+    console.error(errorData);
+    if (throwError) {
+      throw new Error(errorData[0]);
+    }
+  }
+  /** Alias for loadExtensionModules */
+  static async load(extensionPoint, requiredFunctions = [], throwError = false) {
+    return Extensions.loadExtensionModules(extensionPoint, requiredFunctions, throwError);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Extensions;
+}
+export {
+  Extensions
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/extensions/extensions.ts"],
  "sourcesContent": ["/**\n * API Extensions\n *\n */\n\nconst ExtensionsFacade = Java.type(\"org.eclipse.dirigible.components.api.extensions.ExtensionsFacade\");\n\n/**\n * Provides functionality for discovering and loading extensions defined\n * against the Dirigible extension model.\n */\nexport class Extensions {\n\n\t/**\n\t * Retrieves the list of extension module paths registered for a specific extension point.\n\t *\n\t * @param extensionPoint The unique identifier of the extension point (e.g., \"my.extension.point\").\n\t * @returns An array of string paths (modules) registered for the given extension point.\n\t */\n\tpublic static getExtensions(extensionPoint: string): string[] {\n\t\tconst extensions = ExtensionsFacade.getExtensions(extensionPoint);\n\t\t// The native facade returns a Java List, which is converted to JSON string \n\t\t// and then parsed to a JavaScript array.\n\t\treturn JSON.parse(JSON.stringify(extensions));\n\t}\n\n\t/**\n\t * Retrieves all available extension point identifiers.\n\t *\n\t * @returns An array of strings representing all registered extension point IDs.\n\t */\n\tpublic static getExtensionPoints(): string[] {\n\t\tconst extensionPoints = ExtensionsFacade.getExtensionPoints();\n\t\treturn JSON.parse(JSON.stringify(extensionPoints));\n\t}\n\n\t/**\n\t * Loads extension modules registered for a specific extension point.\n\t * It handles both synchronous (require) and asynchronous (import) loading.\n\t *\n\t * @param extensionPoint The unique identifier of the extension point.\n\t * @param requiredFunctions An optional list of function names that the extension module must export to be included.\n\t * @param throwError If true, throws an error on failure; otherwise, logs the error and continues.\n\t * @returns A Promise that resolves to an array of successfully loaded and validated extension modules (exports).\n\t */\n\tpublic static async loadExtensionModules(extensionPoint: string, requiredFunctions: string[] = [], throwError: boolean = false): Promise<any[]> {\n\t\tconst extensionModules = [];\n\t\tconst extensions: string[] = this.getExtensions(extensionPoint);\n\n\t\tfor (let i = 0; i < extensions?.length; i++) {\n\t\t\tconst module: string = extensions[i];\n\t\t\ttry {\n\t\t\t\tlet extensionModule: any;\n\t\t\t\ttry {\n\t\t\t\t\t// Fallback to native require() (Dirigible-specific)\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\textensionModule = dirigibleRequire(module);\n\t\t\t\t} catch (e) {\n\t\t\t\t\t// Fallback to dynamic import (for environments supporting ESM/Async)\n\t\t\t\t\textensionModule = await import(`../../../../${module}`);\n\t\t\t\t}\n\n\t\t\t\tif (!extensionModule || Object.keys(extensionModule).length === 0) {\n\t\t\t\t\tconst errorMessage = `Extension '${module}' for extension point '${extensionPoint}' doesn't provide any function(s) or was not properly loaded, consider publishing it.`;\n\t\t\t\t\tthis.logError(throwError, errorMessage);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tlet requiredFunctionsFound = true;\n\t\t\t\trequiredFunctions.forEach(f => {\n\t\t\t\t\trequiredFunctionsFound &&= typeof extensionModule[f] === \"function\";\n\t\t\t\t});\n\n\t\t\t\tif (!requiredFunctionsFound) {\n\t\t\t\t\tconst errorMessage = `Extension '${module}' for extension point '${extensionPoint}', doesn't provide the following required function(s): [\\n\\t${requiredFunctions.join(\"(),\\n\\t\")}()\\n]`;\n\t\t\t\t\tthis.logError(throwError, errorMessage);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\textensionModules.push(extensionModule);\n\t\t\t} catch (e) {\n\t\t\t\tconst errorMessage = `Error occurred while importing extension '${module}' for extension point '${extensionPoint}'.`;\n\t\t\t\tthis.logError(throwError, errorMessage, e);\n\t\t\t}\n\t\t}\n\n\t\treturn extensionModules;\n\t}\n\n\t/**\n\t * Logs an error to the console and optionally throws an exception.\n\t * @param throwError If true, an exception is thrown.\n\t * @param errorData The data/message to log and/or use for the error message.\n\t */\n\tprivate static logError(throwError: boolean, ...errorData: any[]): void {\n\t\tconsole.error(errorData);\n\t\tif (throwError) {\n\t\t\tthrow new Error(errorData[0]);\n\t\t}\n\t}\n\t\n\t/** Alias for loadExtensionModules */\n\tpublic static async load(extensionPoint: string, requiredFunctions: string[] = [], throwError: boolean = false): Promise<any[]> {\n\t\treturn Extensions.loadExtensionModules(extensionPoint, requiredFunctions, throwError);\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Extensions;\n}"],
  "mappings": "AAKA,MAAM,mBAAmB,KAAK,KAAK,kEAAkE;AAM9F,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQvB,OAAc,cAAc,gBAAkC;AAC7D,UAAM,aAAa,iBAAiB,cAAc,cAAc;AAGhE,WAAO,KAAK,MAAM,KAAK,UAAU,UAAU,CAAC;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,qBAA+B;AAC5C,UAAM,kBAAkB,iBAAiB,mBAAmB;AAC5D,WAAO,KAAK,MAAM,KAAK,UAAU,eAAe,CAAC;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,aAAoB,qBAAqB,gBAAwB,oBAA8B,CAAC,GAAG,aAAsB,OAAuB;AAC/I,UAAM,mBAAmB,CAAC;AAC1B,UAAM,aAAuB,KAAK,cAAc,cAAc;AAE9D,aAAS,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AAC5C,YAAMA,UAAiB,WAAW,CAAC;AACnC,UAAI;AACH,YAAI;AACJ,YAAI;AAGH,4BAAkB,iBAAiBA,OAAM;AAAA,QAC1C,SAAS,GAAG;AAEX,4BAAkB,MAAM,OAAO,eAAeA,OAAM;AAAA,QACrD;AAEA,YAAI,CAAC,mBAAmB,OAAO,KAAK,eAAe,EAAE,WAAW,GAAG;AAClE,gBAAM,eAAe,cAAcA,OAAM,0BAA0B,cAAc;AACjF,eAAK,SAAS,YAAY,YAAY;AACtC;AAAA,QACD;AAEA,YAAI,yBAAyB;AAC7B,0BAAkB,QAAQ,OAAK;AAC9B,qCAA2B,OAAO,gBAAgB,CAAC,MAAM;AAAA,QAC1D,CAAC;AAED,YAAI,CAAC,wBAAwB;AAC5B,gBAAM,eAAe,cAAcA,OAAM,0BAA0B,cAAc;AAAA,GAA+D,kBAAkB,KAAK,QAAS,CAAC;AAAA;AACjL,eAAK,SAAS,YAAY,YAAY;AACtC;AAAA,QACD;AAEA,yBAAiB,KAAK,eAAe;AAAA,MACtC,SAAS,GAAG;AACX,cAAM,eAAe,6CAA6CA,OAAM,0BAA0B,cAAc;AAChH,aAAK,SAAS,YAAY,cAAc,CAAC;AAAA,MAC1C;AAAA,IACD;AAEA,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAe,SAAS,eAAwB,WAAwB;AACvE,YAAQ,MAAM,SAAS;AACvB,QAAI,YAAY;AACf,YAAM,IAAI,MAAM,UAAU,CAAC,CAAC;AAAA,IAC7B;AAAA,EACD;AAAA;AAAA,EAGA,aAAoB,KAAK,gBAAwB,oBAA8B,CAAC,GAAG,aAAsB,OAAuB;AAC/H,WAAO,WAAW,qBAAqB,gBAAgB,mBAAmB,UAAU;AAAA,EACrF;AACD;AAGA,IAAI,OAAO,WAAW,aAAa;AAElC,SAAO,UAAU;AAClB;",
  "names": ["module"]
}


package/dist/esm/extensions/index.mjs

@@ -0,0 +1,9 @@
+export * from "./extensions";
+import { Extensions } from "./extensions";
+import * as decorators from "./decorators";
+export * from "./decorators";
+export {
+  decorators,
+  Extensions as extensions
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2V4dGVuc2lvbnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImV4cG9ydCAqIGZyb20gXCIuL2V4dGVuc2lvbnNcIjtcbmV4cG9ydCB7IEV4dGVuc2lvbnMgYXMgZXh0ZW5zaW9ucyB9IGZyb20gXCIuL2V4dGVuc2lvbnNcIjtcbmV4cG9ydCAqIGFzIGRlY29yYXRvcnMgZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiOyJdLAogICJtYXBwaW5ncyI6ICJBQUFBLGNBQWM7QUFDZCxTQUF1QixrQkFBa0I7QUFDekMsWUFBWSxnQkFBZ0I7QUFDNUIsY0FBYzsiLAogICJuYW1lcyI6IFtdCn0K