@qlik/api 1.29.0 → 1.31.0

package/chunks/ETNHFALU.js

@@ -0,0 +1,61 @@
+// src/qix/session/websocket-errors.ts
+var closeCodeEngineTerminating = 4003;
+var closeCodeEngineProxyGeneric = 4200;
+var closeCodeClientTimeout = 4201;
+var closeCodeBadRequest = 4202;
+var closeCodePermissions = 4203;
+var closeCodeNotFound = 4204;
+var closeCodeTooManyRequests = 4205;
+var closeCodeNetwork = 4206;
+var closeCodeDependencyGeneric = 4210;
+var closeCodeDependencyUnavailable = 4211;
+var closeCodeEngineGeneric = 4220;
+var closeCodeEntitlement = 4230;
+var closeCodeNoEnginesAvailable = 4240;
+var CloseCodeSessionReservationMissing = 4222;
+var closeCodeMessages = {
+  1e3: "Connection closed normally.",
+  1001: "Going away.",
+  1002: "Protocol error.",
+  1003: "Unsupported data.",
+  1005: "No status received.",
+  1006: "Abnormal closure.",
+  1007: "Invalid frame payload data.",
+  1008: "Policy violation.",
+  1009: "Message too big.",
+  1010: "Mandatory extension missing.",
+  1011: "Server internal error.",
+  1012: "Service restart.",
+  1013: "Try again later.",
+  1014: "Bad gateway.",
+  1015: "TLS handshake failure.",
+  [closeCodeEngineTerminating]: "The engine is in terminating state",
+  [closeCodeEngineProxyGeneric]: "A problem occurred in engine-proxy",
+  [closeCodeClientTimeout]: "The client has closed the connection",
+  [closeCodeBadRequest]: "The provided request is invalid and/or malformed",
+  [closeCodePermissions]: "No permission to open the app",
+  [closeCodeNotFound]: "App not found",
+  [closeCodeTooManyRequests]: "Too many requests have been sent in a given amount of time",
+  [closeCodeNetwork]: "Networking issues",
+  [closeCodeDependencyGeneric]: "A problem occurred in a dependency of engine-proxy",
+  [closeCodeDependencyUnavailable]: "A dependency is unavailable and not serving any requests",
+  [closeCodeEngineGeneric]: "A problem occurred in an engine",
+  [closeCodeEntitlement]: "You are not entitled to perform that operation",
+  [closeCodeNoEnginesAvailable]: "There are currently no engines available",
+  [CloseCodeSessionReservationMissing]: "The reserved session is missing"
+};
+var uknownCloseErrorMessage = "websocket closed for unknown reason";
+function getHumanReadableSocketClosedErrorMessage(err, { appId, hostConfig }) {
+  const closeCode = err?.original?.code || err?.code;
+  const reason = err?.original?.reason || err?.reason;
+  const closeMessage = closeCode && closeCodeMessages[closeCode] || reason || err.message || uknownCloseErrorMessage;
+  if (hostConfig?.host) {
+    return `Failed to open app ${appId} on ${hostConfig?.host}: ${closeMessage}`;
+  } else {
+    return `Failed to open app ${appId}: ${closeMessage}`;
+  }
+}
+
+export {
+  getHumanReadableSocketClosedErrorMessage
+};

package/chunks/{NBW6PHZU.js → FKDGGR2O.js}

@@ -6,37 +6,79 @@ import {
   isNode
 } from "./2ZQ3ZX7F.js";
 
