@decaf-ts/integrations 0.3.12 → 0.4.1-0

package/lib/esm/nest/utils.js

@@ -1,64 +1,50 @@
 import { AuthorizationError } from "@decaf-ts/core";
+import { getTokenPayload } from "@decaf-ts/crypto/integration/services/jwt";
 export const DECAF_ADAPTER_OPTIONS = Symbol("DecafAdapterForOptions");
-export function getTokenPayload(jwt) {
-    try {
-        return JSON.parse(Buffer.from(jwt.split(".")[1] ?? "", "base64url").toString("utf8"));
-    }
-    catch {
-        return null;
-    }
-}
 export function extractKeycloakRoles(payload) {
     const roles = new Set();
     if (Array.isArray(payload?.realm_access?.roles)) {
-        for (const role of payload.realm_access.roles)
-            roles.add(role);
+        for (const role of payload.realm_access.roles) {
+            if (!role?.startsWith("namespace:"))
+                roles.add(role);
+        }
     }
     if (payload?.resource_access && typeof payload.resource_access === "object") {
         for (const client of Object.keys(payload.resource_access)) {
             for (const role of payload.resource_access[client]?.roles ?? []) {
-                roles.add(role);
+                if (!role?.startsWith("namespace:"))
+                    roles.add(role);
             }
         }
     }
     return [...roles];
 }
