@zenify-omni/chat-js 0.1.0

package/utils/request.js

@@ -0,0 +1,461 @@
+import axios from "axios";
+import {
+  checkIsViewAsMode,
+  getUser,
+  markSessionEnded,
+  SessionEndReason
+} from "./auth.js";
+import { logout } from "./session-end.js";
+import { AxiosError } from "../exceptions/axios-error.js";
+import { HttpsError } from "../exceptions/https-error.js";
+import { ValidatorError } from "../exceptions/validator-error.js";
+import { createSingleFlight } from "./concurrency-limiter.js";
+import i18n from "../lib/i18n/index.js";
+import { env } from "../config/env.js";
+const APP_VERSION_HEADER = "x-app-version";
+const APP_VERSION = "2.0";
+const REQUEST_TIMEOUT_MS = 6e4;
+const withLazyBaseURL = (instance, getBaseURL) => {
+  instance.interceptors.request.use((config) => {
+    if (!config.baseURL) config.baseURL = getBaseURL();
+    return config;
+  });
+  return instance;
+};
+const apiInstance = withLazyBaseURL(
+  axios.create({ timeout: REQUEST_TIMEOUT_MS }),
+  () => env.API_EVS_URL
+);
+const emailInstance = withLazyBaseURL(
+  axios.create({ timeout: REQUEST_TIMEOUT_MS }),
+  () => env.EMAIL_URL || "https://api.zenify.vn/emailgateway"
+);
+const cdnInstance = withLazyBaseURL(
+  axios.create(),
+  () => env.CDN_URL || "https://cdn.zenify.vn"
+);
+const apiZaloInstance = withLazyBaseURL(
+  axios.create({ timeout: REQUEST_TIMEOUT_MS }),
+  () => env.ZALO_LOGIN_URL
+);
+const apiHubInstance = withLazyBaseURL(
+  axios.create({ timeout: REQUEST_TIMEOUT_MS }),
+  () => env.HUB_URL || "https://apihub.zenify.vn"
+);
+const msgHubInstance = withLazyBaseURL(
+  axios.create({ timeout: REQUEST_TIMEOUT_MS }),
+  () => env.MSG_HUB_URL || "https://msghub.zenify.vn"
+);
+const authBaseURL = () => env.AUTH_URL || env.HUB_URL || "https://apihub.zenify.vn";
+const apiAuthInstance = withLazyBaseURL(axios.create(), authBaseURL);
+const refreshInstance = withLazyBaseURL(axios.create(), authBaseURL);
+const REFRESH_ENDPOINT = "/auth/refresh";
+const omapInstance = withLazyBaseURL(
+  axios.create({ timeout: REQUEST_TIMEOUT_MS }),
+  () => env.OMAP_URL || `${env.API_EVS_URL}/omap`
+);
+const ottGatewayInstance = withLazyBaseURL(
+  axios.create({ timeout: REQUEST_TIMEOUT_MS }),
+  () => env.OTT_GATEWAY_URL ? `${env.OTT_GATEWAY_URL}/ottgateway` : "https://chat.zenify.vn/ottgateway"
+);
+const successInterceptor = (response) => {
+  if (response.status === 204) {
+    return Promise.resolve({});
+  }
+  const status = response.data.statusCode || response.data.status;
+  if (response.data) {
+    if (response.data instanceof Blob) {
+      return Promise.resolve(response.data);
+    }
+    if (status === 200 || status === 201) {
+      return Promise.resolve(response.data);
+    }
+  }
+  const message = response.data.message;
+  return Promise.reject(new HttpsError({ status, message }));
+};
+const matchesStatus = (error, code) => error.response?.data?.status === code || error.response?.data?.statusCode === code || error.response?.status === code;
+const AUTH_TOKEN_EXPIRED = "AUTH_TOKEN_EXPIRED";
+const AUTH_TOKEN_INVALID = "AUTH_TOKEN_INVALID";
+const REFRESHABLE_AUTH_CODES = /* @__PURE__ */ new Set([AUTH_TOKEN_EXPIRED, AUTH_TOKEN_INVALID]);
+const isRefreshableAuthCode = (code) => REFRESHABLE_AUTH_CODES.has(code);
+const AUTH_SESSION_REVOKED = "AUTH_SESSION_REVOKED";
+const REPLAYED_FLAG = "__authRefreshReplayed";
+const readStoredUser = () => {
+  try {
+    return JSON.parse(localStorage.getItem("zenify-sdk-user"));
+  } catch {
+    return null;
+  }
+};
+const DEFINITIVE_REFRESH_REJECTIONS = /* @__PURE__ */ new Set([400, 401, 403]);
+class RefreshFailed extends Error {
+  constructor(definitive, cause) {
+    super("Refresh failed");
+    this.name = "RefreshFailed";
+    this.definitive = definitive;
+    this.cause = cause;
+  }
+}
+const performRefresh = async () => {
+  const refreshToken = readStoredUser()?.refresh_token;
+  if (!refreshToken) throw new RefreshFailed(true);
+  let response;
+  try {
+    response = await refreshInstance.post(REFRESH_ENDPOINT, {
+      refresh_token: refreshToken
+    });
+  } catch (err) {
+    const status = err.response?.status;
+    throw new RefreshFailed(DEFINITIVE_REFRESH_REJECTIONS.has(status), err);
+  }
+  const payload = response.data?.data ?? response.data;
+  if (!payload?.token || !payload?.refresh_token) {
+    throw new RefreshFailed(false);
+  }
+  const stored = readStoredUser();
+  if (!stored) throw new RefreshFailed(true);
+  localStorage.setItem(
+    "zenify-sdk-user",
+    JSON.stringify({
+      ...stored,
+      token: payload.token,
+      refresh_token: payload.refresh_token
+    })
+  );
+  return payload.token;
+};
+const singleFlightRefresh = createSingleFlight();
+const refreshAccessToken = () => singleFlightRefresh("access-token", performRefresh);
+const replayWithToken = (error, token, onResponse, onError) => {
+  const config = error.config;
+  config[REPLAYED_FLAG] = true;
+  const headers = config.headers;
+  const previous = (typeof headers?.get === "function" ? headers.get("Authorization") : headers?.Authorization) || "";
+  const next = typeof previous === "string" && previous.startsWith("Bearer ") ? `Bearer ${token}` : token;
+  if (typeof headers?.set === "function") {
+    headers.set("Authorization", next);
+  } else {
+    config.headers = { ...headers, Authorization: next };
+  }
+  return axios(config).then(onResponse, onError);
+};
+const makeErrorInterceptor = ({
+  logoutOnUnauthorized = true,
+  // Whether an AUTH_TOKEN_EXPIRED body may trigger refresh-then-replay.
+  refreshOnExpired = true,
+  // How a REPLAYED response is unwrapped — must match the success interceptor
+  // registered on the instance this error interceptor belongs to.
+  onReplayResponse = successInterceptor,
+  // When false the error is re-rejected untouched instead of being converted to
+  // an HttpsError. Used for apiZaloInstance, whose call sites consume the raw
+  // axios response/error and must not change behaviour.
+  transformError = true
+} = {}) => {
+  const endSession = (error) => {
+    if (checkIsViewAsMode()) {
+      console.log("Spy mode detected, not logging out");
+    } else {
+      markSessionEnded(
+        error?.response?.data?.code === AUTH_SESSION_REVOKED ? SessionEndReason.REVOKED : SessionEndReason.EXPIRED
+      );
+      logout(true);
+    }
+  };
+  const handle = (error, { allowLogout = true } = {}) => {
+    if (!transformError) return Promise.reject(error);
+    if (allowLogout && logoutOnUnauthorized && matchesStatus(error, 401)) {
+      endSession(error);
+    }
+    if (error.response && matchesStatus(error, 403)) {
+      const message = error.response.data?.message;
+      return Promise.reject(
+        new HttpsError({ status: 403, message, data: error.response.data })
+      );
+    }
+    if (error.message === "Network Error") {
+    }
+    if (error.response && error.response.data) {
+      const status = error.response.data.status || error.response.data.statusCode || error.response.status;
+      if (status === 422) {
+        const errors = error.response.data;
+        return Promise.reject(new ValidatorError(errors));
+      } else {
+        const message = error.response.data.message;
+        return Promise.reject(
+          new HttpsError({ status, message, data: error.response.data })
+        );
+      }
+    } else {
+      const { code } = error;
+      return Promise.reject(new AxiosError({ code }));
+    }
+  };
+  const interceptor = (error) => {
+    const shouldRefresh = refreshOnExpired && !!error.response && isRefreshableAuthCode(error.response.data?.code) && !error.config?.[REPLAYED_FLAG] && // View-as (spy) mode borrows the target's token from sessionStorage;
+    // refreshing here would rotate the REAL user's session behind their back.
+    !checkIsViewAsMode();
+    if (!shouldRefresh) return handle(error);
+    return refreshAccessToken().then(
+      (token) => replayWithToken(error, token, onReplayResponse, interceptor),
+      (failure) => {
+        if (failure?.definitive) endSession(error);
+        return handle(error, { allowLogout: false });
+      }
+    );
+  };
+  return interceptor;
+};
+const errorInterceptor = makeErrorInterceptor();
+const zaloErrorInterceptor = makeErrorInterceptor({
+  transformError: false,
+  onReplayResponse: (response) => response
+});
+const authErrorInterceptor = makeErrorInterceptor({
+  logoutOnUnauthorized: false,
+  refreshOnExpired: false
+});
+apiInstance.defaults.headers.common[APP_VERSION_HEADER] = APP_VERSION;
+if (typeof __APP_VERSION__ !== "undefined") {
+  apiAuthInstance.defaults.headers.common[APP_VERSION_HEADER] = __APP_VERSION__;
+}
+const localizedInstances = [apiInstance, apiHubInstance];
+const applyAcceptLanguage = (lng) => {
+  const value = lng || i18n.resolvedLanguage || i18n.language;
+  localizedInstances.forEach((instance) => {
+    instance.defaults.headers.common["Accept-Language"] = value;
+  });
+};
+applyAcceptLanguage(i18n.resolvedLanguage || i18n.language);
+i18n.on("languageChanged", applyAcceptLanguage);
+const exemptFileDownloadTimeout = (config) => {
+  if (config.responseType === "blob" || config.responseType === "arraybuffer") {
+    config.timeout = 0;
+  }
+  return config;
+};
+[
+  apiInstance,
+  emailInstance,
+  apiZaloInstance,
+  apiHubInstance,
+  msgHubInstance,
+  omapInstance,
+  ottGatewayInstance
+].forEach((instance) => {
+  instance.interceptors.request.use(exemptFileDownloadTimeout);
+});
+apiInstance.interceptors.response.use(successInterceptor, errorInterceptor);
+emailInstance.interceptors.response.use(successInterceptor, errorInterceptor);
+cdnInstance.interceptors.response.use(successInterceptor, errorInterceptor);
+apiHubInstance.interceptors.response.use(successInterceptor, errorInterceptor);
+msgHubInstance.interceptors.response.use(successInterceptor, errorInterceptor);
+omapInstance.interceptors.response.use(successInterceptor, errorInterceptor);
+ottGatewayInstance.interceptors.response.use(
+  successInterceptor,
+  errorInterceptor
+);
+apiZaloInstance.interceptors.response.use(void 0, zaloErrorInterceptor);
+apiAuthInstance.interceptors.response.use(
+  successInterceptor,
+  authErrorInterceptor
+);
+const requestApi = async ({
+  endpoint,
+  isPublicApi = false,
+  customHeaders = {},
+  ...axiosArgs
+} = {}) => {
+  let token;
+  if (!isPublicApi) {
+    const user = await getUser();
+    token = user?.token;
+  }
+  const headers = {
+    Authorization: token,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    ...customHeaders
+  };
+  return apiInstance(endpoint, {
+    headers,
+    ...axiosArgs
+  });
+};
+const postWithFile = async ({
+  endpoint,
+  customHeaders = {},
+  ...axiosArgs
+} = {}) => {
+  const user = await getUser();
+  const headers = {
+    Authorization: user?.token,
+    ...customHeaders
+  };
+  const formData = axiosArgs.data instanceof FormData ? axiosArgs.data : Object.entries(axiosArgs.data || {}).reduce((fd, [key, value]) => {
+    fd.append(key, value);
+    return fd;
+  }, new FormData());
+  return apiInstance.post(endpoint, formData, {
+    headers,
+    ...axiosArgs
+  });
+};
+const requestCdn = async ({
+  endpoint,
+  isPublicApi = false,
+  ...axiosArgs
+}) => {
+  let token;
+  if (!isPublicApi) {
+    const user = await getUser;
+    token = user?.token;
+  }
+  const headers = {
+    "Content-Type": "multipart/form-data",
+    Authorization: token
+  };
+  return cdnInstance(endpoint, {
+    headers,
+    ...axiosArgs
+  });
+};
+const requestEmail = async ({
+  endpoint,
+  isPublicApi = false,
+  ...axiosArgs
+} = {}) => {
+  let token;
+  if (!isPublicApi) {
+    const user = await getUser();
+    token = user?.token;
+  }
+  const headers = {
+    Authorization: token,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  return emailInstance(endpoint, {
+    headers,
+    ...axiosArgs
+  });
+};
+const requestZaloApi = async ({ endpoint, ...axiosArgs } = {}) => {
+  const user = getUser();
+  const token = user?.token;
+  const headers = {
+    Authorization: token,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    ...axiosArgs?.headers ?? {}
+  };
+  delete axiosArgs.headers;
+  return apiZaloInstance(endpoint, {
+    headers,
+    ...axiosArgs
+  });
+};
+const requestAuthApi = ({
+  endpoint,
+  customHeaders = {},
+  ...axiosArgs
+} = {}) => apiAuthInstance(endpoint, {
+  headers: {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    ...customHeaders
+  },
+  ...axiosArgs
+});
+class MissingAccessTokenError extends Error {
+  constructor(endpoint) {
+    super(`No access token for hub request ${endpoint}`);
+    this.name = "MissingAccessTokenError";
+    this.code = "NO_ACCESS_TOKEN";
+  }
+}
+const requestHubApi = async ({ endpoint, ...axiosArgs } = {}) => {
+  const user = getUser();
+  const token = user?.token;
+  if (!token) throw new MissingAccessTokenError(endpoint);
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    ...axiosArgs?.headers ?? {}
+  };
+  delete axiosArgs.headers;
+  return apiHubInstance(endpoint, {
+    headers,
+    ...axiosArgs
+  });
+};
+const requestMsgHubApi = async ({ endpoint, ...axiosArgs } = {}) => {
+  const headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    ...axiosArgs?.headers ?? {}
+  };
+  delete axiosArgs.headers;
+  return msgHubInstance(endpoint, {
+    headers,
+    ...axiosArgs
+  });
+};
+const requestOttApi = async ({
+  endpoint,
+  isPublicApi = false,
+  customHeaders = {},
+  ...axiosArgs
+} = {}) => {
+  let token;
+  if (!isPublicApi) {
+    const user = await getUser();
+    token = user?.token;
+  }
+  const headers = {
+    Authorization: token,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    ...customHeaders
+  };
+  return ottGatewayInstance(endpoint, {
+    headers,
+    ...axiosArgs
+  });
+};
+const requestOttApiWithFile = async ({
+  endpoint,
+  params,
+  ...axiosArgs
+} = {}) => {
+  const user = await getUser();
+  const formData = axiosArgs.data instanceof FormData ? axiosArgs.data : Object.entries(axiosArgs.data || {}).reduce((fd, [key, value]) => {
+    fd.append(key, value);
+    return fd;
+  }, new FormData());
+  return ottGatewayInstance.post(endpoint, formData, {
+    params,
+    headers: { Authorization: user?.token }
+  });
+};
+export {
+  APP_VERSION,
+  APP_VERSION_HEADER,
+  AUTH_TOKEN_EXPIRED,
+  apiInstance,
+  errorInterceptor,
+  isRefreshableAuthCode,
+  makeErrorInterceptor,
+  postWithFile,
+  refreshAccessToken,
+  requestApi,
+  requestAuthApi,
+  requestCdn,
+  requestEmail,
+  requestHubApi,
+  requestMsgHubApi,
+  requestOttApi,
+  requestOttApiWithFile,
+  requestZaloApi
+};

