@aerokit/sdk 12.44.0

package/dist/esm/io/zip.mjs

@@ -0,0 +1,232 @@
+import { Bytes } from "@aerokit/sdk/io/bytes";
+const ZipFacade = Java.type("org.eclipse.dirigible.components.api.io.ZipFacade");
+class Zip {
+  /**
+   * Zips the content of a source directory or file into a target ZIP file.
+   *
+   * @param sourcePath The file system path to the content to be compressed.
+   * @param zipTargetPath The file system path where the resulting ZIP file should be saved.
+   */
+  static zip(sourcePath, zipTargetPath) {
+    ZipFacade.exportZip(sourcePath, zipTargetPath);
+  }
+  /**
+   * Unzips an existing ZIP file into a target directory.
+   *
+   * @param zipPath The file system path to the ZIP file to be extracted.
+   * @param targetPath The file system path to the directory where content should be extracted.
+   */
+  static unzip(zipPath, targetPath) {
+    ZipFacade.importZip(zipPath, targetPath);
+  }
+  /**
+   * Creates a {@link ZipInputStream} that reads ZIP archive data from a provided
+   * generic {@link InputStream}. This allows for reading ZIP entries without
+   * writing the archive to disk first.
+   *
+   * @param inputStream The source stream containing the raw ZIP data.
+   * @returns A new {@link ZipInputStream} instance.
+   */
+  static createZipInputStream(inputStream) {
+    const native = ZipFacade.createZipInputStream(inputStream.native);
+    return new ZipInputStream(native);
+  }
+  /**
+   * Creates a {@link ZipOutputStream} that writes compressed ZIP archive data
+   * to a provided generic {@link OutputStream}. This allows for creating ZIP archives
+   * in memory or streaming them directly.
+   *
+   * @param outputStream The destination stream where the raw ZIP data will be written.
+   * @returns A new {@link ZipOutputStream} instance.
+   */
+  static createZipOutputStream(outputStream) {
+    const native = ZipFacade.createZipOutputStream(outputStream.native);
+    return new ZipOutputStream(native);
+  }
+}
+class ZipInputStream {
+  /**
+   * @param native The underlying native ZipInputStream object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Reads the next ZIP file entry and positions the stream at the beginning of the entry data.
+   * Must be called before reading data for an entry.
+   *
+   * @returns The next {@link ZipEntry} object, or null if there are no more entries.
+   */
+  getNextEntry() {
+    const native = this.native.getNextEntry();
+    return new ZipEntry(native);
+  }
+  /**
+   * Reads the data for the current entry and returns it as a JavaScript byte array.
+   *
+   * @returns A JavaScript array (`number[]`) of the byte values for the current entry.
+   */
+  read() {
+    const native = ZipFacade.readNative(this.native);
+    return Bytes.toJavaScriptBytes(native);
+  }
+  /**
+   * Reads the data for the current entry and returns the native Java byte array.
+   *
+   * @returns The native Java byte array object.
+   */
+  readNative() {
+    return ZipFacade.readNative(this.native);
+  }
+  /**
+   * Reads the data for the current entry and converts it to a string
+   * using the platform's default character encoding.
+   *
+   * @returns The content of the current entry as a string.
+   */
+  readText() {
+    return ZipFacade.readText(this.native);
+  }
+  /**
+   * Closes the underlying native ZipInputStream.
+   */
+  close() {
+    this.native.close();
+  }
+}
+class ZipOutputStream {
+  /**
+   * @param native The underlying native ZipOutputStream object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Creates a new {@link ZipEntry} with the given name, and begins writing the
+   * entry's header to the archive stream. All subsequent write operations
+   * will apply to this entry until {@link closeEntry} is called.
+   *
+   * @param name The file or directory name to use inside the ZIP archive.
+   * @returns The newly created {@link ZipEntry} object.
+   */
+  createZipEntry(name) {
+    const nativeNext = ZipFacade.createZipEntry(name);
+    const zipEntry = new ZipEntry(nativeNext);
+    this.native.putNextEntry(nativeNext);
+    return zipEntry;
+  }
+  /**
+   * Writes the data from a JavaScript byte array to the current active entry in the stream.
+   *
+   * @param data The JavaScript array (`number[]`) of byte values to write.
+   */
+  write(data) {
+    const native = Bytes.toJavaBytes(data);
+    ZipFacade.writeNative(this.native, native);
+  }
+  /**
+   * Writes the data from a native Java byte array to the current active entry in the stream.
+   *
+   * @param data The native Java byte array object to write.
+   */
+  writeNative(data) {
+    ZipFacade.writeNative(this.native, data);
+  }
+  /**
+   * Converts the string to bytes and writes it to the current active entry in the stream.
+   *
+   * @param text The string content to write.
+   */
+  writeText(text) {
+    ZipFacade.writeText(this.native, text);
+  }
+  /**
+   * Closes the current active ZIP entry and positions the stream for the next entry.
+   */
+  closeEntry() {
+    this.native.closeEntry();
+  }
+  /**
+   * Finalizes the writing of the ZIP file, flushes the stream, and closes the native object.
+   * This must be called after all entries have been written.
+   */
+  close() {
+    this.native.finish();
+    this.native.flush();
+    this.native.close();
+  }
+}
+class ZipEntry {
+  /**
+   * @param native The underlying native ZipEntry object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Gets the name of the entry (path relative to the ZIP root).
+   * @returns The name of the entry.
+   */
+  getName() {
+    return this.native.getName();
+  }
+  /**
+   * Gets the uncompressed size of the entry data.
+   * @returns The size in bytes.
+   */
+  getSize() {
+    return this.native.getSize();
+  }
+  /**
+   * Gets the compressed size of the entry data.
+   * @returns The compressed size in bytes.
+   */
+  getCompressedSize() {
+    return this.native.getCompressedSize();
+  }
+  /**
+   * Gets the modification time of the entry.
+   * @returns The time as a numerical timestamp.
+   */
+  getTime() {
+    return this.native.getTime();
+  }
+  /**
+   * Gets the CRC-32 checksum of the uncompressed entry data.
+   * @returns The CRC value.
+   */
+  getCrc() {
+    return this.native.getCrc();
+  }
+  /**
+   * Gets the optional comment for the entry.
+   * @returns The comment string.
+   */
+  getComment() {
+    return this.native.getComment();
+  }
+  /**
+   * Checks if the entry represents a directory.
+   * @returns True if it is a directory, false otherwise.
+   */
+  isDirectory() {
+    return this.native.isDirectory();
+  }
+  /**
+   * Checks if the underlying native ZipEntry object is defined and non-null.
+   * @returns True if the entry is valid, false otherwise.
+   */
+  isValid() {
+    return this.native !== void 0 && this.native !== null;
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = Zip;
+}
+export {
+  Zip,
+  ZipEntry,
+  ZipInputStream,
+  ZipOutputStream
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/io/zip.ts"],
  "sourcesContent": ["/**\r\n * Provides a fa\u00E7ade for handling ZIP archive operations, including\r\n * file compression, decompression, and stream-based entry processing.\r\n */\r\nimport { Bytes } from \"@aerokit/sdk/io/bytes\";\r\nimport { InputStream, OutputStream } from \"@aerokit/sdk/io/streams\";\r\n\r\nconst ZipFacade = Java.type(\"org.eclipse.dirigible.components.api.io.ZipFacade\");\r\n\r\n/**\r\n * The Zip class provides static utility methods for managing ZIP archives\r\n * at both file path level and stream level.\r\n */\r\nexport class Zip {\r\n\r\n    /**\r\n     * Zips the content of a source directory or file into a target ZIP file.\r\n     *\r\n     * @param sourcePath The file system path to the content to be compressed.\r\n     * @param zipTargetPath The file system path where the resulting ZIP file should be saved.\r\n     */\r\n    public static zip(sourcePath: string, zipTargetPath: string): void {\r\n        ZipFacade.exportZip(sourcePath, zipTargetPath);\r\n    }\r\n\r\n    /**\r\n     * Unzips an existing ZIP file into a target directory.\r\n     *\r\n     * @param zipPath The file system path to the ZIP file to be extracted.\r\n     * @param targetPath The file system path to the directory where content should be extracted.\r\n     */\r\n    public static unzip(zipPath: string, targetPath: string): void {\r\n        ZipFacade.importZip(zipPath, targetPath);\r\n    }\r\n\r\n    /**\r\n     * Creates a {@link ZipInputStream} that reads ZIP archive data from a provided\r\n     * generic {@link InputStream}. This allows for reading ZIP entries without\r\n     * writing the archive to disk first.\r\n     *\r\n     * @param inputStream The source stream containing the raw ZIP data.\r\n     * @returns A new {@link ZipInputStream} instance.\r\n     */\r\n    public static createZipInputStream(inputStream: InputStream): ZipInputStream {\r\n        const native = ZipFacade.createZipInputStream(inputStream.native);\r\n        return new ZipInputStream(native);\r\n    }\r\n\r\n    /**\r\n     * Creates a {@link ZipOutputStream} that writes compressed ZIP archive data\r\n     * to a provided generic {@link OutputStream}. This allows for creating ZIP archives\r\n     * in memory or streaming them directly.\r\n     *\r\n     * @param outputStream The destination stream where the raw ZIP data will be written.\r\n     * @returns A new {@link ZipOutputStream} instance.\r\n     */\r\n    public static createZipOutputStream(outputStream: OutputStream): ZipOutputStream {\r\n        const native = ZipFacade.createZipOutputStream(outputStream.native);\r\n        return new ZipOutputStream(native);\r\n    }\r\n}\r\n\r\n/**\r\n * Represents an input stream for reading data from a ZIP archive.\r\n * Data is accessed sequentially by iterating through {@link ZipEntry} objects.\r\n */\r\nexport class ZipInputStream {\r\n\r\n    private readonly native: any;\r\n\r\n    /**\r\n     * @param native The underlying native ZipInputStream object.\r\n     */\r\n    constructor(native: any) {\r\n        this.native = native;\r\n    }\r\n\r\n    /**\r\n     * Reads the next ZIP file entry and positions the stream at the beginning of the entry data.\r\n     * Must be called before reading data for an entry.\r\n     *\r\n     * @returns The next {@link ZipEntry} object, or null if there are no more entries.\r\n     */\r\n    public getNextEntry(): ZipEntry {\r\n        const native = this.native.getNextEntry();\r\n        // If native is null (end of stream), the ZipEntry constructor will handle the null check or throw/return invalid.\r\n        return new ZipEntry(native);\r\n    }\r\n\r\n    /**\r\n     * Reads the data for the current entry and returns it as a JavaScript byte array.\r\n     *\r\n     * @returns A JavaScript array (`number[]`) of the byte values for the current entry.\r\n     */\r\n    public read(): any[] {\r\n        const native = ZipFacade.readNative(this.native);\r\n        return Bytes.toJavaScriptBytes(native);\r\n    }\r\n\r\n    /**\r\n     * Reads the data for the current entry and returns the native Java byte array.\r\n     *\r\n     * @returns The native Java byte array object.\r\n     */\r\n    public readNative(): any[] {\r\n        return ZipFacade.readNative(this.native);\r\n    }\r\n\r\n    /**\r\n     * Reads the data for the current entry and converts it to a string\r\n     * using the platform's default character encoding.\r\n     *\r\n     * @returns The content of the current entry as a string.\r\n     */\r\n    public readText(): string {\r\n        return ZipFacade.readText(this.native);\r\n    }\r\n\r\n    /**\r\n     * Closes the underlying native ZipInputStream.\r\n     */\r\n    public close(): void {\r\n        this.native.close();\r\n    }\r\n\r\n}\r\n\r\n/**\r\n * Represents an output stream for writing data to a ZIP archive.\r\n * Entries must be explicitly created and closed.\r\n */\r\nexport class ZipOutputStream {\r\n\r\n    private readonly native: any;\r\n\r\n    /**\r\n     * @param native The underlying native ZipOutputStream object.\r\n     */\r\n    constructor(native: any) {\r\n        this.native = native;\r\n    }\r\n\r\n    /**\r\n     * Creates a new {@link ZipEntry} with the given name, and begins writing the\r\n     * entry's header to the archive stream. All subsequent write operations\r\n     * will apply to this entry until {@link closeEntry} is called.\r\n     *\r\n     * @param name The file or directory name to use inside the ZIP archive.\r\n     * @returns The newly created {@link ZipEntry} object.\r\n     */\r\n    public createZipEntry(name: string): ZipEntry {\r\n        const nativeNext = ZipFacade.createZipEntry(name);\r\n        const zipEntry = new ZipEntry(nativeNext);\r\n        this.native.putNextEntry(nativeNext);\r\n        return zipEntry;\r\n    }\r\n\r\n    /**\r\n     * Writes the data from a JavaScript byte array to the current active entry in the stream.\r\n     *\r\n     * @param data The JavaScript array (`number[]`) of byte values to write.\r\n     */\r\n    public write(data: any[]): void {\r\n        const native = Bytes.toJavaBytes(data);\r\n        ZipFacade.writeNative(this.native, native);\r\n    }\r\n\r\n    /**\r\n     * Writes the data from a native Java byte array to the current active entry in the stream.\r\n     *\r\n     * @param data The native Java byte array object to write.\r\n     */\r\n    public writeNative(data: any[]): void {\r\n        ZipFacade.writeNative(this.native, data);\r\n    }\r\n\r\n    /**\r\n     * Converts the string to bytes and writes it to the current active entry in the stream.\r\n     *\r\n     * @param text The string content to write.\r\n     */\r\n    public writeText(text: string): void {\r\n        ZipFacade.writeText(this.native, text);\r\n    }\r\n\r\n    /**\r\n     * Closes the current active ZIP entry and positions the stream for the next entry.\r\n     */\r\n    public closeEntry(): void {\r\n        this.native.closeEntry();\r\n    }\r\n\r\n    /**\r\n     * Finalizes the writing of the ZIP file, flushes the stream, and closes the native object.\r\n     * This must be called after all entries have been written.\r\n     */\r\n    public close(): void {\r\n        this.native.finish();\r\n        this.native.flush();\r\n        this.native.close();\r\n    }\r\n}\r\n\r\n/**\r\n * Represents an entry (file or directory) within a ZIP archive.\r\n * It holds metadata about the archived item.\r\n */\r\nexport class ZipEntry {\r\n\r\n    private readonly native: any;\r\n\r\n    /**\r\n     * @param native The underlying native ZipEntry object.\r\n     */\r\n    constructor(native: any) {\r\n        this.native = native;\r\n    }\r\n\r\n    /**\r\n     * Gets the name of the entry (path relative to the ZIP root).\r\n     * @returns The name of the entry.\r\n     */\r\n    public getName(): string {\r\n        return this.native.getName();\r\n    }\r\n\r\n    /**\r\n     * Gets the uncompressed size of the entry data.\r\n     * @returns The size in bytes.\r\n     */\r\n    public getSize(): number {\r\n        return this.native.getSize();\r\n    }\r\n\r\n    /**\r\n     * Gets the compressed size of the entry data.\r\n     * @returns The compressed size in bytes.\r\n     */\r\n    public getCompressedSize(): number {\r\n        return this.native.getCompressedSize();\r\n    }\r\n\r\n    /**\r\n     * Gets the modification time of the entry.\r\n     * @returns The time as a numerical timestamp.\r\n     */\r\n    public getTime(): number {\r\n        return this.native.getTime();\r\n    }\r\n\r\n    /**\r\n     * Gets the CRC-32 checksum of the uncompressed entry data.\r\n     * @returns The CRC value.\r\n     */\r\n    public getCrc(): number {\r\n        return this.native.getCrc();\r\n    }\r\n\r\n    /**\r\n     * Gets the optional comment for the entry.\r\n     * @returns The comment string.\r\n     */\r\n    public getComment(): string {\r\n        return this.native.getComment();\r\n    }\r\n\r\n    /**\r\n     * Checks if the entry represents a directory.\r\n     * @returns True if it is a directory, false otherwise.\r\n     */\r\n    public isDirectory(): boolean {\r\n        return this.native.isDirectory();\r\n    }\r\n\r\n    /**\r\n     * Checks if the underlying native ZipEntry object is defined and non-null.\r\n     * @returns True if the entry is valid, false otherwise.\r\n     */\r\n    public isValid(): boolean {\r\n        return this.native !== undefined && this.native !== null;\r\n    }\r\n}\r\n\r\n// @ts-ignore\r\nif (typeof module !== 'undefined') {\r\n\t// @ts-ignore\r\n\tmodule.exports = Zip;\r\n}\r\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/job/decorators.mjs

@@ -0,0 +1,21 @@
+const SCHEDULED_METADATA_KEY = Symbol("scheduled:metadata");
+function Scheduled(options) {
+  return function(target, context) {
+    if (context.kind !== "class") {
+      throw new Error(`@Scheduled can only be used on classes.`);
+    }
+    Object.defineProperty(target, SCHEDULED_METADATA_KEY, {
+      value: {
+        expression: options.expression,
+        group: options.group
+      },
+      writable: false,
+      configurable: false,
+      enumerable: true
+    });
+  };
+}
+export {
+  Scheduled
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2pvYi9kZWNvcmF0b3JzLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJjb25zdCBTQ0hFRFVMRURfTUVUQURBVEFfS0VZID0gU3ltYm9sKFwic2NoZWR1bGVkOm1ldGFkYXRhXCIpO1xuXG5leHBvcnQgaW50ZXJmYWNlIFNjaGVkdWxlZE9wdGlvbnMge1xuICAgIGV4cHJlc3Npb246IHN0cmluZzsgLy8gZS5nLiwgXCIwLzEwICogKiAqICogP1wiXG4gICAgZ3JvdXA/OiBzdHJpbmc7ICAgICAgLy8gZS5nLiwgXCJkZWZpbmVkXCJcbn1cblxuLyoqXG4gKiBAU2NoZWR1bGVkIGRlY29yYXRvclxuICogTWFya3MgYW4gZW50aXJlIGNsYXNzIGFzIGEgc2NoZWR1bGVkIGpvYiB3aXRoIGEgY3JvbiBleHByZXNzaW9uLlxuICpcbiAqIGludHJvZHVjZWQgaW4gVHlwZVNjcmlwdCA1LjAsIHdoaWNoIGV4cGVjdHMgYSBDbGFzc0RlY29yYXRvckNvbnRleHQgb2JqZWN0LlxuICovXG5leHBvcnQgZnVuY3Rpb24gU2NoZWR1bGVkKG9wdGlvbnM6IFNjaGVkdWxlZE9wdGlvbnMpIHtcbiAgICBcbiAgICByZXR1cm4gZnVuY3Rpb24gPFQgZXh0ZW5kcyBhYnN0cmFjdCBuZXcgKC4uLmFyZ3M6IGFueSkgPT4gYW55Pih0YXJnZXQ6IFQsIGNvbnRleHQ6IENsYXNzRGVjb3JhdG9yQ29udGV4dDxUPikge1xuICAgICAgICBcbiAgICAgICAgaWYgKGNvbnRleHQua2luZCAhPT0gJ2NsYXNzJykge1xuICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBAU2NoZWR1bGVkIGNhbiBvbmx5IGJlIHVzZWQgb24gY2xhc3Nlcy5gKTtcbiAgICAgICAgfVxuXG4gICAgICAgIE9iamVjdC5kZWZpbmVQcm9wZXJ0eSh0YXJnZXQsIFNDSEVEVUxFRF9NRVRBREFUQV9LRVksIHtcbiAgICAgICAgICAgIHZhbHVlOiB7XG4gICAgICAgICAgICAgICAgZXhwcmVzc2lvbjogb3B0aW9ucy5leHByZXNzaW9uLFxuICAgICAgICAgICAgICAgIGdyb3VwOiBvcHRpb25zLmdyb3VwXG4gICAgICAgICAgICB9LFxuICAgICAgICAgICAgd3JpdGFibGU6IGZhbHNlLFxuICAgICAgICAgICAgY29uZmlndXJhYmxlOiBmYWxzZSxcbiAgICAgICAgICAgIGVudW1lcmFibGU6IHRydWVcbiAgICAgICAgfSk7XG4gICAgfTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQUFBLE1BQU0seUJBQXlCLE9BQU8sb0JBQW9CO0FBYW5ELFNBQVMsVUFBVSxTQUEyQjtBQUVqRCxTQUFPLFNBQXdELFFBQVcsU0FBbUM7QUFFekcsUUFBSSxRQUFRLFNBQVMsU0FBUztBQUMxQixZQUFNLElBQUksTUFBTSx5Q0FBeUM7QUFBQSxJQUM3RDtBQUVBLFdBQU8sZUFBZSxRQUFRLHdCQUF3QjtBQUFBLE1BQ2xELE9BQU87QUFBQSxRQUNILFlBQVksUUFBUTtBQUFBLFFBQ3BCLE9BQU8sUUFBUTtBQUFBLE1BQ25CO0FBQUEsTUFDQSxVQUFVO0FBQUEsTUFDVixjQUFjO0FBQUEsTUFDZCxZQUFZO0FBQUEsSUFDaEIsQ0FBQztBQUFBLEVBQ0w7QUFDSjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/esm/job/index.mjs

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

package/dist/esm/job/scheduler.mjs

@@ -0,0 +1,328 @@
+import { configurations } from "@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 = 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;
+}
+export {
+  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/esm/junit/index.mjs

@@ -0,0 +1,2 @@
+export * from "./junit";
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2p1bml0L2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgKiBmcm9tIFwiLi9qdW5pdFwiO1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsY0FBYzsiLAogICJuYW1lcyI6IFtdCn0K