@aerokit/sdk 12.44.0

package/dist/esm/junit/junit.mjs

@@ -0,0 +1,48 @@
+const Assert = Java.type("org.junit.Assert");
+function test(name, testFn) {
+  globalThis.test(name, testFn);
+}
+function assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined) {
+  if (arguments.length === 3) {
+    Assert.assertEquals(messageOrExpected, expectedOrActual, actualOrUndefined);
+  } else {
+    Assert.assertEquals(messageOrExpected, expectedOrActual);
+  }
+}
+function assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined) {
+  if (arguments.length === 3) {
+    Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual, actualOrUndefined);
+  } else {
+    Assert.assertNotEquals(messageOrUnexpected, unexpectedOrActual);
+  }
+}
+function assertTrue(messageOrCondition, conditionOrUndefined) {
+  if (arguments.length === 2) {
+    Assert.assertTrue(messageOrCondition, conditionOrUndefined);
+  } else {
+    Assert.assertTrue(messageOrCondition);
+  }
+}
+function assertFalse(messageOrCondition, conditionOrUndefined) {
+  if (arguments.length === 2) {
+    Assert.assertFalse(messageOrCondition, conditionOrUndefined);
+  } else {
+    Assert.assertFalse(messageOrCondition);
+  }
+}
+function fail(message) {
+  if (message) {
+    Assert.fail(message);
+  } else {
+    Assert.fail();
+  }
+}
+export {
+  assertEquals,
+  assertFalse,
+  assertNotEquals,
+  assertTrue,
+  fail,
+  test
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/kafka/consumer.mjs

@@ -0,0 +1,51 @@
+const KafkaFacade = Java.type("org.eclipse.dirigible.components.api.kafka.KafkaFacade");
+class Consumer {
+  /**
+   * Creates a new topic configuration wrapper that can be used to start or
+   * stop listening for messages on a Kafka topic.
+   *
+   * @param destination The name of the Kafka topic to consume messages from.
+   * @param configuration Optional key-value object containing Kafka consumer properties
+   * (e.g., 'group.id', 'auto.offset.reset').
+   * @returns A {@link Topic} instance configured for the specified destination and properties.
+   */
+  static topic(destination, configuration = {}) {
+    return new Topic(destination, configuration);
+  }
+}
+class Topic {
+  /**
+   * @param destination The name of the Kafka topic.
+   * @param configuration Optional key-value object for consumer properties.
+   */
+  constructor(destination, configuration = {}) {
+    this.configuration = {};
+    this.destination = destination;
+    this.configuration = configuration;
+  }
+  /**
+   * Starts listening to the configured topic in a background process.
+   *
+   * @param handler The path to the script or function name that will handle the incoming Kafka messages.
+   * This function should accept two arguments: `message` (string) and `headers` (object).
+   * @param timeout The maximum amount of time (in milliseconds) the consumer should wait for messages.
+   */
+  startListening(handler, timeout) {
+    KafkaFacade.startListening(this.destination, handler, timeout, JSON.stringify(this.configuration));
+  }
+  /**
+   * Stops the background process that is listening to the configured topic.
+   * Note: Stopping is based on matching the topic and configuration, so the same
+   * configuration object used in `startListening` should be used here.
+   */
+  stopListening() {
+    KafkaFacade.stopListening(this.destination, JSON.stringify(this.configuration));
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Consumer;
+}
+export {
+  Consumer
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/kafka/index.mjs

@@ -0,0 +1,9 @@
+import { Consumer } from "./consumer";
+export * from "./consumer";
+import { Producer } from "./producer";
+export * from "./producer";
+export {
+  Consumer as consumer,
+  Producer as producer
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2thZmthL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgeyBDb25zdW1lciBhcyBjb25zdW1lciB9IGZyb20gXCIuL2NvbnN1bWVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdW1lclwiO1xuZXhwb3J0IHsgUHJvZHVjZXIgYXMgcHJvZHVjZXIgfSBmcm9tIFwiLi9wcm9kdWNlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHJvZHVjZXJcIjsiXSwKICAibWFwcGluZ3MiOiAiQUFBQSxTQUFxQixnQkFBZ0I7QUFDckMsY0FBYztBQUNkLFNBQXFCLGdCQUFnQjtBQUNyQyxjQUFjOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/esm/kafka/producer.mjs

@@ -0,0 +1,51 @@
+const KafkaFacade = Java.type("org.eclipse.dirigible.components.api.kafka.KafkaFacade");
+class Producer {
+  /**
+   * Creates a new topic configuration wrapper that can be used to send messages
+   * to a specific Kafka topic.
+   *
+   * @param destination The name of the Kafka topic to send messages to.
+   * @param configuration Optional key-value object containing Kafka producer properties
+   * (e.g., 'bootstrap.servers', 'acks').
+   * @returns A {@link Topic} instance configured for the specified destination and properties.
+   */
+  static topic(destination, configuration = {}) {
+    return new Topic(destination, configuration);
+  }
+  /**
+   * Closes the Kafka producer connection pool, releasing associated resources.
+   * This should be called when message sending is complete to ensure proper cleanup.
+   *
+   * @param configuration Optional key-value object containing the configuration
+   * used to initialize the producer to be closed.
+   */
+  static close(configuration = {}) {
+    KafkaFacade.closeProducer(configuration);
+  }
+}
+class Topic {
+  /**
+   * @param destination The name of the Kafka topic.
+   * @param configuration Key-value object for producer properties.
+   */
+  constructor(destination, configuration) {
+    this.destination = destination;
+    this.configuration = configuration;
+  }
+  /**
+   * Sends a message with an optional key to the configured Kafka topic.
+   *
+   * @param key The key of the message. Messages with the same key go to the same partition.
+   * @param value The content of the message to be sent.
+   */
+  send(key, value) {
+    KafkaFacade.send(this.destination, key, value, JSON.stringify(this.configuration));
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Producer;
+}
+export {
+  Producer
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/log/index.mjs

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

package/dist/esm/log/logging.mjs

@@ -0,0 +1,155 @@
+const LogFacade = Java.type("org.eclipse.dirigible.components.api.log.LogFacade");
+class Logging {
+  /**
+   * Retrieves or creates a Logger instance associated with a specific name.
+   * The logger name is typically used to categorize log messages (e.g., 'com.app.service').
+   *
+   * @param loggerName The name of the logger.
+   * @returns A {@link Logger} instance.
+   */
+  static getLogger(loggerName) {
+    return new Logger(loggerName);
+  }
+}
+class Logger {
+  /**
+   * @param loggerName The name of the logger.
+   */
+  constructor(loggerName) {
+    this.loggerName = loggerName;
+  }
+  /**
+   * Sets the logging level for this specific logger instance.
+   * Messages below this threshold will be ignored.
+   *
+   * @param level The desired logging level (e.g., 'TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR').
+   * @returns The Logger instance for method chaining.
+   */
+  setLevel(level) {
+    LogFacade.setLevel(this.loggerName, level);
+    return this;
+  }
+  /**
+   * Checks if the DEBUG level is currently enabled for this logger.
+   * @returns True if DEBUG logging is enabled, false otherwise.
+   */
+  isDebugEnabled() {
+    return LogFacade.isDebugEnabled(this.loggerName);
+  }
+  /**
+   * Checks if the ERROR level is currently enabled for this logger.
+   * @returns True if ERROR logging is enabled, false otherwise.
+   */
+  isErrorEnabled() {
+    return LogFacade.isErrorEnabled(this.loggerName);
+  }
+  /**
+   * Checks if the WARN level is currently enabled for this logger.
+   * @returns True if WARN logging is enabled, false otherwise.
+   */
+  isWarnEnabled() {
+    return LogFacade.isWarnEnabled(this.loggerName);
+  }
+  /**
+   * Checks if the INFO level is currently enabled for this logger.
+   * @returns True if INFO logging is enabled, false otherwise.
+   */
+  isInfoEnabled() {
+    return LogFacade.isInfoEnabled(this.loggerName);
+  }
+  /**
+   * Checks if the TRACE level is currently enabled for this logger.
+   * @returns True if TRACE logging is enabled, false otherwise.
+   */
+  isTraceEnabled() {
+    return LogFacade.isTraceEnabled(this.loggerName);
+  }
+  /**
+   * The core logging method. Logs a message at the specified level, optionally
+   * supporting parameters for message formatting and a final Error object for stack trace logging.
+   *
+   * @param msg The log message template (e.g., "User {0} failed to connect: {1}").
+   * @param level The logging level (e.g., 'DEBUG', 'ERROR').
+   * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+   */
+  log(msg, level) {
+    const args = Array.prototype.slice.call(arguments);
+    let msgParameters = [];
+    let rawError = null;
+    if (args.length > 2) {
+      if (args[args.length - 1] instanceof Error) {
+        rawError = args[args.length - 1];
+        if (rawError.stack) {
+          console.debug("Handling error with stack:\n" + rawError.stack);
+        }
+      }
+      const endIndex = rawError ? args.length - 1 : args.length;
+      msgParameters = args.slice(2, endIndex).map(function(param) {
+        return typeof param === "object" ? JSON.stringify(param) : param;
+      });
+    }
+    LogFacade.log(this.loggerName, level, msg, JSON.stringify(msgParameters), rawError);
+  }
+  /**
+   * Logs a message at the DEBUG level.
+   *
+   * @param msg The log message template.
+   * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+   */
+  debug(msg, ..._) {
+    const args = Array.prototype.slice.call(arguments);
+    args.splice(1, 0, "DEBUG");
+    this.log.apply(this, args);
+  }
+  /**
+   * Logs a message at the INFO level.
+   *
+   * @param msg The log message template.
+   * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+   */
+  info(msg, ..._) {
+    const args = Array.prototype.slice.call(arguments);
+    args.splice(1, 0, "INFO");
+    this.log.apply(this, args);
+  }
+  /**
+   * Logs a message at the TRACE level.
+   *
+   * @param msg The log message template.
+   * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+   */
+  trace(msg, ..._) {
+    const args = Array.prototype.slice.call(arguments);
+    args.splice(1, 0, "TRACE");
+    this.log.apply(this, args);
+  }
+  /**
+   * Logs a message at the WARN level.
+   *
+   * @param msg The log message template.
+   * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+   */
+  warn(msg, ..._) {
+    const args = Array.prototype.slice.call(arguments);
+    args.splice(1, 0, "WARN");
+    this.log.apply(this, args);
+  }
+  /**
+   * Logs a message at the ERROR level.
+   *
+   * @param msg The log message template.
+   * @param [args] Optional arguments for message formatting. The last argument can be an Error object.
+   */
+  error(msg, ..._) {
+    const args = Array.prototype.slice.call(arguments);
+    args.splice(1, 0, "ERROR");
+    this.log.apply(this, args);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Logging;
+}
+export {
+  Logging
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/log/logging.ts"],
  "sourcesContent": ["/**\n * Provides a wrapper for the underlying logging facility, allowing\n * for categorized and leveled logging messages with support for variable arguments,\n * including error objects.\n */\nconst LogFacade = Java.type(\"org.eclipse.dirigible.components.api.log.LogFacade\");\n\n\n/**\n * The main entry point for the logging API. Use this class to obtain a named\n * logger instance.\n */\nexport class Logging {\n\n\t/**\n\t * Retrieves or creates a Logger instance associated with a specific name.\n\t * The logger name is typically used to categorize log messages (e.g., 'com.app.service').\n\t *\n\t * @param loggerName The name of the logger.\n\t * @returns A {@link Logger} instance.\n\t */\n\tpublic static getLogger(loggerName: string): Logger {\n\t\treturn new Logger(loggerName);\n\t}\n}\n\n/**\n * Represents a named logger instance used for emitting log messages at various levels.\n */\nclass Logger {\n\n\tprivate loggerName: string;\n\n\t/**\n\t * @param loggerName The name of the logger.\n\t */\n\tconstructor(loggerName: string) {\n\t\tthis.loggerName = loggerName;\n\t}\n\n\t/**\n\t * Sets the logging level for this specific logger instance.\n\t * Messages below this threshold will be ignored.\n\t *\n\t * @param level The desired logging level (e.g., 'TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR').\n\t * @returns The Logger instance for method chaining.\n\t */\n\tpublic setLevel(level: string): Logger {\n\t\tLogFacade.setLevel(this.loggerName, level);\n\t\treturn this;\n\t}\n\n    /**\n     * Checks if the DEBUG level is currently enabled for this logger.\n     * @returns True if DEBUG logging is enabled, false otherwise.\n     */\n    public isDebugEnabled(): boolean {\n        return LogFacade.isDebugEnabled(this.loggerName);\n    }\n\n    /**\n     * Checks if the ERROR level is currently enabled for this logger.\n     * @returns True if ERROR logging is enabled, false otherwise.\n     */\n    public isErrorEnabled(): boolean {\n        return LogFacade.isErrorEnabled(this.loggerName);\n    }\n\n    /**\n     * Checks if the WARN level is currently enabled for this logger.\n     * @returns True if WARN logging is enabled, false otherwise.\n     */\n    public isWarnEnabled(): boolean {\n        return LogFacade.isWarnEnabled(this.loggerName);\n    }\n\n    /**\n     * Checks if the INFO level is currently enabled for this logger.\n     * @returns True if INFO logging is enabled, false otherwise.\n     */\n    public isInfoEnabled(): boolean {\n        return LogFacade.isInfoEnabled(this.loggerName);\n    }\n\n    /**\n     * Checks if the TRACE level is currently enabled for this logger.\n     * @returns True if TRACE logging is enabled, false otherwise.\n     */\n    public isTraceEnabled(): boolean {\n        return LogFacade.isTraceEnabled(this.loggerName);\n    }\n\n\t/**\n\t * The core logging method. Logs a message at the specified level, optionally\n\t * supporting parameters for message formatting and a final Error object for stack trace logging.\n\t *\n\t * @param msg The log message template (e.g., \"User {0} failed to connect: {1}\").\n\t * @param level The logging level (e.g., 'DEBUG', 'ERROR').\n\t * @param [args] Optional arguments for message formatting. The last argument can be an Error object.\n\t */\n\tpublic log(msg: string, level: string): void {\n\t\tconst args = Array.prototype.slice.call(arguments);\n\t\tlet msgParameters = [];\n\n\t\tlet rawError = null;\n\t\tif (args.length > 2) {\n\t\t\tif (args[args.length-1] instanceof Error) {\n                rawError = args[args.length-1];\n\n                if (rawError.stack) {\n                    console.debug(\"Handling error with stack:\\n\" + rawError.stack);\n                }\n\t\t\t}\n\t\t\tconst endIndex = rawError ? (args.length - 1) : args.length;\n\t\t\tmsgParameters = args.slice(2, endIndex).map(function (param) {\n\t\t\t\treturn typeof param === 'object' ? JSON.stringify(param) : param;\n\t\t\t});\n\t\t}\n\n\t\tLogFacade.log(this.loggerName, level, msg, JSON.stringify(msgParameters), rawError);\n\t}\n\n\t/**\n\t * Logs a message at the DEBUG level.\n\t *\n\t * @param msg The log message template.\n\t * @param [args] Optional arguments for message formatting. The last argument can be an Error object.\n\t */\n\tpublic debug(msg: string, ..._: any[]): void {\n\t\tconst args = Array.prototype.slice.call(arguments);\n\t\targs.splice(1, 0, 'DEBUG');//insert DEBUG on second position in arguments array\n\t\tthis.log.apply(this, args);\n\t}\n\n\t/**\n\t * Logs a message at the INFO level.\n\t *\n\t * @param msg The log message template.\n\t * @param [args] Optional arguments for message formatting. The last argument can be an Error object.\n\t */\n\tpublic info(msg: string, ..._: any[]): void {\n\t\tconst args = Array.prototype.slice.call(arguments);\n\t\targs.splice(1, 0, 'INFO');//insert INFO on second position in arguments array\n\t\tthis.log.apply(this, args);\n\t}\n\n\t/**\n\t * Logs a message at the TRACE level.\n\t *\n\t * @param msg The log message template.\n\t * @param [args] Optional arguments for message formatting. The last argument can be an Error object.\n\t */\n\tpublic trace(msg: string, ..._: any[]): void {\n\t\tconst args = Array.prototype.slice.call(arguments);\n\t\targs.splice(1, 0, 'TRACE');//insert TRACE on second position in arguments array\n\t\tthis.log.apply(this, args);\n\t}\n\n\t/**\n\t * Logs a message at the WARN level.\n\t *\n\t * @param msg The log message template.\n\t * @param [args] Optional arguments for message formatting. The last argument can be an Error object.\n\t */\n\tpublic warn(msg: string, ..._: any[]): void {\n\t\tconst args = Array.prototype.slice.call(arguments);\n\t\targs.splice(1, 0, 'WARN');//insert WARN on second position in arguments array\n\t\tthis.log.apply(this, args);\n\t}\n\n\t/**\n\t * Logs a message at the ERROR level.\n\t *\n\t * @param msg The log message template.\n\t * @param [args] Optional arguments for message formatting. The last argument can be an Error object.\n\t */\n\tpublic error(msg: string, ..._: any[]): void {\n\t\tconst args = Array.prototype.slice.call(arguments);\n\t\targs.splice(1, 0, 'ERROR');//insert ERROR on second position in arguments array\n\t\tthis.log.apply(this, args);\n\t}\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Logging;\n}"],
  "mappings": "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",
  "names": []
}


package/dist/esm/mail/client.mjs

@@ -0,0 +1,134 @@
+const Properties = Java.type("java.util.Properties");
+const MailFacade = Java.type("org.eclipse.dirigible.components.api.mail.MailFacade");
+class MailClient {
+  /**
+   * A static convenience method to send a multipart email without instantiating a client.
+   * This is suitable for emails that require attachments, inline images, or mixed content.
+   *
+   * @param from The sender's email address.
+   * @param recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).
+   * @param subject The subject line of the email.
+   * @param parts An array of {@link MailMultipart} objects defining the email content.
+   */
+  static sendMultipart(from, recipients, subject, parts) {
+    const mailClient = new MailClient();
+    mailClient.sendMultipart(from, recipients, subject, parts);
+  }
+  /**
+   * A static convenience method to send a simple email with only a single text or HTML body.
+   *
+   * @param from The sender's email address.
+   * @param recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).
+   * @param subject The subject line of the email.
+   * @param text The body content of the email.
+   * @param contentType Specifies the body format: 'html' or 'plain'.
+   */
+  static send(from, recipients, subject, text, contentType) {
+    const mailClient = new MailClient();
+    mailClient.send(from, recipients, subject, text, contentType);
+  }
+  /**
+   * Creates a new instance of the MailClient, optionally configuring the underlying
+   * native mail facade.
+   *
+   * @param options Optional key-value object containing configuration properties for the mail client (e.g., SMTP settings).
+   */
+  constructor(options) {
+    this.native = options ? MailFacade.getInstance(toJavaProperties(options)) : MailFacade.getInstance();
+  }
+  /**
+   * Sends a simple email with a single body part (text or HTML).
+   *
+   * @param from The sender's email address.
+   * @param _recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).
+   * @param subject The subject line of the email.
+   * @param text The body content of the email.
+   * @param contentType Specifies the body format: 'html' or 'plain'.
+   * @throws {Error} Throws an error if the recipient format is invalid or the native call fails.
+   */
+  send(from, _recipients, subject, text, contentType) {
+    const recipients = processRecipients(_recipients);
+    const part = {
+      contentType: contentType === "html" ? "text/html" : "text/plain",
+      text,
+      type: "text"
+    };
+    try {
+      this.native.send(from, recipients.to, recipients.cc, recipients.bcc, subject, [part]);
+    } catch (error) {
+      console.error(error.message);
+      throw new Error(error);
+    }
+  }
+  /**
+   * Sends a complex email composed of multiple parts (text bodies, HTML, attachments, inline content).
+   *
+   * @param from The sender's email address.
+   * @param _recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).
+   * @param subject The subject line of the email.
+   * @param parts An array of {@link MailMultipart} objects defining the email content.
+   * @throws {Error} Throws an error if the recipient format is invalid or the native call fails.
+   */
+  sendMultipart(from, _recipients, subject, parts) {
+    let recipients = processRecipients(_recipients);
+    try {
+      return this.native.send(from, recipients.to, recipients.cc, recipients.bcc, subject, stringifyPartData(parts));
+    } catch (error) {
+      console.error(error.message);
+      throw new Error(error);
+    }
+  }
+}
+function stringifyPartData(parts) {
+  parts.forEach(function(part) {
+    if (part.data) {
+      part.data = JSON.stringify(part.data);
+    }
+    return part;
+  });
+  return parts;
+}
+function processRecipients(recipients) {
+  let to = [];
+  let cc = [];
+  let bcc = [];
+  if (typeof recipients === "string") {
+    to.push(recipients);
+  } else if (typeof recipients === "object") {
+    to = parseRecipients(recipients, "to");
+    cc = parseRecipients(recipients, "cc");
+    bcc = parseRecipients(recipients, "bcc");
+  } else {
+    const errorMessage = "Invalid 'recipients' format: " + JSON.stringify(recipients);
+    console.error(errorMessage);
+    throw new Error(errorMessage);
+  }
+  return { to, cc, bcc };
+}
+function toJavaProperties(properties) {
+  const javaProperties = new Properties();
+  Object.keys(properties).forEach(function(e) {
+    javaProperties.put(e, properties[e]);
+  });
+  return javaProperties;
+}
+function parseRecipients(recipients, type) {
+  const objectType = typeof recipients[type];
+  if (objectType === "string") {
+    return [recipients[type]];
+  } else if (Array.isArray(recipients[type])) {
+    return recipients[type];
+  } else if (objectType === "undefined") {
+    return [];
+  }
+  const errorMessage = `Invalid 'recipients.${type}' format: [${recipients[type]}|${objectType}]`;
+  console.error(errorMessage);
+  throw new Error(errorMessage);
+}
+if (typeof module !== "undefined") {
+  module.exports = MailClient;
+}
+export {
+  MailClient
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/mail/client.ts"],
  "sourcesContent": ["/**\n * Provides a client for sending emails, supporting both simple text/HTML\n * messages and complex multipart messages with attachments or inline content.\n */\nconst Properties = Java.type(\"java.util.Properties\");\nconst MailFacade = Java.type(\"org.eclipse.dirigible.components.api.mail.MailFacade\");\n\n/**\n * Defines the structure for specifying email recipients.\n * Recipients can be provided as a single email string or an array of strings.\n */\nexport interface MailRecipients {\n    /** The primary recipients of the email. */\n    to?: string | string[];\n    /** Carbon Copy recipients. */\n    cc?: string | string[];\n    /** Blind Carbon Copy recipients. */\n    bcc?: string | string[];\n}\n\n/**\n * Defines a single part of a multipart email message.\n * This is used for bodies, attachments, and inline images.\n */\nexport interface MailMultipart {\n    /** The nature of the part: 'text' (body), 'inline' (e.g., image displayed in HTML), or 'attachment'. */\n    type: \"text\" | \"inline\" | \"attachment\";\n    /** The MIME content type of the part (e.g., 'text/plain', 'text/html', 'image/png'). */\n    contentType: string;\n    /** The text content for 'text' parts. */\n    text?: string;\n    /** Required for 'inline' parts; used in the HTML body to reference the content (e.g., `<img src=\"cid:...\">`). */\n    contentId?: string;\n    /** The name of the file for 'attachment' and 'inline' parts. */\n    fileName?: string;\n    /** The base64-encoded data content for 'attachment' and 'inline' parts. */\n    data?: string;\n}\n\n/**\n * Defines the content type for simple emails sent via {@link MailClient.send}.\n */\ntype MailContentType = \"html\" | \"plain\";\n\n/**\n * The MailClient provides methods for sending emails, handling recipient processing\n * and interfacing with the underlying MailFacade.\n */\nexport class MailClient {\n    private readonly native: any;\n\n    /**\n     * A static convenience method to send a multipart email without instantiating a client.\n     * This is suitable for emails that require attachments, inline images, or mixed content.\n     *\n     * @param from The sender's email address.\n     * @param recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).\n     * @param subject The subject line of the email.\n     * @param parts An array of {@link MailMultipart} objects defining the email content.\n     */\n    public static sendMultipart(from: string, recipients: string | MailRecipients, subject: string, parts: MailMultipart[]): void {\n        const mailClient = new MailClient();\n        mailClient.sendMultipart(from, recipients, subject, parts);\n    }\n\n    /**\n     * A static convenience method to send a simple email with only a single text or HTML body.\n     *\n     * @param from The sender's email address.\n     * @param recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).\n     * @param subject The subject line of the email.\n     * @param text The body content of the email.\n     * @param contentType Specifies the body format: 'html' or 'plain'.\n     */\n    public static send(from: string, recipients: string | MailRecipients, subject: string, text: string, contentType: MailContentType): void {\n        const mailClient = new MailClient();\n        mailClient.send(from, recipients, subject, text, contentType);\n    }\n\n    /**\n     * Creates a new instance of the MailClient, optionally configuring the underlying\n     * native mail facade.\n     *\n     * @param options Optional key-value object containing configuration properties for the mail client (e.g., SMTP settings).\n     */\n    constructor(options?: object) {\n        this.native = options ? MailFacade.getInstance(toJavaProperties(options)) : MailFacade.getInstance();\n    }\n\n    /**\n     * Sends a simple email with a single body part (text or HTML).\n     *\n     * @param from The sender's email address.\n     * @param _recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).\n     * @param subject The subject line of the email.\n     * @param text The body content of the email.\n     * @param contentType Specifies the body format: 'html' or 'plain'.\n     * @throws {Error} Throws an error if the recipient format is invalid or the native call fails.\n     */\n    public send(from: string, _recipients: string | MailRecipients, subject: string, text: string, contentType: MailContentType): void {\n        const recipients = processRecipients(_recipients);\n\n        const part = {\n            contentType: contentType === \"html\" ? \"text/html\" : \"text/plain\",\n            text: text,\n            type: 'text'\n        };\n\n        try {\n            this.native.send(from, recipients.to, recipients.cc, recipients.bcc, subject, [part]);\n        } catch (error) {\n            console.error(error.message);\n            throw new Error(error as string);\n        }\n    }\n\n    /**\n     * Sends a complex email composed of multiple parts (text bodies, HTML, attachments, inline content).\n     *\n     * @param from The sender's email address.\n     * @param _recipients The recipient(s) structure (string for 'to', or {@link MailRecipients} object).\n     * @param subject The subject line of the email.\n     * @param parts An array of {@link MailMultipart} objects defining the email content.\n     * @throws {Error} Throws an error if the recipient format is invalid or the native call fails.\n     */\n    public sendMultipart(from: string, _recipients: string | MailRecipients, subject: string, parts: MailMultipart[]): void {\n        let recipients = processRecipients(_recipients);\n        try {\n            // Note: The native facade expects base64 data to be JSON-stringified if present.\n            return this.native.send(from, recipients.to, recipients.cc, recipients.bcc, subject, stringifyPartData(parts));\n        } catch (error) {\n            console.error(error.message);\n            throw new Error(error as string);\n        }\n    }\n}\n\n/**\n * Prepares the multipart array for the native facade call by JSON-stringifying\n * the 'data' field of any part that has it (required for base64 data transport).\n *\n * @param parts The array of MailMultipart objects.\n * @returns The modified parts array ready for the native call.\n */\nfunction stringifyPartData(parts: MailMultipart[]): MailMultipart[] {\n    parts.forEach(function (part: any) {\n        if (part.data) {\n            part.data = JSON.stringify(part.data);\n        }\n        return part;\n    })\n    return parts;\n}\n\n/**\n * Processes the recipients input (either a single string or a {@link MailRecipients} object)\n * into separate 'to', 'cc', and 'bcc' arrays of strings.\n *\n * @param recipients The raw recipient data.\n * @returns An object containing `to`, `cc`, and `bcc` arrays.\n * @throws {Error} Throws an error if the input format is invalid.\n */\nfunction processRecipients(recipients: string | MailRecipients) {\n    let to = [];\n    let cc = [];\n    let bcc = [];\n    if (typeof recipients === \"string\") {\n        to.push(recipients);\n    } else if (typeof recipients === \"object\") {\n        to = parseRecipients(recipients, \"to\");\n        cc = parseRecipients(recipients, \"cc\");\n        bcc = parseRecipients(recipients, \"bcc\");\n    } else {\n        const errorMessage = \"Invalid 'recipients' format: \" + JSON.stringify(recipients);\n        console.error(errorMessage);\n        throw new Error(errorMessage);\n    }\n\n    return { to: to, cc: cc, bcc: bcc };\n}\n\n/**\n * Converts a JavaScript object of properties into a Java Properties object.\n *\n * @param properties The JavaScript object containing key-value configuration pairs.\n * @returns A Java Properties instance.\n */\nfunction toJavaProperties(properties: any) {\n    const javaProperties = new Properties();\n    Object.keys(properties).forEach(function (e) {\n        javaProperties.put(e, properties[e]);\n    });\n    return javaProperties;\n}\n\n/**\n * Helper function to safely extract and validate recipients from a specific field ('to', 'cc', 'bcc').\n *\n * @param recipients The MailRecipients object.\n * @param type The field name to parse ('to', 'cc', or 'bcc').\n * @returns An array of recipient email strings.\n * @throws {Error} Throws an error if the field value is not a string, array, or undefined.\n */\nfunction parseRecipients(recipients: MailRecipients, type: keyof MailRecipients): string[] {\n    const objectType = typeof recipients[type];\n    if (objectType === \"string\") {\n        return [recipients[type] as string];\n    } else if (Array.isArray(recipients[type])) {\n        return recipients[type] as string[];\n    } else if (objectType === \"undefined\") {\n        return [];\n    }\n    const errorMessage = `Invalid 'recipients.${type}' format: [${recipients[type]}|${objectType}]`;\n    console.error(errorMessage);\n    throw new Error(errorMessage);\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = MailClient;\n}"],
  "mappings": "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",
  "names": []
}


package/dist/esm/mail/index.mjs

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

package/dist/esm/messaging/consumer.mjs

@@ -0,0 +1,64 @@
+const MessagingFacade = Java.type("org.eclipse.dirigible.components.api.messaging.MessagingFacade");
+class Consumer {
+  /**
+   * Creates a Queue consumer instance for point-to-point messaging.
+   * Messages sent to this destination are consumed by only one receiver.
+   *
+   * @param destination The name of the queue destination (e.g., 'orders.queue').
+   * @returns A {@link Queue} instance.
+   */
+  static queue(destination) {
+    return new Queue(destination);
+  }
+  /**
+   * Creates a Topic consumer instance for publish/subscribe messaging.
+   * Messages sent to this destination can be consumed by multiple subscribers.
+   *
+   * @param destination The name of the topic destination (e.g., 'market.updates.topic').
+   * @returns A {@link Topic} instance.
+   */
+  static topic(destination) {
+    return new Topic(destination);
+  }
+}
+class Queue {
+  /**
+   * @param destination The name of the queue destination.
+   */
+  constructor(destination) {
+    this.destination = destination;
+  }
+  /**
+   * Attempts to synchronously receive a message from the queue.
+   *
+   * @param timeout The maximum time (in milliseconds) to wait for a message. Defaults to 1000ms.
+   * @returns The received message content (usually a string or object), or null if the timeout is reached.
+   */
+  receive(timeout = 1e3) {
+    return MessagingFacade.receiveFromQueue(this.destination, timeout);
+  }
+}
+class Topic {
+  /**
+   * @param destination The name of the topic destination.
+   */
+  constructor(destination) {
+    this.destination = destination;
+  }
+  /**
+   * Attempts to synchronously receive a message from the topic.
+   *
+   * @param timeout The maximum time (in milliseconds) to wait for a message. Defaults to 1000ms.
+   * @returns The received message content (usually a string or object), or null if the timeout is reached.
+   */
+  receive(timeout = 1e3) {
+    return MessagingFacade.receiveFromTopic(this.destination, timeout);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Consumer;
+}
+export {
+  Consumer
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/messaging/decorators.mjs

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