+// src/auth/internal/host-config-registry.ts
+var registeredHostConfigs = {};
+function registerHostConfigInternal(name, hostConfig) {
+  if (hostConfig?.reference) {
+    throw new InvalidHostConfigError("Cannot register a host config with a reference");
+  }
+  if (registeredHostConfigs[name]) {
+    console.warn(`registerHostConfig: Host config with name "${name}" is already registered. Overwriting.`);
+  }
+  registeredHostConfigs[name] = hostConfig;
+}
+function unregisterHostConfigInternal(name) {
+  if (registeredHostConfigs[name]) {
+    delete registeredHostConfigs[name];
+  } else {
+    console.warn(`unregisterHostConfig: Host config with name "${name}" not found.`);
+  }
+}
+function getRegisteredHostConfigInternal(name) {
+  if (!registeredHostConfigs[name]) {
+    throw new Error(`Host config with name "${name}" not found.`);
+  }
+  return registeredHostConfigs[name];
+}
+
+// src/auth/internal/default-host-config.ts
+var defaultHostConfig = {};
+function setDefaultHostConfigInternal(hostConfig) {
+  defaultHostConfig = hostConfig || {};
+}
+function withResolvedHostConfig(hostConfig) {
+  if (hostConfig?.reference) {
+    return getRegisteredHostConfigInternal(hostConfig.reference);
+  }
+  if (hostConfig && Object.keys(hostConfig).length > 0) {
+    return hostConfig;
+  }
+  return defaultHostConfig;
+}
+
 // src/platform/platform-functions.ts
 var getPlatform = async (options = {}) => {
+  const hc = withResolvedHostConfig(options.hostConfig);
+  const isAnonymous = hc?.authType === "anonymous" || !!hc.accessCode;
   const isNodeEnvironment = typeof window === "undefined";
   if (isNodeEnvironment) {
-    return result({ isNodeEnv: true });
+    return result({ isNodeEnv: true, isAnonymous });
   }
   const { data: productInfo, status } = await getProductInfo(options);
   if (status === 404) {
-    return result({ isUnknown: true });
+    return result({ isUnknown: true, isAnonymous });
   }
   if (!productInfo || status <= 399 && status >= 300) {
-    return result({ isQSE: true, isWindows: true });
+    return result({ isQSE: true, isWindows: true, isAnonymous });
   }
   const deploymentType = (productInfo.composition?.deploymentType || "").toLowerCase();
   const isControlCenter = deploymentType === "controlcenter";
   if (deploymentType === "qliksenseserver") {
-    return result({ isQSE: true, isWindows: true });
+    return result({ isQSE: true, isWindows: true, isAnonymous, meta: extractMeta(productInfo) });
   }
   if (deploymentType === "qliksensedesktop") {
-    return result({ isQSD: true, isWindows: true });
+    return result({ isQSD: true, isWindows: true, isAnonymous, meta: extractMeta(productInfo) });
   }
   if (deploymentType === "qliksensemobile") {
-    return result({ isQSE: true, isWindows: true });
+    return result({ isQSE: true, isWindows: true, isAnonymous, meta: extractMeta(productInfo) });
   }
   if (deploymentType === "cloud-console") {
-    return result({ isCloud: true, isCloudConsole: true });
+    return result({ isCloud: true, isCloudConsole: true, isAnonymous, meta: extractMeta(productInfo) });
   }
   if (productInfo.composition?.provider === "fedramp") {
-    return result({ isCloud: true, isQCG: true, isControlCenter });
+    return result({ isCloud: true, isQCG: true, isControlCenter, isAnonymous, meta: extractMeta(productInfo) });
   }
-  return result({ isCloud: true, isQCS: true, isControlCenter });
+  return result({ isCloud: true, isQCS: true, isControlCenter, isAnonymous, meta: extractMeta(productInfo) });
 };
 var productInfoPromises = {};
 function templateUrl(baseUrl) {
@@ -73,6 +115,27 @@ var getProductInfo = async ({ hostConfig, noCache } = {}) => {
     }
   }
 };
