javonet-nodejs-sdk 2.6.13 → 2.6.15

package/dist/plugins/PluginImplementationRegistry.cjs

@@ -0,0 +1,214 @@
+"use strict";
+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 PluginImplementationRegistry_exports = {};
+__export(PluginImplementationRegistry_exports, {
+  PluginImplementationRegistry: () => PluginImplementationRegistry
+});
+module.exports = __toCommonJS(PluginImplementationRegistry_exports);
+class PluginImplementationRegistry {
+  /** @type {Map<string, Function>} Map of interface names to implementation constructors for transient plugins */
+  static #transientImplementations = /* @__PURE__ */ new Map();
+  /** @type {Map<Function, object>} Map of implementation types to singleton instances */
+  static #singletonImplementations = /* @__PURE__ */ new Map();
+  /** @type {Map<Function, object>} Map of settings types to configuration objects */
+  static #pluginConfigurations = /* @__PURE__ */ new Map();
+  /**
+   * Registers a transient plugin implementation. A new instance will be created each time the plugin is resolved.
+   * 
+   * @param {Function} InterfaceClass - The interface or base class of the plugin (must be a class/constructor)
+   * @param {Function} ImplementationClass - The concrete class that implements InterfaceClass
+   * @throws {TypeError} If InterfaceClass is not a function/constructor
+   * @throws {TypeError} If ImplementationClass is not a function/constructor
+   * 
+   * @example
+   * PluginImplementationRegistry.registerPluginTransientImplementation(IJwtAuthorize, JwtAuthorizeImpl)
+   */
+  static registerPluginTransientImplementation(InterfaceClass, ImplementationClass) {
+    if (typeof InterfaceClass !== "function") {
+      throw new TypeError(`${InterfaceClass?.name || "InterfaceClass"} is not a function. Only classes/constructors are allowed.`);
+    }
+    if (typeof ImplementationClass !== "function") {
+      throw new TypeError(`${ImplementationClass?.name || "ImplementationClass"} is not a function. Only classes/constructors are allowed.`);
+    }
+    const interfaceName = InterfaceClass.name || InterfaceClass.toString();
+    PluginImplementationRegistry.#transientImplementations.set(interfaceName, ImplementationClass);
+  }
+  /**
+   * Resolves a new instance of a transiently registered plugin.
+   * 
+   * @param {Function} InterfaceClass - The type of the plugin interface to resolve
+   * @param {...any} constructorArgs - Optional arguments to pass to the constructor
+   * @returns {object} A newly created instance of the registered implementation
+   * @throws {Error} If the plugin type has not been registered as transient
+   * @throws {TypeError} If InterfaceClass is not a function/constructor
+   * 
+   * @example
+   * const jwtAuthorize = PluginImplementationRegistry.resolvePluginTransientImplementation(IJwtAuthorize)
+   */
+  static resolvePluginTransientImplementation(InterfaceClass, ...constructorArgs) {
+    if (typeof InterfaceClass !== "function") {
+      throw new TypeError(`${InterfaceClass?.name || "InterfaceClass"} is not a function. Only classes/constructors are allowed.`);
+    }
+    const interfaceName = InterfaceClass.name || InterfaceClass.toString();
+    const ImplementationClass = PluginImplementationRegistry.#transientImplementations.get(interfaceName);
+    if (!ImplementationClass) {
+      throw new Error(`No transient implementation registered for ${interfaceName}.`);
+    }
+    try {
+      const instance = constructorArgs.length > 0 ? new ImplementationClass(...constructorArgs) : new ImplementationClass();
+      if (!instance) {
+        throw new Error(`Could not instantiate ${ImplementationClass.name || "implementation"}.`);
+      }
+      return instance;
+    } catch (error) {
+      throw new Error(`Failed to create instance of ${ImplementationClass.name || "implementation"}: ${error.message}`);
+    }
+  }
+  /**
+   * Registers a plugin configuration/settings object.
+   * 
+   * @param {Function} SettingsClass - The settings class type
+   * @param {object} settings - The settings instance to register
+   * @throws {TypeError} If SettingsClass is not a function/constructor
+   * @throws {TypeError} If settings is not an object
+   * 
+   * @example
+   * const settings = new JwtGraftocodePluginSettings()
+   * settings.username = 'user'
+   * settings.secretKey = 'key'
+   * PluginImplementationRegistry.registerPluginConfiguration(JwtGraftocodePluginSettings, settings)
+   */
+  static registerPluginConfiguration(SettingsClass, settings) {
+    if (typeof SettingsClass !== "function") {
+      throw new TypeError(`${SettingsClass?.name || "SettingsClass"} is not a function. Only classes/constructors are allowed.`);
+    }
+    if (!settings || typeof settings !== "object") {
+      throw new TypeError("settings must be an object");
+    }
+    PluginImplementationRegistry.#pluginConfigurations.set(SettingsClass, settings);
+  }
+  /**
+   * Retrieves the configuration object of the specified type for a given plugin.
+   * 
+   * @param {Function} SettingsClass - The expected configuration type
+   * @returns {object | null} The configuration object, or null if not found
+   * @throws {TypeError} If SettingsClass is not a function/constructor
+   * 
+   * @example
+   * const config = PluginImplementationRegistry.getPluginConfiguration(JwtGraftocodePluginSettings)
+   * if (config) {
+   *   console.log(config.username)
+   * }
+   */
+  static getPluginConfiguration(SettingsClass) {
+    if (typeof SettingsClass !== "function") {
+      throw new TypeError(`${SettingsClass?.name || "SettingsClass"} is not a function. Only classes/constructors are allowed.`);
+    }
+    const config = PluginImplementationRegistry.#pluginConfigurations.get(SettingsClass);
+    return config || null;
+  }
+  /**
+   * Checks whether a configuration has been registered for the specified plugin type.
+   * 
+   * @param {Function} SettingsClass - The settings class type to check
+   * @returns {boolean} True if a configuration entry exists, false otherwise
+   * @throws {TypeError} If SettingsClass is not a function/constructor
+   * 
+   * @example
+   * if (PluginImplementationRegistry.isPluginConfigurationAvailable(JwtGraftocodePluginSettings)) {
+   *   // Configuration exists
+   * }
+   */
+  static isPluginConfigurationAvailable(SettingsClass) {
+    if (typeof SettingsClass !== "function") {
+      throw new TypeError(`${SettingsClass?.name || "SettingsClass"} is not a function. Only classes/constructors are allowed.`);
+    }
+    return PluginImplementationRegistry.#pluginConfigurations.has(SettingsClass);
+  }
+  /**
+   * Registers a new plugin implementation of the specified type and stores it as a singleton instance.
+   * 
+   * @param {Function} InterfaceClass - The interface or base class that the plugin implementation inherits or implements
+   * @param {Function} ImplementationClass - The concrete plugin type to register
+   * @param {...any} constructorArgs - Optional arguments to pass to the constructor
+   * @throws {TypeError} If InterfaceClass is not a function/constructor
+   * @throws {TypeError} If ImplementationClass is not a function/constructor
+   * 
+   * @example
+   * PluginImplementationRegistry.registerPluginSingletonImplementation(IJwtAuthorize, JwtAuthorizeImpl)
+   * // Or with constructor arguments:
+   * PluginImplementationRegistry.registerPluginSingletonImplementation(IJwtAuthorize, JwtAuthorizeImpl, 'arg1', 'arg2')
+   */
+  static registerPluginSingletonImplementation(InterfaceClass, ImplementationClass, ...constructorArgs) {
+    if (typeof InterfaceClass !== "function") {
+      throw new TypeError(`${InterfaceClass?.name || "InterfaceClass"} is not a function. Only classes/constructors are allowed.`);
+    }
+    if (typeof ImplementationClass !== "function") {
+      throw new TypeError(`${ImplementationClass?.name || "ImplementationClass"} is not a function. Only classes/constructors are allowed.`);
+    }
+    try {
+      const instance = constructorArgs.length > 0 ? new ImplementationClass(...constructorArgs) : new ImplementationClass();
+      if (!instance) {
+        throw new Error(`Could not create instance of ${ImplementationClass.name || "implementation"}.`);
+      }
+      PluginImplementationRegistry.#singletonImplementations.set(ImplementationClass, instance);
+    } catch (error) {
+      throw new Error(`Failed to register singleton implementation: ${error.message}`);
+    }
+  }
+  /**
+   * Resolves a registered plugin implementation by its type.
+   * 
+   * @param {Function} ImplementationClass - The type of the plugin implementation to resolve
+   * @returns {object} The registered plugin instance
+   * @throws {Error} If no plugin instance of the specified type is found in the registry
+   * @throws {TypeError} If ImplementationClass is not a function/constructor
+   * 
+   * @example
+   * const plugin = PluginImplementationRegistry.resolvePluginSingletonImplementation(JwtAuthorizeImpl)
+   */
+  static resolvePluginSingletonImplementation(ImplementationClass) {
+    if (typeof ImplementationClass !== "function") {
+      throw new TypeError(`${ImplementationClass?.name || "ImplementationClass"} is not a function. Only classes/constructors are allowed.`);
+    }
+    const instance = PluginImplementationRegistry.#singletonImplementations.get(ImplementationClass);
+    if (!instance) {
+      throw new Error(`No singleton implementation registered for ${ImplementationClass.name || "implementation"}.`);
+    }
+    return instance;
+  }
+  /**
+   * Resets the entire plugin implementation registry to its initial state.
+   * Clears all registered plugins and configurations.
+   * Useful for testing or reconfiguration scenarios.
+   * 
+   * @example
+   * PluginImplementationRegistry.reset()
+   * // Can now register new plugins
+   */
+  static reset() {
+    PluginImplementationRegistry.#transientImplementations.clear();
+    PluginImplementationRegistry.#singletonImplementations.clear();
+    PluginImplementationRegistry.#pluginConfigurations.clear();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginImplementationRegistry
+});