package/utils/session-end.js

@@ -0,0 +1,19 @@
+import { LOGOUT_EVENT, PRE_LOGOUT_EVENT } from "../constants/events.js";
+import { getSessionEndReason, SessionEndReason } from "./auth.js";
+import { logoutSession } from "../api/session.js";
+import { sendSessionEndBeacon } from "../api/session-event.js";
+const mapReason = (r) => r === SessionEndReason.REVOKED ? "session_revoked" : r === SessionEndReason.EXPIRED ? "token_invalid" : r === SessionEndReason.LEGACY ? "forbidden" : "refresh_failed";
+const logout = (isExpired = false) => {
+  document.dispatchEvent(new CustomEvent(PRE_LOGOUT_EVENT));
+  if (!isExpired) {
+    logoutSession().catch(() => {
+    });
+  } else {
+    sendSessionEndBeacon(mapReason(getSessionEndReason()));
+  }
+  const ev = new CustomEvent(LOGOUT_EVENT, { detail: { isExpired } });
+  document.dispatchEvent(ev);
+};
+export {
+  logout
+};

package/utils/string.js

@@ -0,0 +1,154 @@
+import { URL_REGEX, BARE_URL_REGEX } from "../constants/regex.js";
+const toHref = (url) => url.startsWith("http://") || url.startsWith("https://") ? url : `https://${url}`;
+const matchFirstUrl = (str) => {
+  if (!str) return null;
+  const httpMatch = str.match(new RegExp(URL_REGEX.source, URL_REGEX.flags));
+  const bareMatch = str.match(
+    new RegExp(BARE_URL_REGEX.source, BARE_URL_REGEX.flags)
+  );
+  if (!httpMatch && !bareMatch) return null;
+  const httpIndex = httpMatch ? str.indexOf(httpMatch[0]) : Infinity;
+  const bareIndex = bareMatch ? str.indexOf(bareMatch[0]) : Infinity;
+  if (httpIndex <= bareIndex) return { url: httpMatch[0], href: httpMatch[0] };
+  return { url: bareMatch[0], href: `https://${bareMatch[0]}` };
+};
+const findAllUrlMatches = (str) => {
+  if (!str) return [];
+  const httpMatches = [
+    ...str.matchAll(new RegExp(URL_REGEX.source, URL_REGEX.flags))
+  ].map((m) => ({ url: m[0], href: m[0], index: m.index }));
+  const bareMatches = [
+    ...str.matchAll(new RegExp(BARE_URL_REGEX.source, BARE_URL_REGEX.flags))
+  ].filter(
+    (m) => !httpMatches.some(
+      (h) => m.index >= h.index && m.index < h.index + h.url.length
+    )
+  ).map((m) => ({ url: m[0], href: `https://${m[0]}`, index: m.index }));
+  return [...httpMatches, ...bareMatches].sort((a, b) => a.index - b.index);
+};
+const removeVietnameseTones = (str) => {
+  if (!str) return "";
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/đ/g, "d").replace(/Đ/g, "D").replace(/[^a-zA-Z0-9\s]/g, "");
+};
+const convertURLsToLinks = (str) => {
+  if (!str) return str;
+  const toAnchor = (url) => `
+<a href="${toHref(url)}" target="_blank" rel="noopener noreferrer" class="text-primary underline">${url}</a>
+`;
+  return str.replace(new RegExp(URL_REGEX.source, URL_REGEX.flags), toAnchor).replace(new RegExp(BARE_URL_REGEX.source, BARE_URL_REGEX.flags), toAnchor);
+};
+const MARK = 'data-mention-formatted="1"';
+const stripMentionSpans = (html = "") => {
+  html = html.replace(
+    /<span\b[^>]*\bdata-mention-(?:formatted|highlight)="1"[^>]*>(.*?)<\/span>/gis,
+    "$1"
+  );
+  html = html.replace(
+    /<span\b[^>]*class="[^"]*\btext-primary\b[^"]*"[^>]*>(.*?)<\/span>/gis,
+    "$1"
+  );
+  return html;
+};
+const withMentionsHighlighted = (message) => {
+  if (message?.extra_data?.mention_infos && !message?.extra_data?.is_undo && !message?.extra_data?.is_deleted) {
+    return highlightMentions(message.content, message.extra_data.mention_infos);
+  }
+  return message?.content;
+};
+const removeMentionColor = (html) => {
+  if (!html) return html;
+  return html.replace(/text-primary/g, "");
+};
+const getFirstURL = (str) => {
+  if (!str) return null;
+  return matchFirstUrl(String(str))?.href ?? null;
+};
+const isValidURL = (str) => {
+  if (!str) return false;
+  return findAllUrlMatches(str).length > 0;
+};
+const unwrapRedirectUrl = (url) => {
+  if (!url) return url;
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname.toLowerCase();
+    if (host === "l.facebook.com" || host === "lm.facebook.com") {
+      const target = parsed.searchParams.get("u");
+      if (target) return target;
+    }
+  } catch {
+    return url;
+  }
+  return url;
+};
+const parseMessageUrl = (message) => {
+  if (!message) return { previewUrl: null, beforeText: "", afterText: "" };
+  const matches = findAllUrlMatches(message);
+  if (!matches.length)
+    return { previewUrl: null, beforeText: message, afterText: "" };
+  const { url, href, index } = matches[0];
+  return {
+    previewUrl: href,
+    beforeText: message.substring(0, index),
+    afterText: message.substring(index + url.length)
+  };
+};
+const IMAGE_EXTENSION_REGEX = /\.(jpg|jpeg|png|gif|webp|bmp|svg|avif)(\?[^#]*)?$/i;
+const isImageUrl = (url) => {
+  try {
+    return IMAGE_EXTENSION_REGEX.test(new URL(url).pathname);
+  } catch {
+    return false;
+  }
+};
+const parseMessageUrls = (message, separatorRegex = "||") => {
+  if (!message) return { previewUrls: [], beforeText: "", afterText: "" };
+  const freshRegex = new RegExp(`^${URL_REGEX.source}$`, "i");
+  const effectiveSeparator = separatorRegex === "||" ? /\|\||\n/ : separatorRegex;
+  const segments = message.split(effectiveSeparator);
+  const previewUrls = [];
+  let firstImageIdx = -1;
+  let lastImageIdx = -1;
+  segments.forEach((segment, i) => {
+    const trimmed = segment.trim();
+    if (freshRegex.test(trimmed) && isImageUrl(trimmed)) {
+      previewUrls.push(trimmed);
+      if (firstImageIdx === -1) firstImageIdx = i;
+      lastImageIdx = i;
+    }
+  });
+  if (!previewUrls.length)
+    return { previewUrls: [], beforeText: message.trim(), afterText: "" };
+  const beforeText = segments.slice(0, firstImageIdx).map((s) => s.trim()).filter(Boolean).join("\n").trim();
+  const afterText = segments.slice(lastImageIdx + 1).map((s) => s.trim()).filter(Boolean).join("\n").trim();
+  return { previewUrls, beforeText, afterText };
+};
+const highlightMentions = (content, mentionInfos) => {
+  if (!mentionInfos?.mention_to?.length || !mentionInfos?.txt) return content;
+  const mentionTxt = mentionInfos?.txt ?? content.text;
+  let html = stripMentionSpans(mentionTxt);
+  const mentions = [...mentionInfos.mention_to].sort(
+    (a, b) => b.length - a.length
+  );
+  mentions.forEach((mention) => {
+    const escaped = mention.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(escaped, "g");
+    html = html.replace(
+      regex,
+      `<span ${MARK} class="text-primary font-normal">${mention}</span>`
+    );
+  });
+  return { ...content, text: html };
+};
+export {
+  convertURLsToLinks,
+  getFirstURL,
+  highlightMentions,
+  isValidURL,
+  parseMessageUrl,
+  parseMessageUrls,
+  removeMentionColor,
+  removeVietnameseTones,
+  unwrapRedirectUrl,
+  withMentionsHighlighted
+};