@decaf-ts/integrations 0.4.0 → 0.4.1-1

package/lib/esm/plugins/kibana/installer.js

@@ -0,0 +1,140 @@
+/**
+ * @module integrations/plugins/kibana/installer
+ * @summary Kibana dashboard embed plugin installer.
+ * @description Implements `DashboardEmbedPlugin` for Kibana: builds the stable
+ * iframe embed URL, creates/sends switch-dashboard messages, and materializes
+ * the generated plugin source into a target directory (optionally building it).
+ *
+ * The plugin is org-agnostic: there is never space switching. The current
+ * Kibana space comes from the request/session/proxy context, not from the
+ * plugin, so the same plugin serves every org.
+ */
+import { InternalError } from "@decaf-ts/db-decorators";
+import { UnsupportedError } from "@decaf-ts/core";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFile } from "node:child_process";
+import { createSwitchDashboardMessage, sendSwitchDashboardMessage, } from "./../contract.js";
+import { KIBANA_APP_ID, KIBANA_PLUGIN_ID, KIBANA_PLUGIN_VERSION, buildKibanaManifest, } from "./manifest.js";
+import { kibanaPluginFiles } from "./templates.js";
+/** Default Kibana base path when none is provided. */
+export const KIBANA_DEFAULT_BASE_PATH = "kibana";
+/**
+ * Build the stable Kibana embed iframe URL.
+ *
+ * @example
+ *   buildKibanaEmbedUrl({ host: "ptp.host", dashboardId: "abc", parentOrigin: "https://app.example.com" })
+ *   // => "//ptp.host/kibana/app/org_dashboard_embed?dashboardId=abc&parentOrigin=https%3A%2F%2Fapp.example.com"
+ */
+export function buildKibanaEmbedUrl(options) {
+    const basePath = options.basePath ?? KIBANA_DEFAULT_BASE_PATH;
+    const params = new URLSearchParams();
+    params.set("dashboardId", options.dashboardId);
+    params.set("parentOrigin", options.parentOrigin);
+    if (options.view?.timeRange) {
+        params.set("timeRange", JSON.stringify(options.view.timeRange));
+    }
+    return `//${options.host}/${basePath}/app/${KIBANA_APP_ID}?${params.toString()}`;
+}
+/**
+ * @class KibanaDashboardEmbedPlugin
+ * @summary Kibana implementation of the `DashboardEmbedPlugin` contract.
+ * @description Org-agnostic multi-tenant dashboard embed plugin for Kibana.
+ */
+export class KibanaDashboardEmbedPlugin {
+    constructor(targetVersion = "kibana") {
+        this.descriptor = {
+            id: KIBANA_PLUGIN_ID,
+            appId: KIBANA_APP_ID,
+            version: KIBANA_PLUGIN_VERSION,
+            targetVersion,
+            tool: "kibana",
+        };
+    }
+    manifest(targetVersion = this.descriptor.targetVersion) {
+        return buildKibanaManifest(targetVersion);
+    }
+    buildEmbedUrl(options) {
+        return buildKibanaEmbedUrl(options);
+    }
+    createSwitchDashboardMessage(payload) {
+        return createSwitchDashboardMessage(payload);
+    }
+    sendSwitchDashboardMessage(target, payload, targetOrigin) {
+        sendSwitchDashboardMessage(target, payload, targetOrigin);
+    }
+    /**
+     * Materialize the generated Kibana plugin into `targetPath/org_dashboard_embed/`.
+     *
+     * Kibana plugins must be built within the Kibana repo against the exact
+     * Kibana version. When `build` is true, this attempts `yarn build` in the
+     * plugin directory (best-effort); real builds require the Kibana plugin
+     * helpers environment.
+     */
+    async install(options) {
+        const ctx = options.context;
+        if (ctx) {
+            // Context is accepted for traceability; no logging side-effect required here.
+            void ctx;
+        }
+        if (!options.targetPath || options.targetPath.trim().length === 0) {
+            throw new UnsupportedError("install targetPath is required");
+        }
+        const targetVersion = options.targetVersion ?? this.descriptor.targetVersion;
+        const pluginDir = path.resolve(options.targetPath, KIBANA_APP_ID);
+        if (fs.existsSync(pluginDir)) {
+            if (!options.overwrite) {
+                throw new InternalError(`Plugin directory already exists: ${pluginDir} (use overwrite: true)`);
+            }
+            fs.rmSync(pluginDir, { recursive: true, force: true });
+        }
+        const files = kibanaPluginFiles(targetVersion);
+        const written = [];
+        for (const file of files) {
+            const fullPath = path.join(pluginDir, file.path);
+            fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+            fs.writeFileSync(fullPath, file.content, "utf8");
+            written.push(file.path);
+        }
+        let built = false;
+        let buildOutput;
+        if (options.build) {
+            const result = await this.runBuild(pluginDir).catch((err) => ({
+                ok: false,
+                output: err.message,
+            }));
+            built = result.ok;
+            buildOutput = result.output;
+        }
+        return {
+            pluginPath: pluginDir,
+            descriptor: { ...this.descriptor, targetVersion },
+            files: written,
+            built,
+            buildOutput,
+        };
+    }
+    /**
+     * Best-effort `yarn build` in the plugin directory. Real builds require the
+     * Kibana plugin helpers environment; failures are captured, not thrown.
+     */
+    runBuild(pluginDir) {
+        return new Promise((resolve) => {
+            execFile("yarn", ["build"], { cwd: pluginDir, timeout: 120000 }, (error, stdout, stderr) => {
+                const output = `${stdout ?? ""}${stderr ?? ""}`.trim();
+                if (error) {
+                    resolve({ ok: false, output: output || error.message });
+                    return;
+                }
+                resolve({ ok: true, output });
+            });
+        });
+    }
+}
+/** Default singleton instance. */
+export const kibanaDashboardEmbedPlugin = new KibanaDashboardEmbedPlugin();
+/** Factory accepting a target Kibana version. */
+export function createKibanaDashboardEmbedPlugin(targetVersion) {
+    return new KibanaDashboardEmbedPlugin(targetVersion);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"installer.js","sourceRoot":"","sources":["../../../../src/plugins/kibana/installer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/plugins/kibana/installer\n * @summary Kibana dashboard embed plugin installer.\n * @description Implements `DashboardEmbedPlugin` for Kibana: builds the stable\n * iframe embed URL, creates/sends switch-dashboard messages, and materializes\n * the generated plugin source into a target directory (optionally building it).\n *\n * The plugin is org-agnostic: there is never space switching. The current\n * Kibana space comes from the request/session/proxy context, not from the\n * plugin, so the same plugin serves every org.\n */\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { UnsupportedError, MaybeContextualArg } from \"@decaf-ts/core\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport { execFile } from \"node:child_process\";\n\nimport {\n  createSwitchDashboardMessage,\n  sendSwitchDashboardMessage,\n  type DashboardEmbedPlugin,\n  type DashboardEmbedPluginDescriptor,\n  type EmbedUrlOptions,\n  type PluginInstallOptions,\n  type PluginInstallResult,\n  type SwitchDashboardPayload,\n  type SwitchDashboardMessage,\n  type EmbedMessageTarget,\n} from \"../contract\";\nimport {\n  KIBANA_APP_ID,\n  KIBANA_PLUGIN_ID,\n  KIBANA_PLUGIN_VERSION,\n  buildKibanaManifest,\n} from \"./manifest\";\nimport { kibanaPluginFiles } from \"./templates\";\n\n/** Default Kibana base path when none is provided. */\nexport const KIBANA_DEFAULT_BASE_PATH = \"kibana\";\n\n/**\n * Build the stable Kibana embed iframe URL.\n *\n * @example\n *   buildKibanaEmbedUrl({ host: \"ptp.host\", dashboardId: \"abc\", parentOrigin: \"https://app.example.com\" })\n *   // => \"//ptp.host/kibana/app/org_dashboard_embed?dashboardId=abc&parentOrigin=https%3A%2F%2Fapp.example.com\"\n */\nexport function buildKibanaEmbedUrl(options: EmbedUrlOptions): string {\n  const basePath = options.basePath ?? KIBANA_DEFAULT_BASE_PATH;\n  const params = new URLSearchParams();\n  params.set(\"dashboardId\", options.dashboardId);\n  params.set(\"parentOrigin\", options.parentOrigin);\n  if (options.view?.timeRange) {\n    params.set(\n      \"timeRange\",\n      JSON.stringify(options.view.timeRange)\n    );\n  }\n  return `//${options.host}/${basePath}/app/${KIBANA_APP_ID}?${params.toString()}`;\n}\n\n/**\n * @class KibanaDashboardEmbedPlugin\n * @summary Kibana implementation of the `DashboardEmbedPlugin` contract.\n * @description Org-agnostic multi-tenant dashboard embed plugin for Kibana.\n */\nexport class KibanaDashboardEmbedPlugin implements DashboardEmbedPlugin {\n  public readonly descriptor: DashboardEmbedPluginDescriptor;\n\n  public constructor(targetVersion: string = \"kibana\") {\n    this.descriptor = {\n      id: KIBANA_PLUGIN_ID,\n      appId: KIBANA_APP_ID,\n      version: KIBANA_PLUGIN_VERSION,\n      targetVersion,\n      tool: \"kibana\",\n    };\n  }\n\n  public manifest(targetVersion: string = this.descriptor.targetVersion): Record<string, unknown> {\n    return buildKibanaManifest(targetVersion) as unknown as Record<string, unknown>;\n  }\n\n  public buildEmbedUrl(options: EmbedUrlOptions): string {\n    return buildKibanaEmbedUrl(options);\n  }\n\n  public createSwitchDashboardMessage(\n    payload: SwitchDashboardPayload\n  ): SwitchDashboardMessage {\n    return createSwitchDashboardMessage(payload);\n  }\n\n  public sendSwitchDashboardMessage(\n    target: EmbedMessageTarget,\n    payload: SwitchDashboardPayload,\n    targetOrigin: string\n  ): void {\n    sendSwitchDashboardMessage(target, payload, targetOrigin);\n  }\n\n  /**\n   * Materialize the generated Kibana plugin into `targetPath/org_dashboard_embed/`.\n   *\n   * Kibana plugins must be built within the Kibana repo against the exact\n   * Kibana version. When `build` is true, this attempts `yarn build` in the\n   * plugin directory (best-effort); real builds require the Kibana plugin\n   * helpers environment.\n   */\n  public async install(\n    options: PluginInstallOptions\n  ): Promise<PluginInstallResult> {\n    const ctx = options.context as MaybeContextualArg<any> | undefined;\n    if (ctx) {\n      // Context is accepted for traceability; no logging side-effect required here.\n      void ctx;\n    }\n    if (!options.targetPath || options.targetPath.trim().length === 0) {\n      throw new UnsupportedError(\"install targetPath is required\");\n    }\n\n    const targetVersion = options.targetVersion ?? this.descriptor.targetVersion;\n    const pluginDir = path.resolve(\n      options.targetPath,\n      KIBANA_APP_ID\n    );\n\n    if (fs.existsSync(pluginDir)) {\n      if (!options.overwrite) {\n        throw new InternalError(\n          `Plugin directory already exists: ${pluginDir} (use overwrite: true)`\n        );\n      }\n      fs.rmSync(pluginDir, { recursive: true, force: true });\n    }\n\n    const files = kibanaPluginFiles(targetVersion);\n    const written: string[] = [];\n    for (const file of files) {\n      const fullPath = path.join(pluginDir, file.path);\n      fs.mkdirSync(path.dirname(fullPath), { recursive: true });\n      fs.writeFileSync(fullPath, file.content, \"utf8\");\n      written.push(file.path);\n    }\n\n    let built = false;\n    let buildOutput: string | undefined;\n    if (options.build) {\n      const result = await this.runBuild(pluginDir).catch((err: Error) => ({\n        ok: false as const,\n        output: err.message,\n      }));\n      built = result.ok;\n      buildOutput = result.output;\n    }\n\n    return {\n      pluginPath: pluginDir,\n      descriptor: { ...this.descriptor, targetVersion },\n      files: written,\n      built,\n      buildOutput,\n    };\n  }\n\n  /**\n   * Best-effort `yarn build` in the plugin directory. Real builds require the\n   * Kibana plugin helpers environment; failures are captured, not thrown.\n   */\n  protected runBuild(\n    pluginDir: string\n  ): Promise<{ ok: boolean; output: string }> {\n    return new Promise((resolve) => {\n      execFile(\n        \"yarn\",\n        [\"build\"],\n        { cwd: pluginDir, timeout: 120000 },\n        (error, stdout, stderr) => {\n          const output = `${stdout ?? \"\"}${stderr ?? \"\"}`.trim();\n          if (error) {\n            resolve({ ok: false, output: output || error.message });\n            return;\n          }\n          resolve({ ok: true, output });\n        }\n      );\n    });\n  }\n}\n\n/** Default singleton instance. */\nexport const kibanaDashboardEmbedPlugin = new KibanaDashboardEmbedPlugin();\n\n/** Factory accepting a target Kibana version. */\nexport function createKibanaDashboardEmbedPlugin(\n  targetVersion: string\n): KibanaDashboardEmbedPlugin {\n  return new KibanaDashboardEmbedPlugin(targetVersion);\n}\n"]}