package/dist/plugins/PluginPayloadBuilder.cjs

@@ -0,0 +1,76 @@
+"use strict";
+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 PluginPayloadBuilder_exports = {};
+__export(PluginPayloadBuilder_exports, {
+  PluginPayloadBuilder: () => PluginPayloadBuilder
+});
+module.exports = __toCommonJS(PluginPayloadBuilder_exports);
+var import_PluginRegistry = require("./PluginRegistry.cjs");
+class PluginPayloadBuilder {
+  /**
+   * Builds the plugin payload for a specific runtime context.
+   * Retrieves the sending plugin registered for the given runtime context ID,
+   * executes it, and returns the serialized result.
+   * 
+   * @param {string} runtimeContextId - The UUID of the runtime context
+   * @returns {string} JSON-serialized plugin payload
+   * @throws {Error} If no plugin is found for the runtime context
+   * @throws {Error} If plugin execution fails
+   * 
+   * @example
+   * const payload = PluginPayloadBuilder.buildPluginsPayload(runtimeContextId)
+   * // Returns: '{"token":"abc123","timestamp":1234567890}'
+   */
+  static buildPluginsPayload(runtimeContextId) {
+    const result = import_PluginRegistry.PluginRegistry.tryGetSendingPlugin(runtimeContextId);
+    if (result.success && result.plugin) {
+      try {
+        const payload = result.plugin.execute();
+        if (!result?.plugin?.pluginId) {
+          throw new Error("Plugin execution failed pluginId is not defined");
+        }
+        const objectPayload = { [result?.plugin?.pluginId]: payload };
+        return PluginPayloadBuilder.serializeObject(objectPayload);
+      } catch (error) {
+        throw new Error(`Plugin execution failed for runtime context ${runtimeContextId}: ${error.message}`);
+      }
+    }
+    throw new Error(`Plugin for runtime context ${runtimeContextId} not found.`);
+  }
+  /**
+   * Serializes an object to JSON string.
+   * 
+   * @param {object} payload - The payload object to serialize
+   * @returns {string} JSON-serialized string
+   * @throws {Error} If serialization fails
+   * 
+   * @private
+   */
+  static serializeObject(payload) {
+    try {
+      return JSON.stringify(payload);
+    } catch (error) {
+      throw new Error(`Failed to serialize plugin payload: ${error.message}`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginPayloadBuilder
+});

package/dist/plugins/PluginRegistry.cjs

@@ -0,0 +1,255 @@
+"use strict";
+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 PluginRegistry_exports = {};
+__export(PluginRegistry_exports, {
+  PluginRegistry: () => PluginRegistry
+});
+module.exports = __toCommonJS(PluginRegistry_exports);
+class PluginRegistry {
+  // Private static fields (ES2022 private fields)
+  /** @type {Map<string, object>} Map of runtime context IDs to sending plugin instances */
+  static #sendingPlugins = /* @__PURE__ */ new Map();
+  /** @type {Map<string, object> | null} Immutable snapshot of sending plugins after freeze */
+  static #sendingSnapshot = null;
+  /** @type {SendingPluginCacheEntry | null} Hot cache for last accessed plugin */
+  static #sendingCache = null;
+  /** @type {object | null} The receiving plugin instance */
+  static #receivingPlugin = null;
+  /** @type {Function | null} The receiving plugin constructor/class */
+  static #receivingPluginType = null;
+  /** @type {string[] | null} Array of registered runtime context IDs for fast lookup */
+  static #registeredKeys = null;
+  /** @type {boolean} Whether to create new plugin instances on each resolve */
+  static #useTransientPlugins = false;
+  /** @type {boolean} Whether the registry has been frozen */
+  static #isFrozen = false;
+  /**
+   * Checks if a receiving plugin has been registered
+   * @returns {boolean} True if a receiving plugin exists
+   */
+  static get hasReceivingPlugin() {
+    return PluginRegistry.#receivingPlugin !== null;
+  }
+  /**
+   * Registers a sending plugin implementation for a specific runtime context.
+   * The plugin is stored as a singleton instance and can later be resolved using the runtime context ID.
+   * 
+   * @param {string} runtimeContextId - The UUID of the runtime context
+   * @param {object} plugin - Plugin instance that implements ICommunitySendingPlugin interface
+   * @throws {Error} If registry is already frozen
+   * @throws {TypeError} If plugin doesn't have required execute method
+   * 
+   * @example
+   * const plugin = new JwtPlugin('token123')
+   * PluginRegistry.registerSendingPlugin(runtimeCtx.runtimeContextId, plugin)
+   */
+  static registerSendingPlugin(runtimeContextId, plugin) {
+    if (PluginRegistry.#isFrozen) {
+      throw new Error("Cannot register plugins after registry has been frozen. Call reset() first.");
+    }
+    if (!plugin || typeof plugin.execute !== "function") {
+      throw new TypeError("Plugin must have an execute() method");
+    }
+    if (!plugin.pluginId) {
+      throw new TypeError("Plugin must have a pluginId property");
+    }
+    if (!runtimeContextId || typeof runtimeContextId !== "string") {
+      throw new TypeError("runtimeContextId must be a non-empty string");
+    }
+    PluginRegistry.#sendingPlugins.set(runtimeContextId, plugin);
+    PluginRegistry.#sendingCache = {
+      key: runtimeContextId,
+      value: plugin,
+      hasValue: true,
+      type: plugin.constructor
+    };
+  }
+  /**
+   * Registers a receiving plugin implementation.
+   * The plugin is stored as a singleton instance and executed on the receiving side.
+   * Only one receiving plugin can be registered per application.
+   * 
+   * @param {object} plugin - Plugin instance that implements ICommunityReceivingPlugin interface
+   * @throws {Error} If a receiving plugin is already registered
+   * @throws {Error} If registry is already frozen
+   * @throws {TypeError} If plugin doesn't have required execute method
+   * 
+   * @example
+   * const plugin = new ValidationPlugin()
+   * PluginRegistry.registerReceivingPlugin(plugin)
+   */
+  static registerReceivingPlugin(plugin) {
+    if (PluginRegistry.#isFrozen) {
+      throw new Error("Cannot register plugins after registry has been frozen. Call reset() first.");
+    }
+    if (PluginRegistry.#receivingPlugin !== null) {
+      throw new Error("A receiving plugin is already registered. Only one receiving plugin is allowed.");
+    }
+    if (!plugin || typeof plugin.execute !== "function") {
+      throw new TypeError("Plugin must have an execute(commandPayload, executionTarget) method");
+    }
+    if (!plugin.pluginId) {
+      throw new TypeError("Plugin must have a pluginId property");
+    }
+    PluginRegistry.#receivingPlugin = plugin;
+    PluginRegistry.#receivingPluginType = plugin.constructor;
+  }
+  /**
+   * Resolves and returns the registered receiving plugin instance.
+   * If transient mode is enabled, creates a new instance.
+   * 
+   * @returns {object} The receiving plugin instance
+   * @throws {Error} If no receiving plugin has been registered
+   * 
+   * @example
+   * const plugin = PluginRegistry.resolveReceivingPlugin()
+   * const result = plugin.execute(payload, target)
+   */
+  static resolveReceivingPlugin() {
+    if (PluginRegistry.#useTransientPlugins && PluginRegistry.#receivingPluginType) {
+      return new PluginRegistry.#receivingPluginType();
+    }
+    if (PluginRegistry.#receivingPlugin === null) {
+      throw new Error("No receiving plugin has been registered");
+    }
+    return PluginRegistry.#receivingPlugin;
+  }
+  /**
+   * Attempts to retrieve a sending plugin registered for the specified runtime context.
+   * First checks a single-entry hot cache for the last accessed plugin,
+   * and if not found, falls back to the map of registered plugins.
+   * On a successful map lookup, the cache is updated with the resolved entry
+   * for faster access in subsequent calls.
+   * 
+   * @param {string} runtimeContextId - The identifier of the runtime context
+   * @returns {{success: boolean, plugin: object | null}} Object with success flag and plugin instance
+   * 
+   * @example
+   * const result = PluginRegistry.tryGetSendingPlugin(runtimeContextId)
+   * if (result.success) {
+   *   const payload = result.plugin.execute()
+   * }
+   */
+  static tryGetSendingPlugin(runtimeContextId) {
+    const localCache = PluginRegistry.#sendingCache;
+    if (PluginRegistry.#useTransientPlugins && localCache && localCache.hasValue && localCache.key === runtimeContextId) {
+      return {
+        success: true,
+        plugin: new localCache.type()
+      };
+    }
+    if (localCache && localCache.hasValue && localCache.key === runtimeContextId) {
+      return {
+        success: true,
+        plugin: localCache.value
+      };
+    }
+    const snapshot = PluginRegistry.#sendingSnapshot;
+    if (snapshot && snapshot.has(runtimeContextId)) {
+      const plugin = snapshot.get(runtimeContextId);
+      PluginRegistry.#sendingCache = {
+        key: runtimeContextId,
+        value: plugin,
+        hasValue: true,
+        type: plugin.constructor
+      };
+      return {
+        success: true,
+        plugin
+      };
+    }
+    return {
+      success: false,
+      plugin: null
+    };
+  }
+  /**
+   * Checks whether any plugins have been registered for given RuntimeContext ID.
+   * 
+   * @param {string} runtimeContextId - The identifier of the runtime context
+   * @returns {boolean} True if at least one plugin is registered for the runtime context
+   * 
+   * @example
+   * if (PluginRegistry.arePluginsRegisteredForRuntime(runtimeContextId)) {
+   *   // Build and wrap command with plugin payload
+   * }
+   */
+  static arePluginsRegisteredForRuntime(runtimeContextId) {
+    const keys = PluginRegistry.#registeredKeys;
+    if (!keys || keys.length === 0) {
+      return false;
+    }
+    return keys.includes(runtimeContextId);
+  }
+  /**
+   * Finalizes the plugin registration phase by creating a compact snapshot of all registered keys.
+   * This snapshot is stored to allow extremely fast lookups on the hot path.
+   * After calling freeze(), no more plugins can be registered unless reset() is called.
+   * 
+   * @param {boolean} useTransientPlugins - If true, creates new plugin instances on each resolve
+   * 
+   * @example
+   * // Register all plugins
+   * PluginRegistry.registerSendingPlugin(rtmCtx.runtimeContextId, plugin1)
+   * PluginRegistry.registerSendingPlugin(rtmCtx2.runtimeContextId, plugin2)
+   * 
+   * // Freeze the registry
+   * PluginRegistry.freeze()
+   * 
+   * // Or freeze with transient mode
+   * PluginRegistry.freeze(true)
+   */
+  static freeze(useTransientPlugins = false) {
+    PluginRegistry.#useTransientPlugins = useTransientPlugins;
+    PluginRegistry.#registeredKeys = Array.from(PluginRegistry.#sendingPlugins.keys());
+    PluginRegistry.#sendingSnapshot = new Map(PluginRegistry.#sendingPlugins);
+    PluginRegistry.#sendingPlugins.clear();
+    PluginRegistry.#isFrozen = true;
+  }
+  /**
+   * Resets the entire plugin registry to its initial state.
+   * Clears all registered plugins and unfreezes the registry.
+   * Useful for testing or reconfiguration scenarios.
+   * 
+   * @example
+   * PluginRegistry.reset()
+   * // Can now register new plugins
+   */
+  static reset() {
+    PluginRegistry.#sendingPlugins.clear();
+    PluginRegistry.#sendingSnapshot = null;
+    PluginRegistry.#sendingCache = null;
+    PluginRegistry.#receivingPlugin = null;
+    PluginRegistry.#receivingPluginType = null;
+    PluginRegistry.#registeredKeys = null;
+    PluginRegistry.#useTransientPlugins = false;
+    PluginRegistry.#isFrozen = false;
+  }
+  /**
+   * Checks if the registry has been frozen
+   * @returns {boolean} True if the registry is frozen
+   */
+  static get isFrozen() {
+    return PluginRegistry.#isFrozen;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginRegistry
+});

