@decaf-ts/integrations 0.3.12 → 0.4.1-0

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

@@ -0,0 +1,192 @@
+/**
+ * @module integrations/plugins/superset/installer
+ * @summary Superset dashboard embed plugin installer.
+ * @description Implements `DashboardEmbedPlugin` for Superset using a
+ * patch-and-build strategy. Decaf holds patch scripts that modify Superset's
+ * internal embedded frontend and SDK source files to add a `switchDashboard`
+ * method. `install` materializes the scripts, clones/uses Superset source,
+ * applies patches, and builds (SDK + frontend + optionally Docker image).
+ *
+ * The same `DashboardEmbedPlugin` API as Kibana is exposed. `sendSwitchDashboardMessage`
+ * delegates to `target.switchDashboard(dashboardId, guestToken)` (the Superset
+ * SDK handle) instead of `postMessage`.
+ */
+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 as sendShared, } from "./../contract.js";
+import { SUPERSET_APP_ID, SUPERSET_PLUGIN_ID, SUPERSET_PLUGIN_VERSION, buildSupersetManifest, } from "./manifest.js";
+import { supersetPatchFiles } from "./templates.js";
+/** Default Superset base path when none is provided. */
+export const SUPERSET_DEFAULT_BASE_PATH = "superset";
+/**
+ * Build the Superset embedded URL.
+ *
+ * For Superset, the `dashboardId` field in `EmbedUrlOptions` is the
+ * embedded-configuration UUID used in `/embedded/:uuid`.
+ *
+ * @example
+ *   buildSupersetEmbedUrl({ host: "superset.example.com", dashboardId: "abc-uuid", parentOrigin: "https://app.example.com" })
+ *   // => "//superset.example.com/superset/embedded/abc-uuid?parentOrigin=https%3A%2F%2Fapp.example.com"
+ */
+export function buildSupersetEmbedUrl(options) {
+    const basePath = options.basePath ?? SUPERSET_DEFAULT_BASE_PATH;
+    const params = new URLSearchParams();
+    params.set("parentOrigin", options.parentOrigin);
+    if (options.view?.timeRange) {
+        params.set("timeRange", JSON.stringify(options.view.timeRange));
+    }
+    return `//${options.host}/${basePath}/embedded/${options.dashboardId}?${params.toString()}`;
+}
+/**
+ * @class SupersetDashboardEmbedPlugin
+ * @summary Superset implementation of the `DashboardEmbedPlugin` contract.
+ * @description Org-agnostic multi-tenant dashboard embed plugin for Superset
+ * using a patch-and-build strategy. Same API as `KibanaDashboardEmbedPlugin`.
+ */
+export class SupersetDashboardEmbedPlugin {
+    constructor(targetVersion = "superset") {
+        this.descriptor = {
+            id: SUPERSET_PLUGIN_ID,
+            appId: SUPERSET_APP_ID,
+            version: SUPERSET_PLUGIN_VERSION,
+            targetVersion,
+            tool: "superset",
+        };
+    }
+    manifest(targetVersion = this.descriptor.targetVersion) {
+        return buildSupersetManifest(targetVersion);
+    }
+    buildEmbedUrl(options) {
+        return buildSupersetEmbedUrl(options);
+    }
+    createSwitchDashboardMessage(payload) {
+        return createSwitchDashboardMessage(payload);
+    }
+    sendSwitchDashboardMessage(target, payload, targetOrigin) {
+        sendShared(target, payload, targetOrigin);
+    }
+    /**
+     * Materialize the patch and build scripts into `targetPath/`, and when
+     * `build` is true, clone/use Superset source, apply patches, and build
+     * (SDK + frontend + optionally Docker image).
+     *
+     * Unlike Kibana (which generates plugin source), Superset's "plugin" is a
+     * patch-and-build strategy: Decaf holds scripts that modify Superset's
+     * existing internal source files.
+     */
+    async install(options) {
+        const ctx = options.context;
+        if (ctx) {
+            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, SUPERSET_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 = supersetPatchFiles();
+        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");
+            if (file.executable) {
+                fs.chmodSync(fullPath, 0o755);
+            }
+            written.push(file.path);
+        }
+        let built = false;
+        let buildOutput;
+        if (options.build) {
+            const supersetRoot = await this.resolveSupersetRoot(pluginDir, options);
+            const result = await this.runPatchAndBuild(pluginDir, supersetRoot, options).catch((err) => ({
+                ok: false,
+                output: err.message,
+            }));
+            built = result.ok;
+            buildOutput = result.output;
+        }
+        return {
+            pluginPath: pluginDir,
+            descriptor: { ...this.descriptor, targetVersion },
+            files: written,
+            built,
+            buildOutput,
+        };
+    }
+    /**
+     * Resolve the Superset source root: use an existing checkout or clone via git.
+     */
+    async resolveSupersetRoot(pluginDir, options) {
+        if (options.supersetSourcePath) {
+            const resolved = path.resolve(options.supersetSourcePath);
+            if (!fs.existsSync(path.join(resolved, "superset-frontend", "src", "embedded", "index.tsx"))) {
+                throw new InternalError(`Superset source not found at: ${resolved} (missing superset-frontend/src/embedded/index.tsx)`);
+            }
+            return resolved;
+        }
+        const gitUrl = options.supersetGitUrl ?? "https://github.com/apache/superset.git";
+        const gitRef = options.supersetGitRef ?? options.targetVersion ?? "6.1.0";
+        const cloneDir = path.join(pluginDir, ".superset-source");
+        if (fs.existsSync(cloneDir)) {
+            fs.rmSync(cloneDir, { recursive: true, force: true });
+        }
+        await this.runCommand("git", ["clone", "--depth", "1", "--branch", gitRef, gitUrl, cloneDir], pluginDir);
+        return cloneDir;
+    }
+    /**
+     * Apply patches, verify, and build (SDK + frontend + optionally Docker).
+     */
+    async runPatchAndBuild(pluginDir, supersetRoot, options) {
+        const outputs = [];
+        // 1. Apply patch
+        const patchResult = await this.runCommand("python3", [path.join(pluginDir, "patches", "apply_superset_6_1_patch.py"), supersetRoot], pluginDir);
+        outputs.push(patchResult);
+        // 2. Verify patch
+        const verifyResult = await this.runCommand(path.join(pluginDir, "patches", "verify_patch.sh"), [supersetRoot], pluginDir);
+        outputs.push(verifyResult);
+        // 3. Build (Docker image or SDK + frontend)
+        if (options.dockerImageTag) {
+            const dockerResult = await this.runCommand(path.join(pluginDir, "build", "build-docker-image.sh"), [supersetRoot, options.dockerImageTag], pluginDir);
+            outputs.push(dockerResult);
+        }
+        else {
+            const sdkResult = await this.runCommand(path.join(pluginDir, "build", "build-sdk.sh"), [supersetRoot], pluginDir);
+            outputs.push(sdkResult);
+            const frontendResult = await this.runCommand(path.join(pluginDir, "build", "build-superset-frontend.sh"), [supersetRoot], pluginDir);
+            outputs.push(frontendResult);
+        }
+        return { ok: true, output: outputs.join("\n") };
+    }
+    /**
+     * Run a command and capture stdout+stderr.
+     */
+    runCommand(cmd, args, cwd) {
+        return new Promise((resolve, reject) => {
+            execFile(cmd, args, { cwd, timeout: 600000 }, (error, stdout, stderr) => {
+                const output = `${stdout ?? ""}${stderr ?? ""}`.trim();
+                if (error) {
+                    reject(new Error(output || error.message));
+                    return;
+                }
+                resolve(output);
+            });
+        });
+    }
+}
+/** Default singleton instance. */
+export const supersetDashboardEmbedPlugin = new SupersetDashboardEmbedPlugin();
+/** Factory accepting a target Superset version. */
+export function createSupersetDashboardEmbedPlugin(targetVersion) {
+    return new SupersetDashboardEmbedPlugin(targetVersion);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"installer.js","sourceRoot":"","sources":["../../../../src/plugins/superset/installer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/plugins/superset/installer\n * @summary Superset dashboard embed plugin installer.\n * @description Implements `DashboardEmbedPlugin` for Superset using a\n * patch-and-build strategy. Decaf holds patch scripts that modify Superset's\n * internal embedded frontend and SDK source files to add a `switchDashboard`\n * method. `install` materializes the scripts, clones/uses Superset source,\n * applies patches, and builds (SDK + frontend + optionally Docker image).\n *\n * The same `DashboardEmbedPlugin` API as Kibana is exposed. `sendSwitchDashboardMessage`\n * delegates to `target.switchDashboard(dashboardId, guestToken)` (the Superset\n * SDK handle) instead of `postMessage`.\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 as sendShared,\n  type DashboardEmbedPlugin,\n  type DashboardEmbedPluginDescriptor,\n  type EmbedMessageTarget,\n  type EmbedUrlOptions,\n  type PluginInstallOptions,\n  type PluginInstallResult,\n  type SwitchDashboardPayload,\n  type SwitchDashboardMessage,\n} from \"../contract\";\nimport {\n  SUPERSET_APP_ID,\n  SUPERSET_PLUGIN_ID,\n  SUPERSET_PLUGIN_VERSION,\n  buildSupersetManifest,\n} from \"./manifest\";\nimport { supersetPatchFiles } from \"./templates\";\n\n/** Default Superset base path when none is provided. */\nexport const SUPERSET_DEFAULT_BASE_PATH = \"superset\";\n\n/**\n * Extension of `PluginInstallOptions` for Superset-specific build configuration.\n */\nexport interface SupersetInstallOptions extends PluginInstallOptions {\n  /** Path to an existing Superset source checkout. If absent, the installer clones via git. */\n  supersetSourcePath?: string;\n  /** Git URL to clone Superset from (used when `supersetSourcePath` is absent). */\n  supersetGitUrl?: string;\n  /** Git ref/branch/tag to checkout after cloning. */\n  supersetGitRef?: string;\n  /** Docker image tag to build (when provided, builds a Docker image instead of just SDK+frontend). */\n  dockerImageTag?: string;\n}\n\n/**\n * Build the Superset embedded URL.\n *\n * For Superset, the `dashboardId` field in `EmbedUrlOptions` is the\n * embedded-configuration UUID used in `/embedded/:uuid`.\n *\n * @example\n *   buildSupersetEmbedUrl({ host: \"superset.example.com\", dashboardId: \"abc-uuid\", parentOrigin: \"https://app.example.com\" })\n *   // => \"//superset.example.com/superset/embedded/abc-uuid?parentOrigin=https%3A%2F%2Fapp.example.com\"\n */\nexport function buildSupersetEmbedUrl(options: EmbedUrlOptions): string {\n  const basePath = options.basePath ?? SUPERSET_DEFAULT_BASE_PATH;\n  const params = new URLSearchParams();\n  params.set(\"parentOrigin\", options.parentOrigin);\n  if (options.view?.timeRange) {\n    params.set(\"timeRange\", JSON.stringify(options.view.timeRange));\n  }\n  return `//${options.host}/${basePath}/embedded/${options.dashboardId}?${params.toString()}`;\n}\n\n/**\n * @class SupersetDashboardEmbedPlugin\n * @summary Superset implementation of the `DashboardEmbedPlugin` contract.\n * @description Org-agnostic multi-tenant dashboard embed plugin for Superset\n * using a patch-and-build strategy. Same API as `KibanaDashboardEmbedPlugin`.\n */\nexport class SupersetDashboardEmbedPlugin implements DashboardEmbedPlugin {\n  public readonly descriptor: DashboardEmbedPluginDescriptor;\n\n  public constructor(targetVersion: string = \"superset\") {\n    this.descriptor = {\n      id: SUPERSET_PLUGIN_ID,\n      appId: SUPERSET_APP_ID,\n      version: SUPERSET_PLUGIN_VERSION,\n      targetVersion,\n      tool: \"superset\",\n    };\n  }\n\n  public manifest(targetVersion: string = this.descriptor.targetVersion): Record<string, unknown> {\n    return buildSupersetManifest(targetVersion) as unknown as Record<string, unknown>;\n  }\n\n  public buildEmbedUrl(options: EmbedUrlOptions): string {\n    return buildSupersetEmbedUrl(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    sendShared(target, payload, targetOrigin);\n  }\n\n  /**\n   * Materialize the patch and build scripts into `targetPath/`, and when\n   * `build` is true, clone/use Superset source, apply patches, and build\n   * (SDK + frontend + optionally Docker image).\n   *\n   * Unlike Kibana (which generates plugin source), Superset's \"plugin\" is a\n   * patch-and-build strategy: Decaf holds scripts that modify Superset's\n   * existing internal source files.\n   */\n  public async install(\n    options: SupersetInstallOptions\n  ): Promise<PluginInstallResult> {\n    const ctx = options.context as MaybeContextualArg<any> | undefined;\n    if (ctx) {\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      SUPERSET_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 = supersetPatchFiles();\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      if (file.executable) {\n        fs.chmodSync(fullPath, 0o755);\n      }\n      written.push(file.path);\n    }\n\n    let built = false;\n    let buildOutput: string | undefined;\n\n    if (options.build) {\n      const supersetRoot = await this.resolveSupersetRoot(pluginDir, options);\n      const result = await this.runPatchAndBuild(\n        pluginDir,\n        supersetRoot,\n        options\n      ).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   * Resolve the Superset source root: use an existing checkout or clone via git.\n   */\n  protected async resolveSupersetRoot(\n    pluginDir: string,\n    options: SupersetInstallOptions\n  ): Promise<string> {\n    if (options.supersetSourcePath) {\n      const resolved = path.resolve(options.supersetSourcePath);\n      if (!fs.existsSync(path.join(resolved, \"superset-frontend\", \"src\", \"embedded\", \"index.tsx\"))) {\n        throw new InternalError(\n          `Superset source not found at: ${resolved} (missing superset-frontend/src/embedded/index.tsx)`\n        );\n      }\n      return resolved;\n    }\n\n    const gitUrl = options.supersetGitUrl ?? \"https://github.com/apache/superset.git\";\n    const gitRef = options.supersetGitRef ?? options.targetVersion ?? \"6.1.0\";\n    const cloneDir = path.join(pluginDir, \".superset-source\");\n\n    if (fs.existsSync(cloneDir)) {\n      fs.rmSync(cloneDir, { recursive: true, force: true });\n    }\n\n    await this.runCommand(\"git\", [\"clone\", \"--depth\", \"1\", \"--branch\", gitRef, gitUrl, cloneDir], pluginDir);\n    return cloneDir;\n  }\n\n  /**\n   * Apply patches, verify, and build (SDK + frontend + optionally Docker).\n   */\n  protected async runPatchAndBuild(\n    pluginDir: string,\n    supersetRoot: string,\n    options: SupersetInstallOptions\n  ): Promise<{ ok: boolean; output: string }> {\n    const outputs: string[] = [];\n\n    // 1. Apply patch\n    const patchResult = await this.runCommand(\n      \"python3\",\n      [path.join(pluginDir, \"patches\", \"apply_superset_6_1_patch.py\"), supersetRoot],\n      pluginDir\n    );\n    outputs.push(patchResult);\n\n    // 2. Verify patch\n    const verifyResult = await this.runCommand(\n      path.join(pluginDir, \"patches\", \"verify_patch.sh\"),\n      [supersetRoot],\n      pluginDir\n    );\n    outputs.push(verifyResult);\n\n    // 3. Build (Docker image or SDK + frontend)\n    if (options.dockerImageTag) {\n      const dockerResult = await this.runCommand(\n        path.join(pluginDir, \"build\", \"build-docker-image.sh\"),\n        [supersetRoot, options.dockerImageTag],\n        pluginDir\n      );\n      outputs.push(dockerResult);\n    } else {\n      const sdkResult = await this.runCommand(\n        path.join(pluginDir, \"build\", \"build-sdk.sh\"),\n        [supersetRoot],\n        pluginDir\n      );\n      outputs.push(sdkResult);\n\n      const frontendResult = await this.runCommand(\n        path.join(pluginDir, \"build\", \"build-superset-frontend.sh\"),\n        [supersetRoot],\n        pluginDir\n      );\n      outputs.push(frontendResult);\n    }\n\n    return { ok: true, output: outputs.join(\"\\n\") };\n  }\n\n  /**\n   * Run a command and capture stdout+stderr.\n   */\n  protected runCommand(\n    cmd: string,\n    args: string[],\n    cwd: string\n  ): Promise<string> {\n    return new Promise((resolve, reject) => {\n      execFile(\n        cmd,\n        args,\n        { cwd, timeout: 600000 },\n        (error, stdout, stderr) => {\n          const output = `${stdout ?? \"\"}${stderr ?? \"\"}`.trim();\n          if (error) {\n            reject(new Error(output || error.message));\n            return;\n          }\n          resolve(output);\n        }\n      );\n    });\n  }\n}\n\n/** Default singleton instance. */\nexport const supersetDashboardEmbedPlugin = new SupersetDashboardEmbedPlugin();\n\n/** Factory accepting a target Superset version. */\nexport function createSupersetDashboardEmbedPlugin(\n  targetVersion: string\n): SupersetDashboardEmbedPlugin {\n  return new SupersetDashboardEmbedPlugin(targetVersion);\n}\n"]}

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

