@greatapps/common 1.1.795 → 1.1.797

package/src/modules/whitelabel/services/whitelabel.service.ts

@@ -1,209 +1,300 @@
-import greatCache from "@greatapps/cache";
-import { ApiError } from "../../../infra/api/types";
-import { WhitelabelTokenApiResponse, WhitelabelTokenData } from "../schema";
-import { normalizeHostname } from "../utils/normalize-hostname";
-
-class WhitelabelService {
-  private getApiUrl(): string {
-    const apiUrl = process.env.GAPPS_R3_API_URL;
-    if (!apiUrl) {
-      throw new ApiError(
-        "GAPPS_R3_API_URL not configured",
-        "CONFIG_ERROR",
-        500,
-      );
-    }
-    return apiUrl;
-  }
-
-  private getToken(): string {
-    const token = process.env.WHITELABEL_TOKEN_MASTER;
-    if (!token) {
-      throw new ApiError(
-        "WHITELABEL_TOKEN_MASTER not configured",
-        "CONFIG_ERROR",
-        500,
-      );
-    }
-    return token;
-  }
-
-  private createCache() {
-    return new greatCache({
-      service: "whitelabel-service",
-      version: "1.0.3",
-      domain: "whitelabel-cache.greatapps.com.br",
-      ambient: process.env.NODE_ENV || "development",
-    });
-  }
-
-  private getCacheKey(hostname: string): string {
-    return `whitelabel-token-${hostname}`;
-  }
-
-  private async fetchFromApi(hostname: string): Promise<WhitelabelTokenData> {
-    const apiUrl = this.getApiUrl();
-    const whitelabelMasterToken = this.getToken();
-    const url = `${apiUrl}/v1/pt-br/1/whitelabel/${hostname}/token`;
-
-    console.log("[WhitelabelService] Fetching token for domain", { url });
-
-    const response = await fetch(url, {
-      method: "GET",
-      headers: {
-        authorization: whitelabelMasterToken,
-      },
-    });
-
-    if (!response.ok) {
-      console.error("[WhitelabelService] Failed to fetch whitelabel token", {
-        response,
-      });
-      throw new ApiError(
-        `Failed to fetch whitelabel token: ${response.status}`,
-        "FETCH_ERROR",
-        response.status,
-      );
-    }
-
-    const result: WhitelabelTokenApiResponse = await response.json();
-
-    if (result.status !== 1 || !result.data?.length) {
-      throw new ApiError("Whitelabel token not found", "TOKEN_NOT_FOUND", 404);
-    }
-
-    return result.data[0];
-  }
-
-  async getTokenByDomain(hostname: string): Promise<WhitelabelTokenData> {
-    hostname = `${normalizeHostname(process.env.WHITELABEL_DOMAIN || hostname)}`;
-    console.debug("[WhitelabelService] Getting token for domain", {
-      hostname,
-      byEnv: process.env.WHITELABEL_DOMAIN,
-    });
-
-    const cache = this.createCache();
-    const cacheKey = this.getCacheKey(hostname);
-
-    const cachedData = await cache.select(cacheKey);
-    console.debug("[WhitelabelService] Cache lookup for domain", {
-      cacheKey,
-      cachedData,
-    });
-
-    if (cachedData.status == 1 && "data" in cachedData && cachedData.data) {
-      const cachedWhitelabel = JSON.parse(cachedData.data) as WhitelabelTokenData;
-
-      if (this.#matchesHostname(cachedWhitelabel, hostname)) {
-        console.log("[WhitelabelService] Cache hit for domain", { hostname });
-        return cachedWhitelabel;
-      }
-
-      console.error("[WhitelabelService] Cached whitelabel does not match hostname", {
-        hostname,
-        cacheKey,
-        whitelabelId: cachedWhitelabel.id,
-        whitelabelDomain: cachedWhitelabel.domain,
-      });
-
-      await cache.delete(cacheKey);
-    }
-
-    const data = await this.fetchFromApi(hostname);
-
-    if (!this.#matchesHostname(data, hostname)) {
-      console.error("[WhitelabelService] API returned whitelabel of another hostname", {
-        hostname,
-        whitelabelId: data.id,
-        whitelabelDomain: data.domain,
-      });
-      return data;
-    }
-
-    await cache.insert(cacheKey, JSON.stringify(data), 604800);
-
-    return data;
-  }
-
-  #matchesHostname(data: WhitelabelTokenData, hostname: string): boolean {
-    if (!data.domain) return true;
-
-    try {
-      return normalizeHostname(new URL(data.domain).hostname) === hostname;
-    } catch {
-      return true;
-    }
-  }
-
-  async getTokenByWhitelabelId(idWl: number): Promise<string> {
-    const apiUrl = this.getApiUrl();
-    const masterToken = this.getToken();
-    const url = `${apiUrl}/v1/pt-br/${idWl}/tokens?limit=1&page=1&sort=id:desc`;
-    console.debug("[WhitelabelService] Fetching token by whitelabel ID", {
-      url,
-      config: {
-        method: "GET",
-        headers: { authorization: masterToken },
-      },
-    });
-
-    const response = await fetch(url, {
-      method: "GET",
-      headers: { authorization: masterToken },
-    });
-
-    console.debug("[WhitelabelService] Response received for whitelabel ID", {
-      response,
-    });
-
-    if (!response.ok) {
-      throw new ApiError(
-        `Failed to fetch whitelabel token: ${response.status}`,
-        "WL_TOKEN_NOT_FOUND",
-        response.status,
-      );
-    }
-
-    const result: WhitelabelTokenApiResponse = await response.json();
-
-    if (result.status !== 1 || !result.data?.length) {
-      throw new ApiError(
-        "Token do whitelabel não encontrado",
-        "WL_TOKEN_NOT_FOUND",
-        404,
-      );
-    }
-
-    return result.data[0].token;
-  }
-
-  async revalidateByDomain(hostname: string): Promise<WhitelabelTokenData> {
-    hostname = `${normalizeHostname(process.env.WHITELABEL_DOMAIN || hostname)}`;
-    console.debug("[WhitelabelService] Getting token for domain", {
-      hostname,
-      byEnv: process.env.WHITELABEL_DOMAIN,
-    });
-
-    const cache = this.createCache();
-    const cacheKey = this.getCacheKey(hostname);
-
-    console.log("[WhitelabelService] Revalidating cache for domain", {
-      hostname,
-      cacheKey,
-    });
-    
-    await cache.delete(cacheKey);
-
-    const data = await this.fetchFromApi(hostname);
-
-    await cache.insert(cacheKey, JSON.stringify(data), 604800);
-
-    console.log("[WhitelabelService] Cache revalidated for domain", {
-      hostname,
-    });
-
-    return data;
-  }
-}
-
-export const whitelabelService = new WhitelabelService();
+import greatCache from "@greatapps/cache";
+import { ApiError } from "../../../infra/api/types";
+import { WhitelabelApiResponse, WhitelabelTokenApiResponse, WhitelabelTokenData } from "../schema";
+import { normalizeHostname } from "../utils/normalize-hostname";
+import {
+  DEFAULT_WHITELABEL_ID,
+  MISSING_WHITELABEL_CACHE_TTL_SECONDS,
+  WHITELABEL_CACHE_TTL_SECONDS,
+} from "../constants/whitelabel.constants";
+
+class WhitelabelService {
+  private getApiUrl(): string {
+    const apiUrl = process.env.GAPPS_R3_API_URL;
+    if (!apiUrl) {
+      throw new ApiError(
+        "GAPPS_R3_API_URL not configured",
+        "CONFIG_ERROR",
+        500,
+      );
+    }
+    return apiUrl;
+  }
+
+  private getToken(): string {
+    const token = process.env.WHITELABEL_TOKEN_MASTER;
+    if (!token) {
+      throw new ApiError(
+        "WHITELABEL_TOKEN_MASTER not configured",
+        "CONFIG_ERROR",
+        500,
+      );
+    }
+    return token;
+  }
+
+  private createCache() {
+    return new greatCache({
+      service: "whitelabel-service",
+      version: "1.0.3",
+      domain: "whitelabel-cache.greatapps.com.br",
+      ambient: process.env.NODE_ENV || "development",
+    });
+  }
+
+  private getCacheKey(hostname: string): string {
+    return `whitelabel-token-${hostname}`;
+  }
+
+  private getMissingCacheKey(hostname: string): string {
+    return `whitelabel-missing-${hostname}`;
+  }
+
+  private getDefaultCacheKey(): string {
+    return `whitelabel-token-id-${DEFAULT_WHITELABEL_ID}`;
+  }
+
+  private async fetchFromApi(hostname: string): Promise<WhitelabelTokenData | null> {
+    const apiUrl = this.getApiUrl();
+    const whitelabelMasterToken = this.getToken();
+    const url = `${apiUrl}/v1/pt-br/1/whitelabel/${hostname}/token`;
+
+    console.log("[WhitelabelService] Fetching token for domain", { url });
+
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        authorization: whitelabelMasterToken,
+      },
+    });
+
+    if (response.status === 404) {
+      console.log("[WhitelabelService] No whitelabel for domain", {
+        hostname,
+        status: response.status,
+      });
+      return null;
+    }
+
+    if (!response.ok) {
+      console.error("[WhitelabelService] Failed to fetch whitelabel token", {
+        hostname,
+        status: response.status,
+      });
+      throw new ApiError(
+        `Failed to fetch whitelabel token: ${response.status}`,
+        "FETCH_ERROR",
+        response.status,
+      );
+    }
+
+    const result: WhitelabelTokenApiResponse = await response.json();
+
+    if (result.status !== 1 || !result.data?.length) {
+      return null;
+    }
+
+    return result.data[0];
+  }
+
+  private async lookup(hostname: string): Promise<WhitelabelTokenData | null> {
+    const cache = this.createCache();
+    const cacheKey = this.getCacheKey(hostname);
+
+    const cachedData = await cache.select(cacheKey);
+    console.debug("[WhitelabelService] Cache lookup for domain", {
+      cacheKey,
+      cachedData,
+    });
+
+    if (cachedData.status == 1 && "data" in cachedData && cachedData.data) {
+      const cachedWhitelabel: WhitelabelTokenData = JSON.parse(cachedData.data);
+
+      if (this.#matchesHostname(cachedWhitelabel, hostname)) {
+        console.log("[WhitelabelService] Cache hit for domain", { hostname });
+        return cachedWhitelabel;
+      }
+
+      console.error("[WhitelabelService] Cached whitelabel does not match hostname", {
+        hostname,
+        cacheKey,
+        whitelabelId: cachedWhitelabel.id,
+        whitelabelDomain: cachedWhitelabel.domain,
+      });
+
+      await cache.delete(cacheKey);
+    }
+
+    const data = await this.fetchFromApi(hostname);
+    if (!data) return null;
+
+    if (!this.#matchesHostname(data, hostname)) {
+      console.error("[WhitelabelService] API returned whitelabel of another hostname", {
+        hostname,
+        whitelabelId: data.id,
+        whitelabelDomain: data.domain,
+      });
+      return data;
+    }
+
+    await cache.insert(cacheKey, JSON.stringify(data), WHITELABEL_CACHE_TTL_SECONDS);
+
+    return data;
+  }
+
+  private async getDefault(): Promise<WhitelabelTokenData> {
+    const cache = this.createCache();
+    const cacheKey = this.getDefaultCacheKey();
+
+    const cachedData = await cache.select(cacheKey);
+    if (cachedData.status == 1 && "data" in cachedData && cachedData.data) {
+      const cachedWhitelabel: WhitelabelTokenData = JSON.parse(cachedData.data);
+      return cachedWhitelabel;
+    }
+
+    const apiUrl = this.getApiUrl();
+    const masterToken = this.getToken();
+    const url = `${apiUrl}/v1/pt-br/${DEFAULT_WHITELABEL_ID}/whitelabels/${DEFAULT_WHITELABEL_ID}`;
+
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        authorization: masterToken,
+      },
+    });
+
+    if (!response.ok) {
+      throw new ApiError(
+        `Default whitelabel not found: ${DEFAULT_WHITELABEL_ID}`,
+        "WL_DEFAULT_UNAVAILABLE",
+        500,
+      );
+    }
+
+    const result: WhitelabelApiResponse = await response.json();
+
+    if (result.status !== 1 || !result.data?.length) {
+      throw new ApiError(
+        `Default whitelabel not found: ${DEFAULT_WHITELABEL_ID}`,
+        "WL_DEFAULT_UNAVAILABLE",
+        500,
+      );
+    }
+
+    const data: WhitelabelTokenData = { ...result.data[0], token: masterToken };
+
+    await cache.insert(cacheKey, JSON.stringify(data), WHITELABEL_CACHE_TTL_SECONDS);
+
+    return data;
+  }
+
+  async getTokenByDomain(hostname: string): Promise<WhitelabelTokenData> {
+    hostname = `${normalizeHostname(process.env.WHITELABEL_DOMAIN || hostname)}`;
+    console.debug("[WhitelabelService] Getting token for domain", {
+      hostname,
+      byEnv: process.env.WHITELABEL_DOMAIN,
+    });
+
+    const cache = this.createCache();
+    const missingCacheKey = this.getMissingCacheKey(hostname);
+
+    const cachedMissing = await cache.select(missingCacheKey);
+    if (cachedMissing.status == 1) {
+      console.log("[WhitelabelService] Cached miss for domain, using default", { hostname });
+      return this.getDefault();
+    }
+
+    const data = await this.lookup(hostname);
+    if (data) return data;
+
+    console.log("[WhitelabelService] No whitelabel for domain, falling back to default", {
+      hostname,
+    });
+    await cache.insert(missingCacheKey, "1", MISSING_WHITELABEL_CACHE_TTL_SECONDS);
+
+    return this.getDefault();
+  }
+
+  #matchesHostname(data: WhitelabelTokenData, hostname: string): boolean {
+    if (!data.domain) return true;
+
+    try {
+      return normalizeHostname(new URL(data.domain).hostname) === hostname;
+    } catch {
+      return true;
+    }
+  }
+
+  async getTokenByWhitelabelId(idWl: number): Promise<string> {
+    const apiUrl = this.getApiUrl();
+    const masterToken = this.getToken();
+    const url = `${apiUrl}/v1/pt-br/${idWl}/tokens?limit=1&page=1&sort=id:desc`;
+    console.debug("[WhitelabelService] Fetching token by whitelabel ID", {
+      url,
+      config: {
+        method: "GET",
+        headers: { authorization: masterToken },
+      },
+    });
+
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { authorization: masterToken },
+    });
+
+    console.debug("[WhitelabelService] Response received for whitelabel ID", {
+      response,
+    });
+
+    if (!response.ok) {
+      throw new ApiError(
+        `Failed to fetch whitelabel token: ${response.status}`,
+        "WL_TOKEN_NOT_FOUND",
+        response.status,
+      );
+    }
+
+    const result: WhitelabelTokenApiResponse = await response.json();
+
+    if (result.status !== 1 || !result.data?.length) {
+      throw new ApiError(
+        "Token do whitelabel não encontrado",
+        "WL_TOKEN_NOT_FOUND",
+        404,
+      );
+    }
+
+    return result.data[0].token;
+  }
+
+  async revalidateByDomain(hostname: string): Promise<WhitelabelTokenData> {
+    hostname = `${normalizeHostname(process.env.WHITELABEL_DOMAIN || hostname)}`;
+    console.debug("[WhitelabelService] Getting token for domain", {
+      hostname,
+      byEnv: process.env.WHITELABEL_DOMAIN,
+    });
+
+    const cache = this.createCache();
+    const cacheKey = this.getCacheKey(hostname);
+    const missingCacheKey = this.getMissingCacheKey(hostname);
+
+    console.log("[WhitelabelService] Revalidating cache for domain", {
+      hostname,
+      cacheKey,
+    });
+
+    await cache.delete(cacheKey);
+    await cache.delete(missingCacheKey);
+    await cache.delete(this.getDefaultCacheKey());
+
+    const data = await this.getTokenByDomain(hostname);
+
+    console.log("[WhitelabelService] Cache revalidated for domain", {
+      hostname,
+    });
+
+    return data;
+  }
+}
+
+export const whitelabelService = new WhitelabelService();

package/src/testing/msw/session.handlers.ts

@@ -26,6 +26,7 @@ export function makeSessionHandlers(opts: SessionHandlersOptions = {}) {
 
   return [
     http.get(`${base}/v1/:locale/:wl/whitelabel/:host/token`, () => apiFind(whitelabel)),
+    http.get(`${base}/v1/:locale/:wl/whitelabels/:id`, () => apiFind(whitelabel)),
     http.get(`${base}/v1/:locale/:wl/tokens`, () => apiFind(whitelabel)),
     // The users path has more segments, so it must come before /accounts/:acc.
     http.get(`${base}/v1/:locale/:wl/accounts/:acc/users/:user`, () => apiFind(user)),