package/dist/plugins/index.cjs

@@ -0,0 +1,51 @@
+"use strict";
+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 plugins_exports = {};
+__export(plugins_exports, {
+  BasePluginSettings: () => import_BasePluginSettings.BasePluginSettings,
+  ICommunityPlugin: () => import_ICommunityPlugin.ICommunityPlugin,
+  ICommunityReceivingPlugin: () => import_ICommunityReceivingPlugin.ICommunityReceivingPlugin,
+  ICommunitySendingPlugin: () => import_ICommunitySendingPlugin.ICommunitySendingPlugin,
+  JwtGraftocodePluginSettings: () => import_JwtGraftocodePluginSettings.JwtGraftocodePluginSettings,
+  PluginImplementationRegistry: () => import_PluginImplementationRegistry.PluginImplementationRegistry,
+  PluginLangType: () => import_BasePluginSettings.PluginLangType,
+  PluginPayloadBuilder: () => import_PluginPayloadBuilder.PluginPayloadBuilder,
+  PluginRegistry: () => import_PluginRegistry.PluginRegistry
+});
+module.exports = __toCommonJS(plugins_exports);
+var import_PluginRegistry = require("./PluginRegistry.cjs");
+var import_PluginPayloadBuilder = require("./PluginPayloadBuilder.cjs");
+var import_ICommunityPlugin = require("./interfaces/ICommunityPlugin.cjs");
+var import_ICommunitySendingPlugin = require("./interfaces/ICommunitySendingPlugin.cjs");
+var import_ICommunityReceivingPlugin = require("./interfaces/ICommunityReceivingPlugin.cjs");
+var import_PluginImplementationRegistry = require("./PluginImplementationRegistry.cjs");
+var import_BasePluginSettings = require("./settings/BasePluginSettings.cjs");
+var import_JwtGraftocodePluginSettings = require("./settings/JwtGraftocodePluginSettings.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BasePluginSettings,
+  ICommunityPlugin,
+  ICommunityReceivingPlugin,
+  ICommunitySendingPlugin,
+  JwtGraftocodePluginSettings,
+  PluginImplementationRegistry,
+  PluginLangType,
+  PluginPayloadBuilder,
+  PluginRegistry
+});

package/dist/plugins/interfaces/ICommunityPlugin.cjs

@@ -0,0 +1,44 @@
+"use strict";
+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 ICommunityPlugin_exports = {};
+__export(ICommunityPlugin_exports, {
+  ICommunityPlugin: () => ICommunityPlugin
+});
+module.exports = __toCommonJS(ICommunityPlugin_exports);
+class ICommunityPlugin {
+  /**
+   * Unique identifier for the plugin.
+   * This should be a string that uniquely identifies the plugin across the system.
+   * @type {string}
+   */
+  pluginId;
+  /**
+   * Creates an instance of ICommunityPlugin
+   * This is a base class and should not be instantiated directly.
+   */
+  constructor() {
+    if (new.target === ICommunityPlugin) {
+      throw new TypeError("Cannot construct ICommunityPlugin instances directly");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ICommunityPlugin
+});