@@ -0,0 +1,30 @@
+/**
+ * @module integrations/plugins/superset/manifest
+ * @summary Superset embed plugin manifest builder (stub).
+ * @description Superset has no Kibana-style native plugin system. This builder
+ * returns a placeholder manifest describing the embed strategy. Detailed
+ * Superset support is deferred ("to be ignored for now").
+ */
+import { EMBED_MESSAGE_TYPE } from "./../contract.js";
+export const SUPERSET_PLUGIN_ID = "orgDashboardEmbedSuperset";
+export const SUPERSET_APP_ID = "org_dashboard_embed_superset";
+export const SUPERSET_PLUGIN_VERSION = "1.0.0";
+/**
+ * Build the placeholder Superset manifest for a target Superset version.
+ */
+export function buildSupersetManifest(targetVersion = "superset") {
+    return {
+        id: SUPERSET_PLUGIN_ID,
+        version: SUPERSET_PLUGIN_VERSION,
+        targetVersion,
+        tool: "superset",
+        server: true,
+        ui: true,
+        embedStrategy: "iframe",
+        status: "stub",
+        requiredPlugins: [],
+        optionalPlugins: [],
+    };
+}
+export { EMBED_MESSAGE_TYPE };
+//# sourceMappingURL=data:application/json;base64,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