-/**
- * Extracts roles from the `resource_access` claim only, optionally excluding
- * specified client IDs (e.g. `"account"`).  Unlike {@link extractKeycloakRoles}
- * this does NOT include `realm_access.roles`.
- *
- * @param payload   The decoded JWT payload.
- * @param excluded  Client IDs to skip.  @default ["account"]
- */
-export function getClientRoles(payload, excluded = ["account"]) {
-    const resourceAccess = payload?.resource_access;
-    if (!resourceAccess || typeof resourceAccess !== "object")
-        return [];
-    const roles = new Set();
-    for (const [clientId, data] of Object.entries(resourceAccess)) {
-        if (excluded.includes(clientId))
-            continue;
-        if (Array.isArray(data?.roles)) {
-            for (const role of data.roles)
-                roles.add(role);
+export function extractKeycloakNamespaces(payload) {
+    const namespaces = new Set();
+    const rawNamespaces = payload?.namespaces ?? payload?.namespace;
+    if (Array.isArray(rawNamespaces)) {
+        for (const namespace of rawNamespaces) {
+            if (namespace)
+                namespaces.add(namespace);
         }
     }
-    return [...roles];
-}
-export function getUser(jwt) {
-    const payload = getTokenPayload(jwt);
-    if (!payload)
-        return undefined;
-    return {
-        preferred_username: payload.preferred_username,
-        email: payload.email,
-        email_verified: payload.email_verified,
-        name: payload.name,
-        given_name: payload.given_name,
-        family_name: payload.family_name,
-        realm: getRealmFromIssuer(jwt),
-    };
+    else if (typeof rawNamespaces === "string" && rawNamespaces) {
+        namespaces.add(rawNamespaces);
+    }
+    const rawRoles = [
+        ...(Array.isArray(payload?.realm_access?.roles)
+            ? payload.realm_access.roles
+            : []),
+        ...(payload?.resource_access && typeof payload.resource_access === "object"
+            ? Object.values(payload.resource_access).flatMap((client) => client?.roles ?? [])
+            : []),
+    ];
+    for (const role of rawRoles) {
+        if (role?.startsWith("namespace:")) {
+            namespaces.add(role.slice("namespace:".length));
+        }
+    }
+    return [...namespaces];
 }
 export function getRealmFromIssuer(jwt) {
     const payload = getTokenPayload(jwt);
@@ -80,4 +66,27 @@ export function getRealmFromIssuer(jwt) {
     }
     return parts[realmsIndex + 1];
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbmVzdC91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVwRCxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxNQUFNLENBQUMsd0JBQXdCLENBQUMsQ0FBQztBQUV0RSxNQUFNLFVBQVUsZUFBZSxDQUFDLEdBQVc7SUFDekMsSUFBSSxDQUFDO1FBQ0gsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsV0FBVyxDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUErQixDQUFDO0lBQ3RILENBQUM7SUFBQyxNQUFNLENBQUM7UUFDUCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7QUFDSCxDQUFDO0FBRUQsTUFBTSxVQUFVLG9CQUFvQixDQUFDLE9BQTBDO0lBQzdFLE1BQU0sS0FBSyxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7SUFDaEMsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxZQUFZLEVBQUUsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUNoRCxLQUFLLE1BQU0sSUFBSSxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSztZQUFFLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDakUsQ0FBQztJQUNELElBQUksT0FBTyxFQUFFLGVBQWUsSUFBSSxPQUFPLE9BQU8sQ0FBQyxlQUFlLEtBQUssUUFBUSxFQUFFLENBQUM7UUFDNUUsS0FBSyxNQUFNLE1BQU0sSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxlQUFlLENBQUMsRUFBRSxDQUFDO1lBQzFELEtBQUssTUFBTSxJQUFJLElBQUksT0FBTyxDQUFDLGVBQWUsQ0FBQyxNQUFNLENBQUMsRUFBRSxLQUFLLElBQUksRUFBRSxFQUFFLENBQUM7Z0JBQ2hFLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDbEIsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxDQUFDLEdBQUcsS0FBSyxDQUFDLENBQUM7QUFDcEIsQ0FBQztBQUVEOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsY0FBYyxDQUM1QixPQUEwQyxFQUMxQyxXQUFxQixDQUFDLFNBQVMsQ0FBQztJQUVoQyxNQUFNLGNBQWMsR0FBRyxPQUFPLEVBQUUsZUFBZSxDQUFDO0lBQ2hELElBQUksQ0FBQyxjQUFjLElBQUksT0FBTyxjQUFjLEtBQUssUUFBUTtRQUFFLE9BQU8sRUFBRSxDQUFDO0lBQ3JFLE1BQU0sS0FBSyxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7SUFDaEMsS0FBSyxNQUFNLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsY0FBYyxDQUFDLEVBQUUsQ0FBQztRQUM5RCxJQUFJLFFBQVEsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDO1lBQUUsU0FBUztRQUMxQyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDL0IsS0FBSyxNQUFNLElBQUksSUFBSSxJQUFJLENBQUMsS0FBSztnQkFBRSxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2pELENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxDQUFDLEdBQUcsS0FBSyxDQUFDLENBQUM7QUFDcEIsQ0FBQztBQUVELE1BQU0sVUFBVSxPQUFPLENBQUMsR0FBVztJQUNqQyxNQUFNLE9BQU8sR0FBRyxlQUFlLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDckMsSUFBSSxDQUFDLE9BQU87UUFBRSxPQUFPLFNBQVMsQ0FBQztJQUMvQixPQUFPO1FBQ0wsa0JBQWtCLEVBQUUsT0FBTyxDQUFDLGtCQUFrQjtRQUM5QyxLQUFLLEVBQUUsT0FBTyxDQUFDLEtBQUs7UUFDcEIsY0FBYyxFQUFFLE9BQU8sQ0FBQyxjQUFjO1FBQ3RDLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSTtRQUNsQixVQUFVLEVBQUUsT0FBTyxDQUFDLFVBQVU7UUFDOUIsV0FBVyxFQUFFLE9BQU8sQ0FBQyxXQUFXO1FBQ2hDLEtBQUssRUFBRSxrQkFBa0IsQ0FBQyxHQUFHLENBQUM7S0FDL0IsQ0FBQztBQUNKLENBQUM7QUFFRCxNQUFNLFVBQVUsa0JBQWtCLENBQUMsR0FBVztJQUM1QyxNQUFNLE9BQU8sR0FBRyxlQUFlLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDckMsTUFBTSxHQUFHLEdBQUcsT0FBTyxFQUFFLEdBQUcsQ0FBQztJQUN6QixJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDVCxNQUFNLElBQUksa0JBQWtCLENBQUMseUJBQXlCLENBQUMsQ0FBQztJQUMxRCxDQUFDO0lBQ0QsSUFBSSxHQUFRLENBQUM7SUFDYixJQUFJLENBQUM7UUFDSCxHQUFHLEdBQUcsSUFBSSxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUFDLE1BQU0sQ0FBQztRQUNQLE1BQU0sSUFBSSxrQkFBa0IsQ0FBQyx1QkFBdUIsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUM3RCxDQUFDO0lBQ0QsTUFBTSxLQUFLLEdBQUcsR0FBRyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3RELE1BQU0sV0FBVyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDNUMsSUFBSSxXQUFXLEtBQUssQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDbEQsTUFBTSxJQUFJLGtCQUFrQixDQUFDLHFDQUFxQyxHQUFHLEVBQUUsQ0FBQyxDQUFDO0lBQzNFLENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQyxXQUFXLEdBQUcsQ0FBQyxDQUFDLENBQUM7QUFDaEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvbmVzdC91dGlsc1xuICogQHN1bW1hcnkgTmVzdCBpbnRlZ3JhdGlvbiB1dGlsaXRpZXMuXG4gKiBAZGVzY3JpcHRpb24gSGVscGVyIGZ1bmN0aW9ucyB1c2VkIGJ5IHRoZSBOZXN0IGF1dGggYW5kIHJlcXVlc3QtY29udGV4dCBhZGFwdGVycy5cbiAqL1xuaW1wb3J0IHR5cGUgeyBLZXljbG9ha0FjY2Vzc1Rva2VuUGF5bG9hZCwgS2V5Y2xvYWtVc2VyIH0gZnJvbSBcIi4vdHlwZXNcIjtcbmltcG9ydCB7IEF1dGhvcml6YXRpb25FcnJvciB9IGZyb20gXCJAZGVjYWYtdHMvY29yZVwiO1xuXG5leHBvcnQgY29uc3QgREVDQUZfQURBUFRFUl9PUFRJT05TID0gU3ltYm9sKFwiRGVjYWZBZGFwdGVyRm9yT3B0aW9uc1wiKTtcblxuZXhwb3J0IGZ1bmN0aW9uIGdldFRva2VuUGF5bG9hZChqd3Q6IHN0cmluZyk6IEtleWNsb2FrQWNjZXNzVG9rZW5QYXlsb2FkIHwgbnVsbCB7XG4gIHRyeSB7XG4gICAgcmV0dXJuIEpTT04ucGFyc2UoQnVmZmVyLmZyb20oand0LnNwbGl0KFwiLlwiKVsxXSA/PyBcIlwiLCBcImJhc2U2NHVybFwiKS50b1N0cmluZyhcInV0ZjhcIikpIGFzIEtleWNsb2FrQWNjZXNzVG9rZW5QYXlsb2FkO1xuICB9IGNhdGNoIHtcbiAgICByZXR1cm4gbnVsbDtcbiAgfVxufVxuXG5leHBvcnQgZnVuY3Rpb24gZXh0cmFjdEtleWNsb2FrUm9sZXMocGF5bG9hZDogS2V5Y2xvYWtBY2Nlc3NUb2tlblBheWxvYWQgfCBudWxsKTogc3RyaW5nW10ge1xuICBjb25zdCByb2xlcyA9IG5ldyBTZXQ8c3RyaW5nPigpO1xuICBpZiAoQXJyYXkuaXNBcnJheShwYXlsb2FkPy5yZWFsbV9hY2Nlc3M/LnJvbGVzKSkge1xuICAgIGZvciAoY29uc3Qgcm9sZSBvZiBwYXlsb2FkLnJlYWxtX2FjY2Vzcy5yb2xlcykgcm9sZXMuYWRkKHJvbGUpO1xuICB9XG4gIGlmIChwYXlsb2FkPy5yZXNvdXJjZV9hY2Nlc3MgJiYgdHlwZW9mIHBheWxvYWQucmVzb3VyY2VfYWNjZXNzID09PSBcIm9iamVjdFwiKSB7XG4gICAgZm9yIChjb25zdCBjbGllbnQgb2YgT2JqZWN0LmtleXMocGF5bG9hZC5yZXNvdXJjZV9hY2Nlc3MpKSB7XG4gICAgICBmb3IgKGNvbnN0IHJvbGUgb2YgcGF5bG9hZC5yZXNvdXJjZV9hY2Nlc3NbY2xpZW50XT8ucm9sZXMgPz8gW10pIHtcbiAgICAgICAgcm9sZXMuYWRkKHJvbGUpO1xuICAgICAgfVxuICAgIH1cbiAgfVxuICByZXR1cm4gWy4uLnJvbGVzXTtcbn1cblxuLyoqXG4gKiBFeHRyYWN0cyByb2xlcyBmcm9tIHRoZSBgcmVzb3VyY2VfYWNjZXNzYCBjbGFpbSBvbmx5LCBvcHRpb25hbGx5IGV4Y2x1ZGluZ1xuICogc3BlY2lmaWVkIGNsaWVudCBJRHMgKGUuZy4gYFwiYWNjb3VudFwiYCkuICBVbmxpa2Uge0BsaW5rIGV4dHJhY3RLZXljbG9ha1JvbGVzfVxuICogdGhpcyBkb2VzIE5PVCBpbmNsdWRlIGByZWFsbV9hY2Nlc3Mucm9sZXNgLlxuICpcbiAqIEBwYXJhbSBwYXlsb2FkICAgVGhlIGRlY29kZWQgSldUIHBheWxvYWQuXG4gKiBAcGFyYW0gZXhjbHVkZWQgIENsaWVudCBJRHMgdG8gc2tpcC4gIEBkZWZhdWx0IFtcImFjY291bnRcIl1cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldENsaWVudFJvbGVzKFxuICBwYXlsb2FkOiBLZXljbG9ha0FjY2Vzc1Rva2VuUGF5bG9hZCB8IG51bGwsXG4gIGV4Y2x1ZGVkOiBzdHJpbmdbXSA9IFtcImFjY291bnRcIl1cbik6IHN0cmluZ1tdIHtcbiAgY29uc3QgcmVzb3VyY2VBY2Nlc3MgPSBwYXlsb2FkPy5yZXNvdXJjZV9hY2Nlc3M7XG4gIGlmICghcmVzb3VyY2VBY2Nlc3MgfHwgdHlwZW9mIHJlc291cmNlQWNjZXNzICE9PSBcIm9iamVjdFwiKSByZXR1cm4gW107XG4gIGNvbnN0IHJvbGVzID0gbmV3IFNldDxzdHJpbmc+KCk7XG4gIGZvciAoY29uc3QgW2NsaWVudElkLCBkYXRhXSBvZiBPYmplY3QuZW50cmllcyhyZXNvdXJjZUFjY2VzcykpIHtcbiAgICBpZiAoZXhjbHVkZWQuaW5jbHVkZXMoY2xpZW50SWQpKSBjb250aW51ZTtcbiAgICBpZiAoQXJyYXkuaXNBcnJheShkYXRhPy5yb2xlcykpIHtcbiAgICAgIGZvciAoY29uc3Qgcm9sZSBvZiBkYXRhLnJvbGVzKSByb2xlcy5hZGQocm9sZSk7XG4gICAgfVxuICB9XG4gIHJldHVybiBbLi4ucm9sZXNdO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0VXNlcihqd3Q6IHN0cmluZyk6IEtleWNsb2FrVXNlciB8IHVuZGVmaW5lZCB7XG4gIGNvbnN0IHBheWxvYWQgPSBnZXRUb2tlblBheWxvYWQoand0KTtcbiAgaWYgKCFwYXlsb2FkKSByZXR1cm4gdW5kZWZpbmVkO1xuICByZXR1cm4ge1xuICAgIHByZWZlcnJlZF91c2VybmFtZTogcGF5bG9hZC5wcmVmZXJyZWRfdXNlcm5hbWUsXG4gICAgZW1haWw6IHBheWxvYWQuZW1haWwsXG4gICAgZW1haWxfdmVyaWZpZWQ6IHBheWxvYWQuZW1haWxfdmVyaWZpZWQsXG4gICAgbmFtZTogcGF5bG9hZC5uYW1lLFxuICAgIGdpdmVuX25hbWU6IHBheWxvYWQuZ2l2ZW5fbmFtZSxcbiAgICBmYW1pbHlfbmFtZTogcGF5bG9hZC5mYW1pbHlfbmFtZSxcbiAgICByZWFsbTogZ2V0UmVhbG1Gcm9tSXNzdWVyKGp3dCksXG4gIH07XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRSZWFsbUZyb21Jc3N1ZXIoand0OiBzdHJpbmcpOiBzdHJpbmcge1xuICBjb25zdCBwYXlsb2FkID0gZ2V0VG9rZW5QYXlsb2FkKGp3dCk7XG4gIGNvbnN0IGlzcyA9IHBheWxvYWQ/LmlzcztcbiAgaWYgKCFpc3MpIHtcbiAgICB0aHJvdyBuZXcgQXV0aG9yaXphdGlvbkVycm9yKFwiSXNzdWVyIChpc3MpIGlzIG1pc3NpbmdcIik7XG4gIH1cbiAgbGV0IHVybDogVVJMO1xuICB0cnkge1xuICAgIHVybCA9IG5ldyBVUkwoaXNzKTtcbiAgfSBjYXRjaCB7XG4gICAgdGhyb3cgbmV3IEF1dGhvcml6YXRpb25FcnJvcihgSW52YWxpZCBpc3N1ZXIgVVJMOiAke2lzc31gKTtcbiAgfVxuICBjb25zdCBwYXJ0cyA9IHVybC5wYXRobmFtZS5zcGxpdChcIi9cIikuZmlsdGVyKEJvb2xlYW4pO1xuICBjb25zdCByZWFsbXNJbmRleCA9IHBhcnRzLmluZGV4T2YoXCJyZWFsbXNcIik7XG4gIGlmIChyZWFsbXNJbmRleCA9PT0gLTEgfHwgIXBhcnRzW3JlYWxtc0luZGV4ICsgMV0pIHtcbiAgICB0aHJvdyBuZXcgQXV0aG9yaXphdGlvbkVycm9yKGBDYW5ub3QgZXh0cmFjdCByZWFsbSBmcm9tIGlzc3VlcjogJHtpc3N9YCk7XG4gIH1cbiAgcmV0dXJuIHBhcnRzW3JlYWxtc0luZGV4ICsgMV07XG59XG4iXX0=
+/**
+ * Extracts roles from the `resource_access` claim only, optionally excluding
+ * specified client IDs (e.g. `"account"`).  Unlike {@link extractKeycloakRoles}
+ * this does NOT include `realm_access.roles`.
+ *
+ * @param payload   The decoded JWT payload.
+ * @param excluded  Client IDs to skip.  @default ["account"]
+ */
+export function getClientRoles(payload, excluded = ["account"]) {
+    const resourceAccess = payload?.resource_access;
+    if (!resourceAccess || typeof resourceAccess !== "object")
+        return [];
+    const roles = new Set();
+    for (const [clientId, data] of Object.entries(resourceAccess)) {
+        if (excluded.includes(clientId))
+            continue;
+        if (Array.isArray(data?.roles)) {
+            for (const role of data.roles)
+                roles.add(role);
+        }
+    }
+    return [...roles];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/nest/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/nest/utils\n * @summary Nest integration utilities.\n * @description Helper functions used by the Nest auth and request-context adapters.\n */\nimport type { KeycloakAccessTokenPayload } from \"./types\";\nimport { AuthorizationError } from \"@decaf-ts/core\";\nimport { getTokenPayload } from \"@decaf-ts/crypto/integration/services/jwt\";\n\nexport const DECAF_ADAPTER_OPTIONS = Symbol(\"DecafAdapterForOptions\");\n\nexport function extractKeycloakRoles(payload: KeycloakAccessTokenPayload | null): string[] {\n  const roles = new Set<string>();\n  if (Array.isArray(payload?.realm_access?.roles)) {\n    for (const role of payload.realm_access.roles) {\n      if (!role?.startsWith(\"namespace:\")) roles.add(role);\n    }\n  }\n  if (payload?.resource_access && typeof payload.resource_access === \"object\") {\n    for (const client of Object.keys(payload.resource_access)) {\n      for (const role of payload.resource_access[client]?.roles ?? []) {\n        if (!role?.startsWith(\"namespace:\")) roles.add(role);\n      }\n    }\n  }\n  return [...roles];\n}\n\nexport function extractKeycloakNamespaces(\n  payload: KeycloakAccessTokenPayload | null | undefined\n): string[] {\n  const namespaces = new Set<string>();\n  const rawNamespaces = payload?.namespaces ?? payload?.namespace;\n  if (Array.isArray(rawNamespaces)) {\n    for (const namespace of rawNamespaces) {\n      if (namespace) namespaces.add(namespace);\n    }\n  } else if (typeof rawNamespaces === \"string\" && rawNamespaces) {\n    namespaces.add(rawNamespaces);\n  }\n\n  const rawRoles = [\n    ...(Array.isArray(payload?.realm_access?.roles)\n      ? payload.realm_access.roles\n      : []),\n    ...(payload?.resource_access && typeof payload.resource_access === \"object\"\n      ? Object.values(payload.resource_access).flatMap(\n          (client) => client?.roles ?? []\n        )\n      : []),\n  ];\n  for (const role of rawRoles) {\n    if (role?.startsWith(\"namespace:\")) {\n      namespaces.add(role.slice(\"namespace:\".length));\n    }\n  }\n\n  return [...namespaces];\n}\n\nexport function getRealmFromIssuer(jwt: string): string {\n  const payload = getTokenPayload<{ iss?: string }>(jwt);\n  const iss = payload?.iss;\n  if (!iss) {\n    throw new AuthorizationError(\"Issuer (iss) is missing\");\n  }\n  let url: URL;\n  try {\n    url = new URL(iss);\n  } catch {\n    throw new AuthorizationError(`Invalid issuer URL: ${iss}`);\n  }\n  const parts = url.pathname.split(\"/\").filter(Boolean);\n  const realmsIndex = parts.indexOf(\"realms\");\n  if (realmsIndex === -1 || !parts[realmsIndex + 1]) {\n    throw new AuthorizationError(`Cannot extract realm from issuer: ${iss}`);\n  }\n  return parts[realmsIndex + 1];\n}\n\n/**\n * Extracts roles from the `resource_access` claim only, optionally excluding\n * specified client IDs (e.g. `\"account\"`).  Unlike {@link extractKeycloakRoles}\n * this does NOT include `realm_access.roles`.\n *\n * @param payload   The decoded JWT payload.\n * @param excluded  Client IDs to skip.  @default [\"account\"]\n */\nexport function getClientRoles(\n  payload: KeycloakAccessTokenPayload | null,\n  excluded: string[] = [\"account\"]\n): string[] {\n  const resourceAccess = payload?.resource_access;\n  if (!resourceAccess || typeof resourceAccess !== \"object\") return [];\n  const roles = new Set<string>();\n  for (const [clientId, data] of Object.entries(resourceAccess)) {\n    if (excluded.includes(clientId)) continue;\n    if (Array.isArray(data?.roles)) {\n      for (const role of data.roles) roles.add(role);\n    }\n  }\n  return [...roles];\n}\n"]}

package/lib/esm/plugins/contract.js

@@ -0,0 +1,68 @@
+import { UnsupportedError } from "@decaf-ts/core";
+/**
+ * Message type constants shared between the embedded plugin and the host.
+ * The plugin is org-agnostic: there is never space switching; the current
+ * Kibana space comes from the request/session/proxy context.
+ */
+export const EMBED_MESSAGE_TYPE = {
+    SWITCH: "ORG_DASHBOARD_EMBED_SWITCH_DASHBOARD",
+    READY: "ORG_DASHBOARD_EMBED_READY",
+    RENDERED: "ORG_DASHBOARD_EMBED_RENDERED",
+    ERROR: "ORG_DASHBOARD_EMBED_ERROR",
+};
+/**
+ * Type guard for the switch-dashboard message received by the embedded plugin.
+ */
+export function isSwitchDashboardMessage(data) {
+    if (!data || typeof data !== "object") {
+        return false;
+    }
+    const msg = data;
+    return (msg.type === EMBED_MESSAGE_TYPE.SWITCH &&
+        typeof msg.dashboardId === "string" &&
+        msg.dashboardId.length > 0);
+}
+/**
+ * Type guard for parent-bound messages emitted by the embedded plugin.
+ */
+export function isEmbedParentMessage(data) {
+    if (!data || typeof data !== "object") {
+        return false;
+    }
+    const msg = data;
+    return (msg.type === EMBED_MESSAGE_TYPE.READY ||
+        msg.type === EMBED_MESSAGE_TYPE.RENDERED ||
+        msg.type === EMBED_MESSAGE_TYPE.ERROR);
+}
+/**
+ * Build a switch-dashboard message from a payload (shared by both plugins).
+ */
+export function createSwitchDashboardMessage(payload) {
+    return {
+        type: EMBED_MESSAGE_TYPE.SWITCH,
+        dashboardId: payload.dashboardId,
+        timeRange: payload.timeRange,
+        query: payload.query,
+        filters: payload.filters,
+        guestToken: payload.guestToken,
+    };
+}
+/**
+ * Send a switch-dashboard message to a DOM-free target.
+ *
+ * If the target supports `postMessage` (Kibana), the message is posted
+ * directly. If the target supports `switchDashboard` (Superset SDK handle),
+ * the SDK method is invoked instead. Both paths use the same payload shape.
+ */
+export function sendSwitchDashboardMessage(target, payload, targetOrigin) {
+    if (typeof target.switchDashboard === "function") {
+        void target.switchDashboard(payload.dashboardId, payload.guestToken);
+        return;
+    }
+    if (typeof target.postMessage === "function") {
+        target.postMessage(createSwitchDashboardMessage(payload), targetOrigin);
+        return;
+    }
+    throw new UnsupportedError("EmbedMessageTarget must provide either postMessage or switchDashboard");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../../src/plugins/contract.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,MAAM,EAAE,sCAAsC;IAC9C,KAAK,EAAE,2BAA2B;IAClC,QAAQ,EAAE,8BAA8B;IACxC,KAAK,EAAE,2BAA2B;CAC1B,CAAC;AAwKX;;GAEG;AACH,MAAM,UAAU,wBAAwB,CACtC,IAAa;IAEb,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QACtC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,GAAG,GAAG,IAAuC,CAAC;IACpD,OAAO,CACL,GAAG,CAAC,IAAI,KAAK,kBAAkB,CAAC,MAAM;QACtC,OAAO,GAAG,CAAC,WAAW,KAAK,QAAQ;QACnC,GAAG,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAC3B,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAAa;IAEb,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QACtC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,GAAG,GAAG,IAAyB,CAAC;IACtC,OAAO,CACL,GAAG,CAAC,IAAI,KAAK,kBAAkB,CAAC,KAAK;QACrC,GAAG,CAAC,IAAI,KAAK,kBAAkB,CAAC,QAAQ;QACxC,GAAG,CAAC,IAAI,KAAK,kBAAkB,CAAC,KAAK,CACtC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,4BAA4B,CAC1C,OAA+B;IAE/B,OAAO;QACL,IAAI,EAAE,kBAAkB,CAAC,MAAM;QAC/B,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,UAAU,EAAE,OAAO,CAAC,UAAU;KAC/B,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CACxC,MAA0B,EAC1B,OAA+B,EAC/B,YAAoB;IAEpB,IAAI,OAAO,MAAM,CAAC,eAAe,KAAK,UAAU,EAAE,CAAC;QACjD,KAAK,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;QACrE,OAAO;IACT,CAAC;IACD,IAAI,OAAO,MAAM,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;QAC7C,MAAM,CAAC,WAAW,CAAC,4BAA4B,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC;QACxE,OAAO;IACT,CAAC;IACD,MAAM,IAAI,gBAAgB,CACxB,uEAAuE,CACxE,CAAC;AACJ,CAAC","sourcesContent":["/**\n * @module integrations/plugins/contract\n * @summary Shared, DOM-free contract for BI dashboard embed plugins.\n * @description Defines the message protocol, embed URL options, install\n * options/result, plugin descriptor, and the `DashboardEmbedPlugin` interface\n * that both the Kibana and Superset plugins implement with the exact same API.\n *\n * This contract is intentionally DOM-free (no `window` / `HTMLIFrameElement`)\n * so it builds under the Node `lib: [\"es2022\"]` tsconfig and is consumable from\n * both Node and the browser. The Angular host supplies a DOM-free\n * `EmbedMessageTarget` (typically `iframe.contentWindow`).\n */\nimport type { MaybeContextualArg } from \"@decaf-ts/core\";\nimport { UnsupportedError } from \"@decaf-ts/core\";\n\n/**\n * Message type constants shared between the embedded plugin and the host.\n * The plugin is org-agnostic: there is never space switching; the current\n * Kibana space comes from the request/session/proxy context.\n */\nexport const EMBED_MESSAGE_TYPE = {\n  SWITCH: \"ORG_DASHBOARD_EMBED_SWITCH_DASHBOARD\",\n  READY: \"ORG_DASHBOARD_EMBED_READY\",\n  RENDERED: \"ORG_DASHBOARD_EMBED_RENDERED\",\n  ERROR: \"ORG_DASHBOARD_EMBED_ERROR\",\n} as const;\n\nexport type EmbedMessageType =\n  (typeof EMBED_MESSAGE_TYPE)[keyof typeof EMBED_MESSAGE_TYPE];\n\nexport interface DashboardQuery {\n  language: \"kuery\" | \"lucene\";\n  query: string;\n}\n\nexport interface DashboardTimeRange {\n  from: string;\n  to: string;\n}\n\n/**\n * Payload used to switch dashboards at runtime.\n *\n * `guestToken` is used by Superset (which requires a dashboard-scoped guest\n * token for each switch) and ignored by Kibana (which relies on the session\n * space context). This keeps the payload shape identical across both plugins.\n */\nexport interface SwitchDashboardPayload {\n  dashboardId: string;\n  timeRange?: DashboardTimeRange;\n  query?: DashboardQuery;\n  filters?: unknown[];\n  /** Superset-only: dashboard-scoped guest token. Kibana ignores this. */\n  guestToken?: string;\n}\n\nexport interface SwitchDashboardMessage extends SwitchDashboardPayload {\n  type: typeof EMBED_MESSAGE_TYPE.SWITCH;\n}\n\nexport interface EmbedReadyMessage {\n  type: typeof EMBED_MESSAGE_TYPE.READY;\n  dashboardId: string | null;\n}\n\nexport interface EmbedRenderedMessage {\n  type: typeof EMBED_MESSAGE_TYPE.RENDERED;\n  dashboardId: string;\n}\n\nexport interface EmbedErrorMessage {\n  type: typeof EMBED_MESSAGE_TYPE.ERROR;\n  dashboardId: string | null;\n  message: string;\n}\n\n/**\n * Union of messages the embedded plugin posts back to the parent host.\n */\nexport type EmbedParentMessage =\n  | EmbedReadyMessage\n  | EmbedRenderedMessage\n  | EmbedErrorMessage;\n\n/**\n * DOM-free message target. Both Kibana and Superset use the same interface;\n * each tool uses a different mechanism:\n *\n * - **Kibana:** the Angular host passes `iframe.contentWindow`, which provides\n *   `postMessage`. `switchDashboard` is unused.\n * - **Superset:** the Angular host passes the embedded SDK's\n *   `EmbeddedDashboard` handle (wrapped), which provides `switchDashboard`.\n *   `postMessage` is unused.\n *\n * At least one of the two methods must be present; each plugin checks for the\n * mechanism it needs and throws an `UnsupportedError` if absent.\n */\nexport interface EmbedMessageTarget {\n  /** Kibana mechanism: post a message to the iframe window. */\n  postMessage?(message: unknown, targetOrigin: string): void;\n  /** Superset mechanism: call the SDK's switchDashboard method. */\n  switchDashboard?(\n    dashboardId: string,\n    guestToken?: string\n  ): Promise<unknown>;\n}\n\nexport interface EmbedViewOptions {\n  showTimeFilter?: boolean;\n  showQueryInput?: boolean;\n  showFilterBar?: boolean;\n  hidePanelTitles?: boolean;\n  timeRange?: DashboardTimeRange;\n}\n\nexport interface EmbedUrlOptions {\n  /** Host without protocol, e.g. \"ptp.host\". */\n  host: string;\n  /** Base path, e.g. \"kibana\". Defaults to the tool default. */\n  basePath?: string;\n  /** Initial dashboard id to render. */\n  dashboardId: string;\n  /** Parent origin allowlist (comma-separated) passed to the plugin. */\n  parentOrigin: string;\n  /** Optional view overrides. */\n  view?: EmbedViewOptions;\n}\n\nexport type BiTool = \"kibana\" | \"superset\";\n\nexport interface DashboardEmbedPluginDescriptor {\n  /** Plugin id (e.g. \"orgDashboardEmbed\"). */\n  id: string;\n  /** Kibana application id (e.g. \"org_dashboard_embed\"). */\n  appId: string;\n  /** Plugin version. */\n  version: string;\n  /** Target BI tool version this plugin is built against. */\n  targetVersion: string;\n  /** BI tool this plugin targets. */\n  tool: BiTool;\n}\n\nexport interface PluginInstallOptions {\n  /** Directory to materialize the plugin into. */\n  targetPath: string;\n  /** Overrides `descriptor.targetVersion` when provided. */\n  targetVersion?: string;\n  /** Attempt to build the plugin after writing files (best-effort). */\n  build?: boolean;\n  /** Overwrite an existing plugin directory. */\n  overwrite?: boolean;\n  /** Optional context for tracing/logging. */\n  context?: MaybeContextualArg<any>;\n}\n\nexport interface PluginInstallResult {\n  /** Absolute path to the materialized plugin directory. */\n  pluginPath: string;\n  /** Descriptor used for this install. */\n  descriptor: DashboardEmbedPluginDescriptor;\n  /** Relative file paths written. */\n  files: string[];\n  /** Whether a build was attempted and reported success. */\n  built: boolean;\n  /** Captured build output (stdout/stderr) when `build` was requested. */\n  buildOutput?: string;\n}\n\n/**\n * Contract both BI dashboard embed plugins implement. Both Kibana and\n * Superset plugins expose the exact same API surface.\n */\nexport interface DashboardEmbedPlugin {\n  readonly descriptor: DashboardEmbedPluginDescriptor;\n  /** Build the BI-tool manifest (e.g. kibana.json) for a target version. */\n  manifest(targetVersion?: string): Record<string, unknown>;\n  /** Build the stable iframe embed URL. */\n  buildEmbedUrl(options: EmbedUrlOptions): string;\n  /** Create a switch-dashboard message object. */\n  createSwitchDashboardMessage(\n    payload: SwitchDashboardPayload\n  ): SwitchDashboardMessage;\n  /** Send a switch-dashboard message to the embedded plugin via `postMessage`. */\n  sendSwitchDashboardMessage(\n    target: EmbedMessageTarget,\n    payload: SwitchDashboardPayload,\n    targetOrigin: string\n  ): void;\n  /** Materialize (and optionally build) the plugin into a target directory. */\n  install(options: PluginInstallOptions): Promise<PluginInstallResult>;\n}\n\n/**\n * Type guard for the switch-dashboard message received by the embedded plugin.\n */\nexport function isSwitchDashboardMessage(\n  data: unknown\n): data is SwitchDashboardMessage {\n  if (!data || typeof data !== \"object\") {\n    return false;\n  }\n  const msg = data as Partial<SwitchDashboardMessage>;\n  return (\n    msg.type === EMBED_MESSAGE_TYPE.SWITCH &&\n    typeof msg.dashboardId === \"string\" &&\n    msg.dashboardId.length > 0\n  );\n}\n\n/**\n * Type guard for parent-bound messages emitted by the embedded plugin.\n */\nexport function isEmbedParentMessage(\n  data: unknown\n): data is EmbedParentMessage {\n  if (!data || typeof data !== \"object\") {\n    return false;\n  }\n  const msg = data as { type?: string };\n  return (\n    msg.type === EMBED_MESSAGE_TYPE.READY ||\n    msg.type === EMBED_MESSAGE_TYPE.RENDERED ||\n    msg.type === EMBED_MESSAGE_TYPE.ERROR\n  );\n}\n\n/**\n * Build a switch-dashboard message from a payload (shared by both plugins).\n */\nexport function createSwitchDashboardMessage(\n  payload: SwitchDashboardPayload\n): SwitchDashboardMessage {\n  return {\n    type: EMBED_MESSAGE_TYPE.SWITCH,\n    dashboardId: payload.dashboardId,\n    timeRange: payload.timeRange,\n    query: payload.query,\n    filters: payload.filters,\n    guestToken: payload.guestToken,\n  };\n}\n\n/**\n * Send a switch-dashboard message to a DOM-free target.\n *\n * If the target supports `postMessage` (Kibana), the message is posted\n * directly. If the target supports `switchDashboard` (Superset SDK handle),\n * the SDK method is invoked instead. Both paths use the same payload shape.\n */\nexport function sendSwitchDashboardMessage(\n  target: EmbedMessageTarget,\n  payload: SwitchDashboardPayload,\n  targetOrigin: string\n): void {\n  if (typeof target.switchDashboard === \"function\") {\n    void target.switchDashboard(payload.dashboardId, payload.guestToken);\n    return;\n  }\n  if (typeof target.postMessage === \"function\") {\n    target.postMessage(createSwitchDashboardMessage(payload), targetOrigin);\n    return;\n  }\n  throw new UnsupportedError(\n    \"EmbedMessageTarget must provide either postMessage or switchDashboard\"\n  );\n}\n"]}

package/lib/esm/plugins/index.js

@@ -0,0 +1,18 @@
+/**
+ * @module integrations/plugins
+ * @summary BI dashboard embed plugin surface.
+ * @description Aggregates the shared DOM-free contract and both BI tool
+ * plugins (Kibana + Superset). Both plugins implement the exact same
+ * `DashboardEmbedPlugin` API.
+ *
+ * - **Kibana:** generated plugin source + installer (writes files, optional build).
+ * - **Superset:** patch-and-build strategy (patches Superset's internal source,
+ *   builds SDK + frontend + optionally Docker image).
+ *
+ * Both are org-agnostic: there is never space switching. The current BI space
+ * comes from the request/session/proxy context, not from the plugin.
+ */
+export * from "./contract.js";
+export * from "./kibana/index.js";
+export * from "./superset/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcGx1Z2lucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsOEJBQTJCO0FBQzNCLGtDQUF5QjtBQUN6QixvQ0FBMkIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL3BsdWdpbnNcbiAqIEBzdW1tYXJ5IEJJIGRhc2hib2FyZCBlbWJlZCBwbHVnaW4gc3VyZmFjZS5cbiAqIEBkZXNjcmlwdGlvbiBBZ2dyZWdhdGVzIHRoZSBzaGFyZWQgRE9NLWZyZWUgY29udHJhY3QgYW5kIGJvdGggQkkgdG9vbFxuICogcGx1Z2lucyAoS2liYW5hICsgU3VwZXJzZXQpLiBCb3RoIHBsdWdpbnMgaW1wbGVtZW50IHRoZSBleGFjdCBzYW1lXG4gKiBgRGFzaGJvYXJkRW1iZWRQbHVnaW5gIEFQSS5cbiAqXG4gKiAtICoqS2liYW5hOioqIGdlbmVyYXRlZCBwbHVnaW4gc291cmNlICsgaW5zdGFsbGVyICh3cml0ZXMgZmlsZXMsIG9wdGlvbmFsIGJ1aWxkKS5cbiAqIC0gKipTdXBlcnNldDoqKiBwYXRjaC1hbmQtYnVpbGQgc3RyYXRlZ3kgKHBhdGNoZXMgU3VwZXJzZXQncyBpbnRlcm5hbCBzb3VyY2UsXG4gKiAgIGJ1aWxkcyBTREsgKyBmcm9udGVuZCArIG9wdGlvbmFsbHkgRG9ja2VyIGltYWdlKS5cbiAqXG4gKiBCb3RoIGFyZSBvcmctYWdub3N0aWM6IHRoZXJlIGlzIG5ldmVyIHNwYWNlIHN3aXRjaGluZy4gVGhlIGN1cnJlbnQgQkkgc3BhY2VcbiAqIGNvbWVzIGZyb20gdGhlIHJlcXVlc3Qvc2Vzc2lvbi9wcm94eSBjb250ZXh0LCBub3QgZnJvbSB0aGUgcGx1Z2luLlxuICovXG5leHBvcnQgKiBmcm9tIFwiLi9jb250cmFjdFwiO1xuZXhwb3J0ICogZnJvbSBcIi4va2liYW5hXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdXBlcnNldFwiO1xuIl19

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

@@ -0,0 +1,19 @@
+/**
+ * @module integrations/plugins/kibana/host
+ * @summary Angular host-side helpers for the Kibana embed plugin.
+ * @description DOM-free convenience helpers the Angular host uses to build the
+ * stable iframe URL and send switch-dashboard messages to the embedded plugin.
+ */
+import { sendSwitchDashboardMessage as sendShared, } from "./../contract.js";
+import { buildKibanaEmbedUrl } from "./installer.js";
+export { buildKibanaEmbedUrl };
+/**
+ * Send a switch-dashboard message to the embedded Kibana plugin.
+ *
+ * The Angular host passes `iframe.contentWindow` (which satisfies
+ * `EmbedMessageTarget`) and the Kibana origin as `targetOrigin`.
+ */
+export function sendKibanaSwitchDashboardMessage(target, payload, targetOrigin) {
+    sendShared(target, payload, targetOrigin);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9zdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wbHVnaW5zL2tpYmFuYS9ob3N0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBQ0gsT0FBTyxFQUNMLDBCQUEwQixJQUFJLFVBQVUsR0FJekMseUJBQW9CO0FBQ3JCLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSx1QkFBb0I7QUFFbEQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLENBQUM7QUFFL0I7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsZ0NBQWdDLENBQzlDLE1BQTBCLEVBQzFCLE9BQStCLEVBQy9CLFlBQW9CO0lBRXBCLFVBQVUsQ0FBQyxNQUFNLEVBQUUsT0FBTyxFQUFFLFlBQVksQ0FBQyxDQUFDO0FBQzVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL3BsdWdpbnMva2liYW5hL2hvc3RcbiAqIEBzdW1tYXJ5IEFuZ3VsYXIgaG9zdC1zaWRlIGhlbHBlcnMgZm9yIHRoZSBLaWJhbmEgZW1iZWQgcGx1Z2luLlxuICogQGRlc2NyaXB0aW9uIERPTS1mcmVlIGNvbnZlbmllbmNlIGhlbHBlcnMgdGhlIEFuZ3VsYXIgaG9zdCB1c2VzIHRvIGJ1aWxkIHRoZVxuICogc3RhYmxlIGlmcmFtZSBVUkwgYW5kIHNlbmQgc3dpdGNoLWRhc2hib2FyZCBtZXNzYWdlcyB0byB0aGUgZW1iZWRkZWQgcGx1Z2luLlxuICovXG5pbXBvcnQge1xuICBzZW5kU3dpdGNoRGFzaGJvYXJkTWVzc2FnZSBhcyBzZW5kU2hhcmVkLFxuICB0eXBlIEVtYmVkTWVzc2FnZVRhcmdldCxcbiAgdHlwZSBFbWJlZFVybE9wdGlvbnMsXG4gIHR5cGUgU3dpdGNoRGFzaGJvYXJkUGF5bG9hZCxcbn0gZnJvbSBcIi4uL2NvbnRyYWN0XCI7XG5pbXBvcnQgeyBidWlsZEtpYmFuYUVtYmVkVXJsIH0gZnJvbSBcIi4vaW5zdGFsbGVyXCI7XG5cbmV4cG9ydCB7IGJ1aWxkS2liYW5hRW1iZWRVcmwgfTtcblxuLyoqXG4gKiBTZW5kIGEgc3dpdGNoLWRhc2hib2FyZCBtZXNzYWdlIHRvIHRoZSBlbWJlZGRlZCBLaWJhbmEgcGx1Z2luLlxuICpcbiAqIFRoZSBBbmd1bGFyIGhvc3QgcGFzc2VzIGBpZnJhbWUuY29udGVudFdpbmRvd2AgKHdoaWNoIHNhdGlzZmllc1xuICogYEVtYmVkTWVzc2FnZVRhcmdldGApIGFuZCB0aGUgS2liYW5hIG9yaWdpbiBhcyBgdGFyZ2V0T3JpZ2luYC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNlbmRLaWJhbmFTd2l0Y2hEYXNoYm9hcmRNZXNzYWdlKFxuICB0YXJnZXQ6IEVtYmVkTWVzc2FnZVRhcmdldCxcbiAgcGF5bG9hZDogU3dpdGNoRGFzaGJvYXJkUGF5bG9hZCxcbiAgdGFyZ2V0T3JpZ2luOiBzdHJpbmdcbik6IHZvaWQge1xuICBzZW5kU2hhcmVkKHRhcmdldCwgcGF5bG9hZCwgdGFyZ2V0T3JpZ2luKTtcbn1cblxuLyoqIFJlLWV4cG9ydCB0aGUgVVJMIG9wdGlvbnMgdHlwZSBmb3IgaG9zdCBjb252ZW5pZW5jZS4gKi9cbmV4cG9ydCB0eXBlIHsgRW1iZWRVcmxPcHRpb25zIH07XG4iXX0=

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

@@ -0,0 +1,14 @@
+/**
+ * @module integrations/plugins/kibana
+ * @summary Kibana dashboard embed plugin surface.
+ * @description Org-agnostic multi-tenant Kibana dashboard embed plugin,
+ * installer, and host helpers. There is never space switching; the current
+ * Kibana space comes from the request/session/proxy context.
+ */
+export * from "./../contract.js";
+export * from "./types.js";
+export * from "./manifest.js";
+export * from "./templates.js";
+export { KibanaDashboardEmbedPlugin, kibanaDashboardEmbedPlugin, createKibanaDashboardEmbedPlugin, buildKibanaEmbedUrl, KIBANA_DEFAULT_BASE_PATH, } from "./installer.js";
+export { sendKibanaSwitchDashboardMessage, } from "./host.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGx1Z2lucy9raWJhbmEvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsaUNBQTRCO0FBQzVCLDJCQUF3QjtBQUN4Qiw4QkFBMkI7QUFDM0IsK0JBQTRCO0FBQzVCLE9BQU8sRUFDTCwwQkFBMEIsRUFDMUIsMEJBQTBCLEVBQzFCLGdDQUFnQyxFQUNoQyxtQkFBbUIsRUFDbkIsd0JBQXdCLEdBQ3pCLHVCQUFvQjtBQUNyQixPQUFPLEVBQ0wsZ0NBQWdDLEdBQ2pDLGtCQUFlIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9wbHVnaW5zL2tpYmFuYVxuICogQHN1bW1hcnkgS2liYW5hIGRhc2hib2FyZCBlbWJlZCBwbHVnaW4gc3VyZmFjZS5cbiAqIEBkZXNjcmlwdGlvbiBPcmctYWdub3N0aWMgbXVsdGktdGVuYW50IEtpYmFuYSBkYXNoYm9hcmQgZW1iZWQgcGx1Z2luLFxuICogaW5zdGFsbGVyLCBhbmQgaG9zdCBoZWxwZXJzLiBUaGVyZSBpcyBuZXZlciBzcGFjZSBzd2l0Y2hpbmc7IHRoZSBjdXJyZW50XG4gKiBLaWJhbmEgc3BhY2UgY29tZXMgZnJvbSB0aGUgcmVxdWVzdC9zZXNzaW9uL3Byb3h5IGNvbnRleHQuXG4gKi9cbmV4cG9ydCAqIGZyb20gXCIuLi9jb250cmFjdFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL21hbmlmZXN0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90ZW1wbGF0ZXNcIjtcbmV4cG9ydCB7XG4gIEtpYmFuYURhc2hib2FyZEVtYmVkUGx1Z2luLFxuICBraWJhbmFEYXNoYm9hcmRFbWJlZFBsdWdpbixcbiAgY3JlYXRlS2liYW5hRGFzaGJvYXJkRW1iZWRQbHVnaW4sXG4gIGJ1aWxkS2liYW5hRW1iZWRVcmwsXG4gIEtJQkFOQV9ERUZBVUxUX0JBU0VfUEFUSCxcbn0gZnJvbSBcIi4vaW5zdGFsbGVyXCI7XG5leHBvcnQge1xuICBzZW5kS2liYW5hU3dpdGNoRGFzaGJvYXJkTWVzc2FnZSxcbn0gZnJvbSBcIi4vaG9zdFwiO1xuIl19

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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