@aerokit/sdk 12.44.0

package/dist/cjs/job/scheduler.js

@@ -0,0 +1,347 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var scheduler_exports = {};
+__export(scheduler_exports, {
+  Scheduler: () => Scheduler
+});
+module.exports = __toCommonJS(scheduler_exports);
+var import_core = require("@aerokit/sdk/core");
+const JobFacade = Java.type("org.eclipse.dirigible.components.api.job.JobFacade");
+class Scheduler {
+  /**
+   * Retrieves all job definitions currently configured in the system.
+   *
+   * @returns An array of {@link Job} objects.
+   */
+  static getJobs() {
+    const jobs = new Array();
+    const jobDefinitions = JSON.parse(JobFacade.getJobs());
+    for (const definition of jobDefinitions) {
+      jobs.push(new Job(definition));
+    }
+    return jobs;
+  }
+  /**
+   * Retrieves a specific job definition by its unique name.
+   *
+   * @param name The name of the job.
+   * @returns A {@link Job} object corresponding to the provided name.
+   */
+  static getJob(name) {
+    const jobDefinition = JSON.parse(JobFacade.getJob(name));
+    return new Job(jobDefinition);
+  }
+  /**
+   * Enables a job, allowing it to be executed according to its schedule (cron expression).
+   *
+   * @param name The name of the job to enable.
+   */
+  static enable(name) {
+    JobFacade.enable(name);
+  }
+  /**
+   * Disables a job, preventing it from executing on its schedule.
+   *
+   * @param name The name of the job to disable.
+   */
+  static disable(name) {
+    JobFacade.disable(name);
+  }
+  /**
+   * Triggers the immediate execution of a job.
+   *
+   * @param name The name of the job to trigger.
+   * @param parameters Optional key-value object of parameters to pass to the job execution.
+   */
+  static trigger(name, parameters = {}) {
+    JobFacade.trigger(name, JSON.stringify(parameters));
+  }
+  /**
+   * Logs a message at the standard log level for a specific job instance.
+   * This is useful when the log context needs to be associated with a running job.
+   *
+   * @param name The name of the job to associate the log with.
+   * @param message The log message content.
+   */
+  static log(name, message) {
+    JobFacade.log(name, message);
+  }
+  /**
+   * Logs an error message for a specific job instance.
+   *
+   * @param name The name of the job.
+   * @param message The error message content.
+   */
+  static error(name, message) {
+    JobFacade.error(name, message);
+  }
+  /**
+   * Logs a warning message for a specific job instance.
+   *
+   * @param name The name of the job.
+   * @param message The warning message content.
+   */
+  static warn(name, message) {
+    JobFacade.warn(name, message);
+  }
+  /**
+   * Logs an informational message for a specific job instance.
+   *
+   * @param name The name of the job.
+   * @param message The information message content.
+   */
+  static info(name, message) {
+    JobFacade.info(name, message);
+  }
+}
+class Job {
+  /**
+   * @param data The raw data object containing job properties.
+   */
+  constructor(data) {
+    this.data = data;
+  }
+  /**
+   * Gets the unique name of the job.
+   * @returns The job name.
+   */
+  getName() {
+    return this.data.name;
+  }
+  /**
+   * Gets the logical grouping for the job.
+   * @returns The job group name.
+   */
+  getGroup() {
+    return this.data.group;
+  }
+  /**
+   * Gets the Java class name (for Java-based jobs) or script file name (for script-based jobs).
+   * @returns The job implementation class/file name.
+   */
+  getClazz() {
+    return this.data.clazz;
+  }
+  /**
+   * Gets the description of the job's purpose.
+   * @returns The job description.
+   */
+  getDescription() {
+    return this.data.description;
+  }
+  /**
+   * Gets the cron expression defining the job's schedule.
+   * @returns The cron expression string.
+   */
+  getExpression() {
+    return this.data.expression;
+  }
+  /**
+   * Gets the handler file path or resource name for script-based jobs.
+   * @returns The handler path.
+   */
+  getHandler() {
+    return this.data.handler;
+  }
+  /**
+   * Gets the execution engine type (e.g., 'JavaScript', 'Java').
+   * @returns The engine type.
+   */
+  getEngine() {
+    return this.data.engine;
+  }
+  /**
+   * Checks if the job is configured as a singleton (only one instance runs at a time).
+   * @returns True if the job is a singleton.
+   */
+  getSingleton() {
+    return this.data.singleton;
+  }
+  /**
+   * Checks if the job is currently enabled for scheduled execution.
+   * @returns True if the job is enabled.
+   */
+  getEnabled() {
+    return this.data.enabled;
+  }
+  /**
+   * Gets the user ID who created the job definition.
+   * @returns The creator's user ID.
+   */
+  getCreatedBy() {
+    return this.data.createdBy;
+  }
+  /**
+   * Gets the timestamp when the job definition was created.
+   * @returns The creation time as a numerical timestamp.
+   */
+  getCreatedAt() {
+    return this.data.createdAt;
+  }
+  /**
+   * Gets the parameters associated with this job definition.
+   * @returns A {@link JobParameters} object containing all parameters.
+   */
+  getParameters() {
+    return new JobParameters(this.data.parameters);
+  }
+  /**
+   * Retrieves the value for a specific parameter of this job.
+   * It checks for an overriding value in the global configurations first,
+   * and falls back to the defined default value if the configuration is not set.
+   *
+   * @param name The name of the parameter to retrieve.
+   * @returns The parameter's configured or default value, or null if not found.
+   */
+  getParameter(name) {
+    if (this.data) {
+      for (let i in this.data.parameters) {
+        if (this.data.parameters[i].name === name) {
+          let value = import_core.configurations.get(name);
+          return value && value !== null ? value : this.data.parameters[i].defaultValue;
+        }
+      }
+    } else {
+      console.error("Job is not valid");
+    }
+    return null;
+  }
+  /**
+   * Enables this specific job instance.
+   */
+  enable() {
+    JobFacade.enable(this.getName());
+  }
+  /**
+   * Disables this specific job instance.
+   */
+  disable() {
+    JobFacade.disable(this.getName());
+  }
+  /**
+   * Triggers the immediate execution of this job instance.
+   *
+   * @param parameters Optional key-value object of parameters to pass to the job execution.
+   */
+  trigger(parameters = {}) {
+    JobFacade.trigger(this.getName(), JSON.stringify(parameters));
+  }
+  /**
+   * Logs a message at the standard log level for this job instance.
+   *
+   * @param message The log message content.
+   */
+  log(message) {
+    JobFacade.log(this.getName(), message);
+  }
+  /**
+   * Logs an error message for this job instance.
+   *
+   * @param message The error message content.
+   */
+  error(message) {
+    JobFacade.error(this.getName(), message);
+  }
+  /**
+   * Logs a warning message for this job instance.
+   *
+   * @param message The warning message content.
+   */
+  warn(message) {
+    JobFacade.warn(this.getName(), message);
+  }
+  /**
+   * Logs an informational message for this job instance.
+   *
+   * @param message The information message content.
+   */
+  info(message) {
+    JobFacade.info(this.getName(), message);
+  }
+}
+class JobParameters {
+  /**
+   * @param data The array of raw job parameter objects.
+   */
+  constructor(data) {
+    this.data = data;
+  }
+  /**
+   * Retrieves a specific job parameter by its index.
+   *
+   * @param i The index of the parameter in the array.
+   * @returns A {@link JobParameter} object.
+   */
+  get(i) {
+    return new JobParameter(this.data[i]);
+  }
+  /**
+   * Gets the total number of parameters defined for the job.
+   * @returns The count of parameters.
+   */
+  count() {
+    return this.data.length;
+  }
+}
+class JobParameter {
+  /**
+   * @param data The raw data object containing parameter properties.
+   */
+  constructor(data) {
+    this.data = data;
+  }
+  /**
+   * Gets the name of the parameter.
+   * @returns The parameter name.
+   */
+  getName() {
+    return this.data.name;
+  }
+  /**
+   * Gets the description of the parameter.
+   * @returns The parameter description.
+   */
+  getDescription() {
+    return this.data.description;
+  }
+  /**
+   * Gets the expected data type of the parameter (e.g., 'String', 'Integer', 'Boolean').
+   * @returns The parameter type.
+   */
+  getType() {
+    return this.data.type;
+  }
+  /**
+   * Gets the default value for the parameter.
+   * @returns The default value string.
+   */
+  getDefaultValue() {
+    return this.data.defaultValue;
+  }
+  /**
+   * Gets a list of predefined choices for the parameter, if applicable.
+   * @returns An array of choice strings.
+   */
+  getChoices() {
+    return this.data.choices;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Scheduler;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/job/scheduler.ts"],
  "sourcesContent": ["/**\n * Provides the API for managing scheduled jobs and tasks within the platform,\n * allowing users to retrieve, enable, disable, and trigger jobs, as well as log output.\n */\n\nimport { configurations } from \"@aerokit/sdk/core\";\n\nconst JobFacade = Java.type(\"org.eclipse.dirigible.components.api.job.JobFacade\");\n\n/**\n * The Scheduler class provides static methods for interacting with the job scheduler,\n * offering global control over the system's defined jobs.\n */\nexport class Scheduler {\n\n    /**\n     * Retrieves all job definitions currently configured in the system.\n     *\n     * @returns An array of {@link Job} objects.\n     */\n    public static getJobs(): Job[] {\n        const jobs = new Array<Job>();\n        const jobDefinitions = JSON.parse(JobFacade.getJobs());\n        for (const definition of jobDefinitions) {\n            jobs.push(new Job(definition));\n        }\n        return jobs;\n    }\n\n    /**\n     * Retrieves a specific job definition by its unique name.\n     *\n     * @param name The name of the job.\n     * @returns A {@link Job} object corresponding to the provided name.\n     */\n    public static getJob(name: string): Job {\n        const jobDefinition = JSON.parse(JobFacade.getJob(name));\n        return new Job(jobDefinition);\n    }\n\n    /**\n     * Enables a job, allowing it to be executed according to its schedule (cron expression).\n     *\n     * @param name The name of the job to enable.\n     */\n    public static enable(name: string): void {\n        JobFacade.enable(name);\n    }\n\n    /**\n     * Disables a job, preventing it from executing on its schedule.\n     *\n     * @param name The name of the job to disable.\n     */\n    public static disable(name: string): void {\n        JobFacade.disable(name);\n    }\n\n    /**\n     * Triggers the immediate execution of a job.\n     *\n     * @param name The name of the job to trigger.\n     * @param parameters Optional key-value object of parameters to pass to the job execution.\n     */\n    public static trigger(name: string, parameters: { [key: string]: string } = {}): void {\n        JobFacade.trigger(name, JSON.stringify(parameters));\n    }\n\n    /**\n     * Logs a message at the standard log level for a specific job instance.\n     * This is useful when the log context needs to be associated with a running job.\n     *\n     * @param name The name of the job to associate the log with.\n     * @param message The log message content.\n     */\n    public static log(name: string, message: string): void {\n        JobFacade.log(name, message);\n    }\n\n    /**\n     * Logs an error message for a specific job instance.\n     *\n     * @param name The name of the job.\n     * @param message The error message content.\n     */\n    public static error(name: string, message: string): void {\n        JobFacade.error(name, message);\n    }\n\n    /**\n     * Logs a warning message for a specific job instance.\n     *\n     * @param name The name of the job.\n     * @param message The warning message content.\n     */\n    public static warn(name: string, message: string): void {\n        JobFacade.warn(name, message);\n    }\n\n    /**\n     * Logs an informational message for a specific job instance.\n     *\n     * @param name The name of the job.\n     * @param message The information message content.\n     */\n    public static info(name: string, message: string): void {\n        JobFacade.info(name, message);\n    }\n\n}\n\n/**\n * Represents a single scheduled job definition.\n */\nclass Job {\n\n    private data: any;\n\n    /**\n     * @param data The raw data object containing job properties.\n     */\n    constructor(data: any) {\n        this.data = data;\n    }\n\n    /**\n     * Gets the unique name of the job.\n     * @returns The job name.\n     */\n    public getName(): string {\n        return this.data.name;\n    }\n\n    /**\n     * Gets the logical grouping for the job.\n     * @returns The job group name.\n     */\n    public getGroup(): string {\n        return this.data.group;\n    }\n\n    /**\n     * Gets the Java class name (for Java-based jobs) or script file name (for script-based jobs).\n     * @returns The job implementation class/file name.\n     */\n    public getClazz(): string {\n        return this.data.clazz;\n    }\n\n    /**\n     * Gets the description of the job's purpose.\n     * @returns The job description.\n     */\n    public getDescription(): string {\n        return this.data.description;\n    }\n\n    /**\n     * Gets the cron expression defining the job's schedule.\n     * @returns The cron expression string.\n     */\n    public getExpression(): string {\n        return this.data.expression;\n    }\n\n    /**\n     * Gets the handler file path or resource name for script-based jobs.\n     * @returns The handler path.\n     */\n    public getHandler(): string {\n        return this.data.handler;\n    }\n\n    /**\n     * Gets the execution engine type (e.g., 'JavaScript', 'Java').\n     * @returns The engine type.\n     */\n    public getEngine(): string {\n        return this.data.engine;\n    }\n\n    /**\n     * Checks if the job is configured as a singleton (only one instance runs at a time).\n     * @returns True if the job is a singleton.\n     */\n    public getSingleton(): boolean {\n        return this.data.singleton;\n    }\n\n    /**\n     * Checks if the job is currently enabled for scheduled execution.\n     * @returns True if the job is enabled.\n     */\n    public getEnabled(): boolean {\n        return this.data.enabled;\n    }\n\n    /**\n     * Gets the user ID who created the job definition.\n     * @returns The creator's user ID.\n     */\n    public getCreatedBy(): string {\n        return this.data.createdBy;\n    }\n\n    /**\n     * Gets the timestamp when the job definition was created.\n     * @returns The creation time as a numerical timestamp.\n     */\n    public getCreatedAt(): number {\n        return this.data.createdAt;\n    }\n\n    /**\n     * Gets the parameters associated with this job definition.\n     * @returns A {@link JobParameters} object containing all parameters.\n     */\n    public getParameters(): JobParameters {\n        return new JobParameters(this.data.parameters);\n    }\n\n    /**\n     * Retrieves the value for a specific parameter of this job.\n     * It checks for an overriding value in the global configurations first,\n     * and falls back to the defined default value if the configuration is not set.\n     *\n     * @param name The name of the parameter to retrieve.\n     * @returns The parameter's configured or default value, or null if not found.\n     */\n    public getParameter(name: string): string {\n        if (this.data) {\n            for (let i in this.data.parameters) {\n                if (this.data.parameters[i].name === name) {\n                    // Check global configuration for override\n                    let value = configurations.get(name);\n                    return value && value !== null ? value : this.data.parameters[i].defaultValue;\n                }\n            }\n        } else {\n            console.error(\"Job is not valid\");\n        }\n        return null;\n    }\n\n    /**\n     * Enables this specific job instance.\n     */\n    public enable(): void {\n        JobFacade.enable(this.getName());\n    }\n\n    /**\n     * Disables this specific job instance.\n     */\n    public disable(): void {\n        JobFacade.disable(this.getName());\n    }\n\n    /**\n     * Triggers the immediate execution of this job instance.\n     *\n     * @param parameters Optional key-value object of parameters to pass to the job execution.\n     */\n    public trigger(parameters: { [key: string]: string } = {}): void {\n        JobFacade.trigger(this.getName(), JSON.stringify(parameters));\n    }\n\n    /**\n     * Logs a message at the standard log level for this job instance.\n     *\n     * @param message The log message content.\n     */\n    public log(message: string): void {\n        JobFacade.log(this.getName(), message);\n    }\n\n    /**\n     * Logs an error message for this job instance.\n     *\n     * @param message The error message content.\n     */\n    public error(message: string): void {\n        JobFacade.error(this.getName(), message);\n    }\n\n    /**\n     * Logs a warning message for this job instance.\n     *\n     * @param message The warning message content.\n     */\n    public warn(message: string): void {\n        JobFacade.warn(this.getName(), message);\n    }\n\n    /**\n     * Logs an informational message for this job instance.\n     *\n     * @param message The information message content.\n     */\n    public info(message: string): void {\n        JobFacade.info(this.getName(), message);\n    }\n}\n\n/**\n * A container object representing the collection of parameters for a {@link Job}.\n */\nclass JobParameters {\n\n    private data: any[]\n\n    /**\n     * @param data The array of raw job parameter objects.\n     */\n    constructor(data: any[]) {\n        this.data = data;\n    }\n\n    /**\n     * Retrieves a specific job parameter by its index.\n     *\n     * @param i The index of the parameter in the array.\n     * @returns A {@link JobParameter} object.\n     */\n    public get(i: number): JobParameter {\n        return new JobParameter(this.data[i]);\n    }\n\n    /**\n     * Gets the total number of parameters defined for the job.\n     * @returns The count of parameters.\n     */\n    public count(): number {\n        return this.data.length;\n    }\n}\n\n/**\n * Represents a single parameter definition for a job.\n */\nclass JobParameter {\n\n    private data: any;\n\n    /**\n     * @param data The raw data object containing parameter properties.\n     */\n    constructor(data: any) {\n        this.data = data;\n    }\n\n    /**\n     * Gets the name of the parameter.\n     * @returns The parameter name.\n     */\n    public getName(): string {\n        return this.data.name;\n    }\n\n    /**\n     * Gets the description of the parameter.\n     * @returns The parameter description.\n     */\n    public getDescription(): string {\n        return this.data.description;\n    }\n\n    /**\n     * Gets the expected data type of the parameter (e.g., 'String', 'Integer', 'Boolean').\n     * @returns The parameter type.\n     */\n    public getType(): string {\n        return this.data.type;\n    }\n\n    /**\n     * Gets the default value for the parameter.\n     * @returns The default value string.\n     */\n    public getDefaultValue(): string {\n        return this.data.defaultValue;\n    }\n\n    /**\n     * Gets a list of predefined choices for the parameter, if applicable.\n     * @returns An array of choice strings.\n     */\n    public getChoices(): string[] {\n        return this.data.choices;\n    }\n\n}\n\n// @ts-ignore\nif (typeof module !== 'undefined') {\n\t// @ts-ignore\n\tmodule.exports = Scheduler;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/cjs/junit/index.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var junit_exports = {};
+module.exports = __toCommonJS(junit_exports);
+__reExport(junit_exports, require("./junit"), module.exports);
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2p1bml0L2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBmcm9tIFwiLi9qdW5pdFwiO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUEsMEJBQWMsb0JBQWQ7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/cjs/junit/junit.js

@@ -0,0 +1,67 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var junit_exports = {};
+__export(junit_exports, {
+  assertEquals: () => assertEquals,
+  assertFalse: () => assertFalse,
+  assertNotEquals: () => assertNotEquals,
+  assertTrue: () => assertTrue,
+  fail: () => fail,
+  test: () => test
+});
+module.exports = __toCommonJS(junit_exports);
+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();
+  }
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2p1bml0L2p1bml0LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIFByb3ZpZGVzIGEgc2V0IG9mIHV0aWxpdHkgZnVuY3Rpb25zIGZvciBkZWZpbmluZyB0ZXN0cyBhbmQgcGVyZm9ybWluZyBhc3NlcnRpb25zLFxuICogd3JhcHBpbmcgdGhlIG5hdGl2ZSBKVW5pdCBBc3NlcnRpb25zIGZvciB1c2UgaW4gVHlwZVNjcmlwdC9KYXZhU2NyaXB0IHRlc3RzLlxuICovXG5jb25zdCBBc3NlcnQgPSBKYXZhLnR5cGUoJ29yZy5qdW5pdC5Bc3NlcnQnKTtcblxuLyoqXG4gKiBEZWZpbmVzIGEgdGVzdCBjYXNlLlxuICpcbiAqIEBwYXJhbSBuYW1lIFRoZSBuYW1lIG9mIHRoZSB0ZXN0IGNhc2UuXG4gKiBAcGFyYW0gdGVzdEZuIFRoZSBmdW5jdGlvbiBjb250YWluaW5nIHRoZSB0ZXN0IGxvZ2ljIGFuZCBhc3NlcnRpb25zLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdGVzdChuYW1lOiBzdHJpbmcsIHRlc3RGbjogKCkgPT4gdm9pZCkge1xuICAgIC8vIENhbGxzIHRoZSBnbG9iYWwgdGVzdCBydW5uZXIgZnVuY3Rpb24gcHJvdmlkZWQgYnkgdGhlIFNESyBlbnZpcm9ubWVudC5cbiAgICAoZ2xvYmFsVGhpcyBhcyBhbnkpLnRlc3QobmFtZSwgdGVzdEZuKTtcbn1cblxuLyoqXG4gKiBBc3NlcnRzIHRoYXQgdHdvIG9iamVjdHMgb3IgcHJpbWl0aXZlIHZhbHVlcyBhcmUgZXF1YWwuXG4gKlxuICogQHRlbXBsYXRlIFQgVGhlIHR5cGUgb2YgdGhlIHZhbHVlcyBiZWluZyBjb21wYXJlZC5cbiAqIEBwYXJhbSBleHBlY3RlZCBUaGUgZXhwZWN0ZWQgdmFsdWUuXG4gKiBAcGFyYW0gYWN0dWFsIFRoZSBhY3R1YWwgdmFsdWUuXG4gKiBAcGFyYW0gbWVzc2FnZSBPcHRpb25hbCBtZXNzYWdlIHRvIGRpc3BsYXkgaWYgdGhlIGFzc2VydGlvbiBmYWlscy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydEVxdWFsczxUPihleHBlY3RlZDogVCwgYWN0dWFsOiBUKTogdm9pZFxuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydEVxdWFsczxUPihtZXNzYWdlOiBzdHJpbmcsIGV4cGVjdGVkOiBULCBhY3R1YWw6IFQpOiB2b2lkXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0RXF1YWxzPFQ+KG1lc3NhZ2VPckV4cGVjdGVkPzogc3RyaW5nIHwgVCwgZXhwZWN0ZWRPckFjdHVhbD86IFQsIGFjdHVhbE9yVW5kZWZpbmVkPzogVCk6IHZvaWQge1xuICAgIGlmIChhcmd1bWVudHMubGVuZ3RoID09PSAzKSB7XG4gICAgICAgIEFzc2VydC5hc3NlcnRFcXVhbHMobWVzc2FnZU9yRXhwZWN0ZWQsIGV4cGVjdGVkT3JBY3R1YWwsIGFjdHVhbE9yVW5kZWZpbmVkKTtcbiAgICB9IGVsc2Uge1xuICAgICAgICBBc3NlcnQuYXNzZXJ0RXF1YWxzKG1lc3NhZ2VPckV4cGVjdGVkLCBleHBlY3RlZE9yQWN0dWFsKTtcbiAgICB9XG59XG5cbi8qKlxuICogQXNzZXJ0cyB0aGF0IHR3byBvYmplY3RzIG9yIHByaW1pdGl2ZSB2YWx1ZXMgYXJlIG5vdCBlcXVhbC5cbiAqXG4gKiBAdGVtcGxhdGUgVCBUaGUgdHlwZSBvZiB0aGUgdmFsdWVzIGJlaW5nIGNvbXBhcmVkLlxuICogQHBhcmFtIHVuZXhwZWN0ZWQgVGhlIHVuZXhwZWN0ZWQgdmFsdWUuXG4gKiBAcGFyYW0gYWN0dWFsIFRoZSBhY3R1YWwgdmFsdWUuXG4gKiBAcGFyYW0gbWVzc2FnZSBPcHRpb25hbCBtZXNzYWdlIHRvIGRpc3BsYXkgaWYgdGhlIGFzc2VydGlvbiBmYWlscy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydE5vdEVxdWFsczxUPih1bmV4cGVjdGVkOiBULCBhY3R1YWw6IFQpOiB2b2lkXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0Tm90RXF1YWxzPFQ+KG1lc3NhZ2U6IHN0cmluZywgdW5leHBlY3RlZDogVCwgYWN0dWFsOiBUKTogdm9pZFxuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydE5vdEVxdWFsczxUPihtZXNzYWdlT3JVbmV4cGVjdGVkPzogc3RyaW5nIHwgVCwgdW5leHBlY3RlZE9yQWN0dWFsPzogVCwgYWN0dWFsT3JVbmRlZmluZWQ/OiBUKTogdm9pZCB7XG4gICAgaWYgKGFyZ3VtZW50cy5sZW5ndGggPT09IDMpIHtcbiAgICAgICAgQXNzZXJ0LmFzc2VydE5vdEVxdWFscyhtZXNzYWdlT3JVbmV4cGVjdGVkLCB1bmV4cGVjdGVkT3JBY3R1YWwsIGFjdHVhbE9yVW5kZWZpbmVkKTtcbiAgICB9IGVsc2Uge1xuICAgICAgICBBc3NlcnQuYXNzZXJ0Tm90RXF1YWxzKG1lc3NhZ2VPclVuZXhwZWN0ZWQsIHVuZXhwZWN0ZWRPckFjdHVhbCk7XG4gICAgfVxufVxuXG4vKipcbiAqIEFzc2VydHMgdGhhdCBhIGNvbmRpdGlvbiBpcyB0cnVlLlxuICpcbiAqIEBwYXJhbSBjb25kaXRpb24gVGhlIGNvbmRpdGlvbiB0byB0ZXN0LlxuICogQHBhcmFtIG1lc3NhZ2UgT3B0aW9uYWwgbWVzc2FnZSB0byBkaXNwbGF5IGlmIHRoZSBhc3NlcnRpb24gZmFpbHMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhc3NlcnRUcnVlKGNvbmRpdGlvbjogYm9vbGVhbik6IHZvaWRcbmV4cG9ydCBmdW5jdGlvbiBhc3NlcnRUcnVlKG1lc3NhZ2U6IHN0cmluZywgY29uZGl0aW9uOiBib29sZWFuKTogdm9pZFxuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydFRydWUobWVzc2FnZU9yQ29uZGl0aW9uPzogc3RyaW5nIHwgYm9vbGVhbiwgY29uZGl0aW9uT3JVbmRlZmluZWQ/OiBib29sZWFuKTogdm9pZCB7XG4gICAgaWYgKGFyZ3VtZW50cy5sZW5ndGggPT09IDIpIHtcbiAgICAgICAgQXNzZXJ0LmFzc2VydFRydWUobWVzc2FnZU9yQ29uZGl0aW9uLCBjb25kaXRpb25PclVuZGVmaW5lZCk7XG4gICAgfSBlbHNlIHtcbiAgICAgICAgQXNzZXJ0LmFzc2VydFRydWUobWVzc2FnZU9yQ29uZGl0aW9uKTtcbiAgICB9XG59XG5cbi8qKlxuICogQXNzZXJ0cyB0aGF0IGEgY29uZGl0aW9uIGlzIGZhbHNlLlxuICpcbiAqIEBwYXJhbSBjb25kaXRpb24gVGhlIGNvbmRpdGlvbiB0byB0ZXN0LlxuICogQHBhcmFtIG1lc3NhZ2UgT3B0aW9uYWwgbWVzc2FnZSB0byBkaXNwbGF5IGlmIHRoZSBhc3NlcnRpb24gZmFpbHMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhc3NlcnRGYWxzZShjb25kaXRpb246IGJvb2xlYW4pOiB2b2lkXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0RmFsc2UobWVzc2FnZTogc3RyaW5nLCBjb25kaXRpb246IGJvb2xlYW4pOiB2b2lkXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0RmFsc2UobWVzc2FnZU9yQ29uZGl0aW9uPzogc3RyaW5nIHwgYm9vbGVhbiwgY29uZGl0aW9uT3JVbmRlZmluZWQ/OiBib29sZWFuKTogdm9pZCB7XG4gICAgaWYgKGFyZ3VtZW50cy5sZW5ndGggPT09IDIpIHtcbiAgICAgICAgQXNzZXJ0LmFzc2VydEZhbHNlKG1lc3NhZ2VPckNvbmRpdGlvbiwgY29uZGl0aW9uT3JVbmRlZmluZWQpO1xuICAgIH0gZWxzZSB7XG4gICAgICAgIEFzc2VydC5hc3NlcnRGYWxzZShtZXNzYWdlT3JDb25kaXRpb24pO1xuICAgIH1cbn1cblxuLyoqXG4gKiBGYWlscyBhIHRlc3QgaW1tZWRpYXRlbHkuXG4gKlxuICogQHBhcmFtIG1lc3NhZ2UgT3B0aW9uYWwgbWVzc2FnZSB0byBkaXNwbGF5IGluZGljYXRpbmcgdGhlIHJlYXNvbiBmb3IgdGhlIGZhaWx1cmUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBmYWlsKCk6IHZvaWRcbmV4cG9ydCBmdW5jdGlvbiBmYWlsKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWRcbmV4cG9ydCBmdW5jdGlvbiBmYWlsKG1lc3NhZ2U/OiBzdHJpbmcpOiB2b2lkIHtcbiAgICBpZiAobWVzc2FnZSkge1xuICAgICAgICBBc3NlcnQuZmFpbChtZXNzYWdlKTtcbiAgICB9IGVsc2Uge1xuICAgICAgICBBc3NlcnQuZmFpbCgpO1xuICAgIH1cbn0iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBSUEsTUFBTSxTQUFTLEtBQUssS0FBSyxrQkFBa0I7QUFRcEMsU0FBUyxLQUFLLE1BQWMsUUFBb0I7QUFFbkQsRUFBQyxXQUFtQixLQUFLLE1BQU0sTUFBTTtBQUN6QztBQVlPLFNBQVMsYUFBZ0IsbUJBQWdDLGtCQUFzQixtQkFBNkI7QUFDL0csTUFBSSxVQUFVLFdBQVcsR0FBRztBQUN4QixXQUFPLGFBQWEsbUJBQW1CLGtCQUFrQixpQkFBaUI7QUFBQSxFQUM5RSxPQUFPO0FBQ0gsV0FBTyxhQUFhLG1CQUFtQixnQkFBZ0I7QUFBQSxFQUMzRDtBQUNKO0FBWU8sU0FBUyxnQkFBbUIscUJBQWtDLG9CQUF3QixtQkFBNkI7QUFDdEgsTUFBSSxVQUFVLFdBQVcsR0FBRztBQUN4QixXQUFPLGdCQUFnQixxQkFBcUIsb0JBQW9CLGlCQUFpQjtBQUFBLEVBQ3JGLE9BQU87QUFDSCxXQUFPLGdCQUFnQixxQkFBcUIsa0JBQWtCO0FBQUEsRUFDbEU7QUFDSjtBQVVPLFNBQVMsV0FBVyxvQkFBdUMsc0JBQXNDO0FBQ3BHLE1BQUksVUFBVSxXQUFXLEdBQUc7QUFDeEIsV0FBTyxXQUFXLG9CQUFvQixvQkFBb0I7QUFBQSxFQUM5RCxPQUFPO0FBQ0gsV0FBTyxXQUFXLGtCQUFrQjtBQUFBLEVBQ3hDO0FBQ0o7QUFVTyxTQUFTLFlBQVksb0JBQXVDLHNCQUFzQztBQUNyRyxNQUFJLFVBQVUsV0FBVyxHQUFHO0FBQ3hCLFdBQU8sWUFBWSxvQkFBb0Isb0JBQW9CO0FBQUEsRUFDL0QsT0FBTztBQUNILFdBQU8sWUFBWSxrQkFBa0I7QUFBQSxFQUN6QztBQUNKO0FBU08sU0FBUyxLQUFLLFNBQXdCO0FBQ3pDLE1BQUksU0FBUztBQUNULFdBQU8sS0FBSyxPQUFPO0FBQUEsRUFDdkIsT0FBTztBQUNILFdBQU8sS0FBSztBQUFBLEVBQ2hCO0FBQ0o7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/cjs/kafka/consumer.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var consumer_exports = {};
+__export(consumer_exports, {
+  Consumer: () => Consumer
+});
+module.exports = __toCommonJS(consumer_exports);
+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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/kafka/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var kafka_exports = {};
+__export(kafka_exports, {
+  consumer: () => import_consumer.Consumer,
+  producer: () => import_producer.Producer
+});
+module.exports = __toCommonJS(kafka_exports);
+var import_consumer = require("./consumer");
+__reExport(kafka_exports, require("./consumer"), module.exports);
+var import_producer = require("./producer");
+__reExport(kafka_exports, require("./producer"), module.exports);
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2thZmthL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgeyBDb25zdW1lciBhcyBjb25zdW1lciB9IGZyb20gXCIuL2NvbnN1bWVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdW1lclwiO1xuZXhwb3J0IHsgUHJvZHVjZXIgYXMgcHJvZHVjZXIgfSBmcm9tIFwiLi9wcm9kdWNlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHJvZHVjZXJcIjsiXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxzQkFBcUM7QUFDckMsMEJBQWMsdUJBRGQ7QUFFQSxzQkFBcUM7QUFDckMsMEJBQWMsdUJBSGQ7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/cjs/kafka/producer.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var producer_exports = {};
+__export(producer_exports, {
+  Producer: () => Producer
+});
+module.exports = __toCommonJS(producer_exports);
+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;
+}
+//# sourceMappingURL=data:application/json;base64,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