+var extractMeta = (data) => {
+  const urls = data.externalUrls;
+  if (!urls) {
+    return void 0;
+  }
+  const productName = data.composition?.productName ?? "Qlik";
+  const releaseLabel = data.composition?.releaseLabel || "-";
+  const productLabel = releaseLabel === "-" ? productName : `${productName} (${releaseLabel})`;
+  return {
+    productId: data.composition?.senseId ?? "qlik",
+    productLabel,
+    version: data.composition?.version,
+    urls: {
+      personalHelpBaseUrl: urls.personalHelpBaseUrl,
+      personalUpgradeBase: urls.personalUpgradeBase,
+      personalUpgradeUrl: urls.personalUpgradeUrl,
+      serverHelpBaseUrl: urls.serverHelpBaseUrl,
+      qlikWebPageUrl: urls.qlikWebPageUrl
+    }
+  };
+};
 var result = (data) => ({
   isNodeEnv: false,
   isCloud: false,
@@ -84,21 +147,10 @@ var result = (data) => ({
   isQSE: false,
   isQSD: false,
   isUnknown: false,
+  isAnonymous: false,
   ...data
 });
 
-// src/auth/internal/default-host-config.ts
-var defaultHostConfig = {};
-function setDefaultHostConfig(hostConfig) {
-  defaultHostConfig = hostConfig || {};
-}
-function withDefaultHostConfig(hostConfig) {
-  if (hostConfig && Object.keys(hostConfig).length > 0) {
-    return hostConfig;
-  }
-  return defaultHostConfig;
-}
-
 // src/auth/internal/auth-module-registry.ts
 var authModules = {};
 var ongoingAuthModuleLoading = Promise.resolve();
@@ -112,7 +164,7 @@ function getRegisteredAuthModule(authType) {
   return authModules[authType.toLowerCase()];
 }
 async function getAuthModule(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
   const authType = await determineAuthType(hostConfigToUse);
   if (ongoingAuthModuleLoading) {
     await ongoingAuthModuleLoading;
@@ -172,7 +224,7 @@ var InvalidAuthTypeError = class extends Error {
   constructor(authType) {
     const validAuthModules = getRegisteredAuthModules();
     super(
-      `Not a valid auth type: ${authType}, valid auth types are; '${validAuthModules.filter((name) => name !== "QmfeEmbedFramerAuthModule").join("', '")}'`
+      `Not a valid auth type: ${authType}, valid auth types are; '${validAuthModules.filter((name) => name.toLowerCase() !== "qmfeembedframerauthmodule").join("', '")}'`
     );
     this.name = "InvalidAuthTypeError";
   }
@@ -208,7 +260,7 @@ function isHostCrossOrigin(hostConfig) {
   if (!globalThis.location?.origin) {
     return true;
   }
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
   if (Object.keys(hostConfigToUse).length === 0) {
     return false;
   }
@@ -220,7 +272,10 @@ function isHostCrossOrigin(hostConfig) {
   return false;
 }
 async function isWindows(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
+  if (typeof hostConfigToUse.forceIsWindows === "boolean") {
+    return hostConfigToUse.forceIsWindows;
+  }
   if (hostConfigToUse.authType === "cookie") {
     return false;
   }
@@ -230,7 +285,7 @@ async function isWindows(hostConfig) {
   return (await getPlatform({ hostConfig })).isWindows;
 }
 function toValidLocationUrl(hostConfig) {
-  const url = withDefaultHostConfig(hostConfig)?.host;
+  const url = withResolvedHostConfig(hostConfig)?.host;
   let locationUrl;
   if (!url) {
     locationUrl = "";
@@ -245,7 +300,7 @@ function toValidLocationUrl(hostConfig) {
   return locationUrl;
 }
 function toValidWebsocketLocationUrl(hostConfig) {
-  const url = withDefaultHostConfig(hostConfig)?.host;
+  const url = withResolvedHostConfig(hostConfig)?.host;
   let locationUrl;
   if (!url) {
     locationUrl = globalThis.location.origin;
@@ -260,7 +315,7 @@ function toValidWebsocketLocationUrl(hostConfig) {
   return locationUrl.replace(leadingHttp, "ws");
 }
 async function getWebSocketAuthParams(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(props.hostConfig);
   try {
     const authModule = await getAuthModule(hostConfigToUse);
     return await authModule.getWebSocketAuthParams({
@@ -273,7 +328,7 @@ async function getWebSocketAuthParams(props) {
   }
 }
 async function getWebResourceAuthParams(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(props.hostConfig);
   try {
     const authModule = await getAuthModule(hostConfigToUse);
     return await authModule.getWebResourceAuthParams?.({
@@ -286,7 +341,7 @@ async function getWebResourceAuthParams(props) {
   }
 }
 async function handleAuthenticationError(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(props.hostConfig);
   const authModule = await getAuthModule(hostConfigToUse);
   const result2 = await authModule.handleAuthenticationError({
     ...props,
@@ -301,7 +356,7 @@ async function handleAuthenticationError(props) {
   return result2;
 }
 async function getRestCallAuthParams(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(props.hostConfig);
   try {
     const authModule = await getAuthModule(hostConfigToUse);
     return await authModule.getRestCallAuthParams({
@@ -324,11 +379,17 @@ async function getAccessToken(props) {
 function registerAuthModule2(name, authModule) {
   registerAuthModule(name, authModule);
 }
-function setDefaultHostConfig2(hostConfig) {
-  setDefaultHostConfig(hostConfig);
+function setDefaultHostConfig(hostConfig) {
+  setDefaultHostConfigInternal(hostConfig);
+}
+function registerHostConfig(name, hostConfig) {
+  registerHostConfigInternal(name, hostConfig);
+}
+function unregisterHostConfig(name) {
+  unregisterHostConfigInternal(name);
 }
 function serializeHostConfig(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
   return JSON.stringify(hostConfigToUse, hostConfigPropertyIgnorer);
 }
 async function determineAuthType(hostConfig) {
@@ -347,13 +408,16 @@ async function determineAuthType(hostConfig) {
   if (hostConfig.webIntegrationId) {
     return "cookie";
   }
+  if (hostConfig.reference) {
+    return "reference";
+  }
   if (await isWindows(hostConfig)) {
     return "windowscookie";
   }
   return "cookie";
 }
 function checkForCrossDomainRequest(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
   if (isHostCrossOrigin(hostConfigToUse)) {
     if (Object.keys(hostConfigToUse).length === 0) {
       throw new InvalidHostConfigError("a host config must be provided when making a cross domain request");
@@ -446,6 +510,17 @@ function internalValidateHostConfig(hostConfig, options) {
   return true;
 }
 
+// src/utils/expose-internal-test-apis.ts
+var internalApisName = "__QLIK_INTERNAL__DO_NOT_USE_OR_YOU_WILL_BE_FIRED";
+function exposeInternalApiOnWindow(name, fn) {
+  if (globalThis.location?.origin.startsWith("https://localhost:") || globalThis.location?.origin?.endsWith("qlik-stage.com")) {
+    if (globalThis[internalApisName] === void 0) {
+      globalThis[internalApisName] = {};
+    }
+    globalThis[internalApisName][name] = fn;
+  }
+}
+
 // src/auth/internal/default-auth-modules/oauth/storage-helpers.ts
 var storagePrefix = "qlik-qmfe-api";
 function getTopicFromOauthHostConfig(hostConfig) {
@@ -462,6 +537,20 @@ function getTopicFromAnonHostConfig(hostConfig) {
   return `${hostConfig.accessCode}_${hostConfig.clientId}`;
 }
 var cachedTokens = {};
+function clearAllCachedTokens() {
+  for (const key in cachedTokens) {
+    delete cachedTokens[key];
+  }
+}
+exposeInternalApiOnWindow("clearAllAccessTokens", () => {
+  console.log("Clearing tokens", cachedTokens);
+  Object.keys(cachedTokens).forEach((key) => {
+    console.log("Clearing access tokens for", key);
+    deleteFromLocalStorage(key, ["access-token", "refresh-token"]);
+    deleteFromSessionStorage(key, ["access-token", "refresh-token"]);
+  });
+  clearAllCachedTokens();
+});
 function saveInLocalStorage(topic, name, value) {
   localStorage.setItem(`${storagePrefix}-${topic}-${name}`, value);
 }
@@ -530,6 +619,7 @@ async function loadOrAcquireAccessToken(topic, acquireTokens, noCache, accessTok
   const mayUseStorage = isBrowser();
   const storedOauthTokens = cachedTokens[topic] || (mayUseStorage ? loadOauthTokensFromStorage(topic, accessTokenStorage) : void 0);
   if (storedOauthTokens) {
+    cachedTokens[topic] = storedOauthTokens;
     return Promise.resolve(storedOauthTokens);
   }
   const tokensPromise = acquireTokens();
@@ -1394,6 +1484,23 @@ var oauth_default = {
   })
 };
 
+// src/auth/internal/default-auth-modules/reference.ts
+function getRestCallAuthParams7() {
+  throw new Error("getRestCallAuthParams should never be called for reference auth module");
+}
+function getWebSocketAuthParams7() {
+  throw new Error("getWebSocketAuthParams should never be called for reference auth module");
+}
+function handleAuthenticationError7() {
+  throw new Error("handleAuthenticationError should never be called for reference auth module");
+}
+var reference_default = {
+  getRestCallAuthParams: getRestCallAuthParams7,
+  getWebSocketAuthParams: getWebSocketAuthParams7,
+  handleAuthenticationError: handleAuthenticationError7,
+  validateHostConfig: (hostConfig) => internalValidateHostConfig(hostConfig, { requiredProps: ["reference"], optionalProps: [] })
+};
+
 // src/auth/internal/default-auth-modules/windows-cookie/xrf-keys.ts
 var xrfKeys = {};
 function createXrfKey() {
@@ -1417,7 +1524,7 @@ function getXrfKey(hostConfig) {
 }
 
 // src/auth/internal/default-auth-modules/windows-cookie.ts
-async function getRestCallAuthParams7({
+async function getRestCallAuthParams8({
   hostConfig
 }) {
   return {
@@ -1430,7 +1537,7 @@ async function getRestCallAuthParams7({
     credentials: getCredentialsForCookieAuth(hostConfig)
   };
 }
-async function getWebSocketAuthParams7({
+async function getWebSocketAuthParams8({
   hostConfig
 }) {
   return {
@@ -1440,7 +1547,7 @@ async function getWebSocketAuthParams7({
     }
   };
 }
-async function handleAuthenticationError7({
+async function handleAuthenticationError8({
   hostConfig
 }) {
   if (hostConfig.loginUri) {
@@ -1459,9 +1566,9 @@ async function handleAuthenticationError7({
   };
 }
 var windows_cookie_default = {
-  getRestCallAuthParams: getRestCallAuthParams7,
-  getWebSocketAuthParams: getWebSocketAuthParams7,
-  handleAuthenticationError: handleAuthenticationError7,
+  getRestCallAuthParams: getRestCallAuthParams8,
+  getWebSocketAuthParams: getWebSocketAuthParams8,
+  handleAuthenticationError: handleAuthenticationError8,
   validateHostConfig: (hostConfig) => internalValidateHostConfig(hostConfig, {
     requiredProps: [],
     optionalProps: ["loginUri", "crossSiteCookies"]
@@ -1479,6 +1586,7 @@ function registerDefaultAuthModules() {
     registerAuthModule("oauth2", oauth_default);
     registerAuthModule("anonymous", anonymous_default);
     registerAuthModule("windowscookie", windows_cookie_default);
+    registerAuthModule("reference", reference_default);
     authModulesRegistered = true;
   }
 }
@@ -1486,7 +1594,9 @@ registerDefaultAuthModules();
 var auth = {
   logout,
   registerAuthModule,
-  setDefaultHostConfig: setDefaultHostConfig2,
+  setDefaultHostConfig,
+  registerHostConfig,
+  unregisterHostConfig,
   getRestCallAuthParams,
   getWebSocketAuthParams,
   getWebResourceAuthParams,
@@ -2103,9 +2213,9 @@ function cleanStack(stack) {
 // src/invoke-fetch/invoke-fetch-functions.ts
 var defaultUserAgent = "qmfe-api/latest";
 async function invokeFetch(api, props, interceptors) {
-  interceptors = interceptors || getInterceptors();
+  const effectiveInterceptors = interceptors || getInterceptors();
   const invokeFetchFinal = (reqeust) => invokeFetchIntercepted(api, reqeust);
-  const withInterceptors = (interceptors || []).reduce(
+  const withInterceptors = (effectiveInterceptors || []).reduce(
     (proceed, interceptor) => (request) => interceptor(request, proceed),
     invokeFetchFinal
   );
@@ -2215,12 +2325,15 @@ export {
   getRestCallAuthParams,
   getAccessToken,
   registerAuthModule2 as registerAuthModule,
-  setDefaultHostConfig2 as setDefaultHostConfig,
+  setDefaultHostConfig,
+  registerHostConfig,
+  unregisterHostConfig,
   serializeHostConfig,
   determineAuthType,
   checkForCrossDomainRequest,
   logout,
   generateRandomString,
+  exposeInternalApiOnWindow,
   InvokeFetchError,
   EncodingError,
   invokeFetch,

package/chunks/{KYCIMQ4L.js → GUU3KZGK.js}

@@ -1,6 +1,6 @@
 import {
   getAuthRuntimeModule
-} from "./2B7YWDQC.js";
+} from "./DLKLPD7T.js";
 
 // src/public/auth.ts
 function registerAuthModule(name, authModule) {
@@ -12,12 +12,20 @@ function logout() {
 function setDefaultHostConfig(hostConfig) {
   void getAuthRuntimeModule(hostConfig).then((impl) => impl.setDefaultHostConfig(hostConfig));
 }
+function registerHostConfig(name, hostConfig) {
+  void getAuthRuntimeModule(hostConfig).then((impl) => impl.registerHostConfig(name, hostConfig));
+}
+function unregisterHostConfig(name) {
+  void getAuthRuntimeModule().then((impl) => impl.unregisterHostConfig(name));
+}
 async function getAccessToken({ hostConfig }) {
   return getAuthRuntimeModule(hostConfig).then((impl) => impl.getAccessToken({ hostConfig }));
 }
 var auth_default = {
   registerAuthModule,
   setDefaultHostConfig,
+  registerHostConfig,
+  unregisterHostConfig,
   getAccessToken
 };
 
@@ -25,6 +33,8 @@ export {
   registerAuthModule,
   logout,
   setDefaultHostConfig,
+  registerHostConfig,
+  unregisterHostConfig,
   getAccessToken,
   auth_default
 };

package/chunks/{5XNSGPGZ.js → KBSD75QL.js}

@@ -1,6 +1,6 @@
 import {
   getQixRuntimeModule
-} from "./2B7YWDQC.js";
+} from "./DLKLPD7T.js";
 
 // src/public/qix.ts
 function openAppSession(appSessionProps) {

package/chunks/{4D5NADHK.js → LY7RP2HA.js}

@@ -15,11 +15,13 @@ import {
   isWindows,
   logout,
   registerAuthModule,
+  registerHostConfig,
   serializeHostConfig,
   setDefaultHostConfig,
   toValidLocationUrl,
-  toValidWebsocketLocationUrl
-} from "./NBW6PHZU.js";
+  toValidWebsocketLocationUrl,
+  unregisterHostConfig
+} from "./FKDGGR2O.js";
 import "./3RGGGGAR.js";
 import "./2ZQ3ZX7F.js";
 export {
@@ -39,8 +41,10 @@ export {
   isWindows,
   logout,
   registerAuthModule,
+  registerHostConfig,
   serializeHostConfig,
   setDefaultHostConfig,
   toValidLocationUrl,
-  toValidWebsocketLocationUrl
+  toValidWebsocketLocationUrl,
+  unregisterHostConfig
 };