package/lib/esm/plugins/kibana/manifest.js

@@ -0,0 +1,32 @@
+/**
+ * @module integrations/plugins/kibana/manifest
+ * @summary Kibana embed plugin manifest builder.
+ * @description Builds the `kibana.json` manifest for the org-agnostic
+ * `orgDashboardEmbed` plugin against a target Kibana version.
+ */
+import { EMBED_MESSAGE_TYPE } from "./../contract.js";
+export const KIBANA_PLUGIN_ID = "orgDashboardEmbed";
+export const KIBANA_APP_ID = "org_dashboard_embed";
+export const KIBANA_PLUGIN_VERSION = "1.0.0";
+/**
+ * Build the `kibana.json` manifest for a target Kibana version.
+ *
+ * @param targetVersion - Kibana version (defaults to "kibana").
+ */
+export function buildKibanaManifest(targetVersion = "kibana") {
+    return {
+        id: KIBANA_PLUGIN_ID,
+        version: KIBANA_PLUGIN_VERSION,
+        kibanaVersion: targetVersion,
+        server: true,
+        ui: true,
+        requiredPlugins: ["dashboard", "embeddable", "data"],
+        optionalPlugins: [],
+    };
+}
+/**
+ * Message type constants re-exported so the generated plugin templates can
+ * reference the same protocol identifiers as the host helpers.
+ */
+export { EMBED_MESSAGE_TYPE };
+//# sourceMappingURL=data:application/json;base64,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