@camunda/ccma-api 0.0.2 → 0.0.4

package/dist/services/wordpress/wordpress.service.js

@@ -0,0 +1,111 @@
+import { request } from "../../utils/api.js";
+import { HttpError } from "../../utils/errors.js";
+class WordpressService {
+  static async getCards(params) {
+    const serviceContext = {
+      method: {
+        name: `WordpressService.getCards`,
+        url: `wp-json/camundahelp/v1/cards?card_id=${params.options.cardIds.join(
+          ","
+        )}`,
+        normalizedUrl: `wp-json/camundahelp/v1/cards?card_id=:card_id`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "wordpress",
+        type: "external"
+      }
+    };
+    const response = await request({
+      ...params,
+      base: {
+        id: "wordpress-helpcenter"
+      },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async getHelpCenterConfig(params) {
+    const serviceContext = {
+      method: {
+        name: `WordpressService.getHelpCenterConfig`,
+        url: `wp-json/camundahelp/v1/helpcenter?env=${params.config.stage}`,
+        normalizedUrl: `wp-json/camundahelp/v1/helpcenter?env=:env`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "wordpress",
+        type: "external"
+      }
+    };
+    params.config.stage = params.config.stage.replace("-test", "");
+    const response = await request({
+      ...params,
+      base: {
+        id: "wordpress-helpcenter"
+      },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  static async getSurveyConfig(params) {
+    const serviceContext = {
+      method: {
+        name: `WordpressService.getSurveyConfig`,
+        url: `wp-json/camundahelp/v1/onboardingsurvey?env=${params.config.stage}`,
+        normalizedUrl: `wp-json/camundahelp/v1/onboardingsurvey?env=:env`,
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "wordpress",
+        type: "external"
+      }
+    };
+    params.config.stage = params.config.stage.replace("-test", "");
+    const response = await request({
+      ...params,
+      base: {
+        id: "wordpress-helpcenter"
+      },
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json"
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+}
+export {
+  WordpressService
+};
+//# sourceMappingURL=wordpress.service.js.map

package/dist/services/wordpress/wordpress.service.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/services/wordpress/wordpress.service.ts"],
+  "sourcesContent": ["/*\n * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH\n * under one or more contributor license agreements. Licensed under a commercial license.\n * You may not use this file except in compliance with the commercial license.\n */\n\nimport type {\n  RequestBaseParams,\n  RequestBaseServiceContext,\n} from '../../types/general.types.js'\nimport { request } from '../../utils/api.js'\nimport { HttpError } from '../../utils/errors.js'\n\nexport interface WordpressGetCardsRequest extends RequestBaseParams {\n  options: {\n    cardIds: string[]\n  }\n}\n\nexport interface WordpressGetHelpCenterConfigRequest\n  extends RequestBaseParams {}\n\nexport interface WordpressGetSurveyConfigRequest extends RequestBaseParams {}\n\nexport class WordpressService {\n  public static async getCards(\n    params: WordpressGetCardsRequest,\n  ): Promise<any[]> {\n    const serviceContext: RequestBaseServiceContext = {\n      method: {\n        name: `WordpressService.getCards`,\n        url: `wp-json/camundahelp/v1/cards?card_id=${params.options.cardIds.join(\n          ',',\n        )}`,\n        normalizedUrl: `wp-json/camundahelp/v1/cards?card_id=:card_id`,\n        type: 'get',\n      },\n      source: params.config.metrics?.source || 'unset',\n      target: {\n        name: 'wordpress',\n        type: 'external',\n      },\n    }\n\n    const response = await request<any[]>({\n      ...params,\n      base: {\n        id: 'wordpress-helpcenter',\n      },\n      url: serviceContext.method.url,\n      method: serviceContext.method.type,\n      metricsDetails: serviceContext,\n      type: 'json',\n    })\n    if (!response.ok) {\n      throw new HttpError(\n        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,\n        response.status,\n        response.statusText,\n      )\n    }\n    return response.body!\n  }\n\n  public static async getHelpCenterConfig(\n    params: WordpressGetHelpCenterConfigRequest,\n  ): Promise<any> {\n    const serviceContext: RequestBaseServiceContext = {\n      method: {\n        name: `WordpressService.getHelpCenterConfig`,\n        url: `wp-json/camundahelp/v1/helpcenter?env=${params.config.stage}`,\n        normalizedUrl: `wp-json/camundahelp/v1/helpcenter?env=:env`,\n        type: 'get',\n      },\n      source: params.config.metrics?.source || 'unset',\n      target: {\n        name: 'wordpress',\n        type: 'external',\n      },\n    }\n    params.config.stage = params.config.stage.replace('-test', '') as any\n    const response = await request<any>({\n      ...params,\n      base: {\n        id: 'wordpress-helpcenter',\n      },\n      url: serviceContext.method.url,\n      method: serviceContext.method.type,\n      metricsDetails: serviceContext,\n      type: 'json',\n    })\n    if (!response.ok) {\n      throw new HttpError(\n        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,\n        response.status,\n        response.statusText,\n      )\n    }\n    return response.body\n  }\n\n  public static async getSurveyConfig(\n    params: WordpressGetSurveyConfigRequest,\n  ): Promise<any> {\n    const serviceContext: RequestBaseServiceContext = {\n      method: {\n        name: `WordpressService.getSurveyConfig`,\n        url: `wp-json/camundahelp/v1/onboardingsurvey?env=${params.config.stage}`,\n        normalizedUrl: `wp-json/camundahelp/v1/onboardingsurvey?env=:env`,\n        type: 'get',\n      },\n      source: params.config.metrics?.source || 'unset',\n      target: {\n        name: 'wordpress',\n        type: 'external',\n      },\n    }\n    params.config.stage = params.config.stage.replace('-test', '') as any\n    const response = await request<any>({\n      ...params,\n      base: {\n        id: 'wordpress-helpcenter',\n      },\n      url: serviceContext.method.url,\n      method: serviceContext.method.type,\n      metricsDetails: serviceContext,\n      type: 'json',\n    })\n    if (!response.ok) {\n      throw new HttpError(\n        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,\n        response.status,\n        response.statusText,\n      )\n    }\n    return response.body\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/types/general.types.d.ts

@@ -0,0 +1,61 @@
+export type Stage = 'dev' | 'devAws' | 'int' | 'prod' | 'local' | 'localconsole' | 'localaccounts';
+export interface RequestBaseParamsAuth {
+    getToken: () => Promise<string>;
+}
+export interface RequestBaseParamsLogger {
+    debug: (message: string, data?: any) => void;
+    info: (message: string, data?: any) => void;
+    error: (message: string, data?: any) => void;
+}
+export type RequestBaseCustomMetricsDetailsType = 'request' | 'success' | 'error' | 'rate-limit-retry';
+export interface RequestBaseServiceContext {
+    source: string;
+    target: {
+        name: string;
+        type: 'internal' | 'external';
+    };
+    method: {
+        name: string;
+        url: string;
+        normalizedUrl: string;
+        type: RequestBaseMethodType;
+    };
+    eventType?: RequestBaseCustomMetricsDetailsType;
+    durationBucket?: string;
+    statusCode?: string;
+    error?: string;
+}
+export interface RequestBaseCustomMetrics {
+    source: string;
+    types: RequestBaseCustomMetricsDetailsType[];
+    callback: (details: RequestBaseServiceContext) => void;
+}
+export interface RequestBaseParamsEnvOverride {
+    [key: string]: string;
+}
+export interface RequestBaseParamsConfig {
+    stage: Stage;
+    auth?: RequestBaseParamsAuth;
+    logger?: RequestBaseParamsLogger;
+    envOverride?: RequestBaseParamsEnvOverride;
+    metrics?: RequestBaseCustomMetrics;
+    timeout?: number;
+    proxyAgent?: any;
+    frontendCaching?: {
+        enabled: boolean;
+        dbName: string;
+        storeName?: string;
+        ttl: number;
+    };
+}
+export interface RequestBaseParams {
+    config: RequestBaseParamsConfig;
+    cacheControl?: {
+        ignoreCache?: boolean;
+    };
+    onCachedResponse?: (data: any, info: {
+        fresh: boolean;
+        source: 'cache';
+    }) => void;
+}
+export type RequestBaseMethodType = 'get' | 'post' | 'put' | 'delete' | 'patch';

package/dist/types/general.types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=general.types.js.map

package/dist/types/general.types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/utils/api.d.ts

@@ -0,0 +1,31 @@
+import type { RequestBaseMethodType, RequestBaseParams, RequestBaseServiceContext } from '../types/general.types.js';
+import { type ServiceName } from './environments.js';
+export interface RequestPayload extends RequestBaseParams {
+    base?: {
+        id: ServiceName;
+    };
+    url: string;
+    method: RequestBaseMethodType;
+    headers?: {
+        [key: string]: string;
+    };
+    type?: 'json' | 'text' | 'form' | 'none';
+    responseType?: 'json' | 'text' | 'none';
+    retry?: {
+        attempts: number;
+        remaining: number;
+    };
+    body?: any;
+    metricsDetails: RequestBaseServiceContext;
+}
+export interface Response<T> {
+    body?: T;
+    status: number;
+    statusText?: string;
+    ok: boolean;
+    meta: {
+        duration: number;
+    };
+}
+export declare function log(payload: RequestPayload, type: 'debug' | 'info' | 'error', message: string, additionalData?: any): void;
+export declare function request<T>(payload: RequestPayload): Promise<Response<T>>;

package/dist/utils/api.js

@@ -0,0 +1,400 @@
+import { getEnvParam } from "./environments.js";
+import { frontendCache } from "./frontendCache.js";
+function sendMetrics(payload, type, options) {
+  if (payload.config.metrics) {
+    if (payload.config.metrics.types.includes(type)) {
+      let durationBucket;
+      if (options?.duration) {
+        if (options.duration < 100) {
+          durationBucket = "0 | <100ms";
+        } else if (options.duration < 200) {
+          durationBucket = "1 | <200ms";
+        } else if (options.duration < 500) {
+          durationBucket = "2 | <500ms";
+        } else if (options.duration < 1e3) {
+          durationBucket = "3 | <1s";
+        } else {
+          durationBucket = "4 | >=1s";
+        }
+      }
+      let error = "other";
+      if (options?.error) {
+        try {
+          const errorMessage = options.error;
+          if (errorMessage.startsWith("<!DOCTYPE html>")) {
+            error = "html-response";
+          } else if (errorMessage.includes("UND_ERR_CONNECT_TIMEOUT")) {
+            error = "connect-timeout";
+          }
+        } catch (_error) {
+        }
+      } else {
+        error = "unset";
+      }
+      const metrics = {
+        ...payload.metricsDetails,
+        eventType: type,
+        durationBucket,
+        statusCode: options?.statusCode,
+        error
+      };
+      try {
+        payload.config.metrics.callback(metrics);
+      } catch (metricsCallbackError) {
+        log(payload, "debug", `Failed to send metrics`, {
+          error: metricsCallbackError,
+          metrics
+        });
+      }
+    }
+  }
+}
+function log(payload, type, message, additionalData) {
+  if (payload.config.logger) {
+    const messageParts = [];
+    messageParts.push(payload.metricsDetails?.method?.name);
+    messageParts.push(
+      `${payload.metricsDetails?.target?.name} (${payload.metricsDetails?.target?.type})`
+    );
+    messageParts.push(message);
+    let body;
+    if (payload.body) {
+      body = JSON.parse(JSON.stringify(payload.body));
+      for (const key of Object.keys(body)) {
+        if (key.toLowerCase().includes("password") || key.toLowerCase().includes("secret") || key.toLowerCase().includes("token")) {
+          body[key] = "********";
+        }
+      }
+    }
+    let fullUrl = "unset";
+    if (payload.base) {
+      try {
+        const base = getEnvParam(payload.base.id, payload.config);
+        fullUrl = base ? `${base}/${payload.url}` : payload.url;
+      } catch (_error) {
+        fullUrl = `failed to get base url for ${payload.base.id}`;
+      }
+    }
+    let url = `${payload.url}`.toLowerCase();
+    if (url.includes("secret") || url.includes("password")) {
+      url = url.split("?")[0];
+    }
+    const data = {
+      base: payload.base,
+      method: payload.method,
+      url,
+      fullUrl,
+      retry: payload.retry,
+      body,
+      context: payload.metricsDetails,
+      ...additionalData
+    };
+    payload.config.logger[type](messageParts.join(" > "), { data });
+  }
+}
+function rateLimitWaitingTime(attempt) {
+  const noise = Math.random() * 100;
+  const waitingTime = 2 ** attempt * 1e3 + noise;
+  return Math.floor(waitingTime);
+}
+async function request(payload) {
+  log(payload, "debug", "starting request");
+  sendMetrics(payload, "request");
+  try {
+    if (payload.config.frontendCaching?.enabled) {
+      frontendCache.configure(payload.config.frontendCaching);
+    }
+  } catch (_cacheConfigError) {
+  }
+  let token;
+  if (payload.config.auth) {
+    token = await payload.config.auth.getToken();
+  }
+  const headers = payload.headers ?? {};
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  const type = payload.type ?? "json";
+  let body;
+  if (type) {
+    switch (type) {
+      case "json":
+        headers["Content-Type"] = "application/json";
+        body = payload.body ? JSON.stringify(payload.body) : void 0;
+        break;
+      case "text":
+        headers["Content-Type"] = "text/plain";
+        body = payload.body ? JSON.stringify(payload.body) : void 0;
+        break;
+      case "form":
+        if (payload.body) {
+          const formData = new URLSearchParams();
+          Object.keys(payload.body).forEach((key) => {
+            formData.append(key, payload.body[key]);
+          });
+          body = formData;
+        }
+        break;
+    }
+  }
+  let base;
+  if (payload.base) {
+    try {
+      base = getEnvParam(payload.base.id, payload.config);
+    } catch (error) {
+      log(payload, "error", `Failed to get base url for ${payload.base.id}`, {
+        error
+      });
+      throw error;
+    }
+  }
+  const url = base ? `${base}/${payload.url}` : payload.url;
+  let serveCachedAndReturnAfterNetwork = false;
+  if (payload.method === "get" && payload.config.frontendCaching?.enabled) {
+    try {
+      const cached = await frontendCache.get("get", url);
+      if (cached) {
+        const fresh = frontendCache.isFresh(cached);
+        if (payload.onCachedResponse) {
+          payload.onCachedResponse(cached.payload, { fresh, source: "cache" });
+          if (!fresh) {
+            log(payload, "debug", "cache stale, refreshing in background");
+            serveCachedAndReturnAfterNetwork = true;
+          } else {
+            log(payload, "debug", "cache fresh, returning early");
+            sendMetrics(payload, "success", { duration: 0, statusCode: "200" });
+            return {
+              // eslint-disable-next-line id-length
+              ok: true,
+              status: 200,
+              statusText: "cached",
+              body: cached.payload,
+              meta: { duration: 0 }
+            };
+          }
+        } else if (fresh) {
+          log(payload, "debug", "cache hit, returning cached response");
+          sendMetrics(payload, "success", { duration: 0, statusCode: "200" });
+          return {
+            // eslint-disable-next-line id-length
+            ok: true,
+            status: 200,
+            statusText: "cached",
+            body: cached.payload,
+            meta: { duration: 0 }
+          };
+        } else {
+          log(payload, "debug", "cache stale, proceeding with network request");
+        }
+      }
+    } catch (_cacheGetError) {
+    }
+  }
+  const start = performance.now();
+  const proxyAgent = payload.config.proxyAgent ?? {};
+  try {
+    const fetchResponse = await fetch(url, {
+      signal: payload.config.timeout ? AbortSignal.timeout(payload.config.timeout) : void 0,
+      method: payload.method.toUpperCase(),
+      headers,
+      body,
+      ...proxyAgent
+    });
+    const end = performance.now();
+    const duration = end - start;
+    if ([429].includes(fetchResponse.status)) {
+      log(payload, "info", "rate limited");
+      sendMetrics(payload, "rate-limit-retry", {
+        duration,
+        statusCode: String(fetchResponse.status)
+      });
+      const remaining = payload.retry?.remaining ?? 8;
+      const attempts = payload.retry?.attempts ?? 1;
+      if (remaining > 0) {
+        let waitingTime = rateLimitWaitingTime(attempts);
+        if (fetchResponse.headers.has("x-ratelimit-reset")) {
+          const rateLimitHeader = fetchResponse.headers.get("x-ratelimit-reset");
+          log(
+            payload,
+            "debug",
+            `rate limited, found x-ratelimit-reset header: ${rateLimitHeader}`
+          );
+          const rateLimitHeaderNumber = Number(rateLimitHeader);
+          if (Number.isNaN(rateLimitHeaderNumber)) {
+            waitingTime = Date.parse(rateLimitHeader ?? "0") - Date.now();
+          } else {
+            waitingTime = rateLimitHeaderNumber - Date.now();
+          }
+        }
+        if (waitingTime < 0 || waitingTime > 18e4) {
+          waitingTime = rateLimitWaitingTime(attempts);
+        }
+        log(
+          payload,
+          "debug",
+          `rate limited, attempt ${attempts}, remaining ${remaining}, waiting ${waitingTime}ms`
+        );
+        await new Promise((resolve) => {
+          setTimeout(resolve, waitingTime);
+        });
+        payload.retry = {
+          attempts: attempts + 1,
+          remaining: remaining - 1
+        };
+        return request(payload);
+      }
+      log(payload, "debug", `rate limited, no more retries`);
+    }
+    const response = {
+      // eslint-disable-next-line id-length
+      ok: fetchResponse.ok,
+      status: fetchResponse.status,
+      statusText: fetchResponse.statusText,
+      meta: {
+        duration
+      }
+    };
+    const responseType = payload.responseType ?? type;
+    if (response.ok) {
+      log(payload, "debug", `request successful in ${Math.floor(duration)}ms`, {
+        baseUrl: base
+      });
+      sendMetrics(payload, "success", {
+        duration,
+        statusCode: String(fetchResponse.status)
+      });
+      switch (responseType) {
+        case "json":
+          try {
+            response.body = await fetchResponse.json();
+          } catch (_error) {
+            log(
+              payload,
+              "debug",
+              `Failed to parse json body. Returning empty object.`,
+              {
+                baseUrl: base
+              }
+            );
+            response.body = {};
+            try {
+              const responseBodyText = await fetchResponse.text();
+              log(payload, "debug", `Response body text`, {
+                baseUrl: base,
+                responseBodyText,
+                status: fetchResponse.status
+              });
+            } catch (textError) {
+              log(payload, "debug", `Failed to parse response body text.`, {
+                baseUrl: base,
+                status: fetchResponse.status,
+                error: textError
+              });
+            }
+          }
+          break;
+        case "text":
+          response.body = await fetchResponse.text();
+          break;
+        default:
+          response.body = await fetchResponse.text();
+      }
+      if (payload.method === "get" && payload.config.frontendCaching?.enabled && response.body !== void 0) {
+        try {
+          await frontendCache.set("get", url, response.body);
+          log(payload, "debug", "cache store successful");
+        } catch (_cacheSetError) {
+        }
+      }
+    } else {
+      let statusText = fetchResponse.statusText;
+      try {
+        statusText = await fetchResponse.text();
+      } catch (_error) {
+      }
+      response.statusText = statusText;
+      log(
+        payload,
+        "debug",
+        `request failed with status ${response.status}: ${statusText}`,
+        {
+          baseUrl: base
+        }
+      );
+      let type2 = "error";
+      const noErrorStatusCodes = [];
+      switch (payload.metricsDetails.target.name) {
+        case "auth0":
+          noErrorStatusCodes.push(...[400, 404, 409]);
+          break;
+        case "accounts":
+        case "console":
+          noErrorStatusCodes.push(...[404, 409]);
+          if (payload.metricsDetails.method.name === "createTemporaryCluster") {
+            noErrorStatusCodes.push(...[400, 403, 412]);
+          }
+          if ([
+            "ConsoleM2MService.verifyZeebeClient",
+            "ConsoleM2MService.verifyApiClient"
+          ].includes(payload.metricsDetails.method.name)) {
+            noErrorStatusCodes.push(...[401]);
+          }
+          if (payload.metricsDetails.method.name === "OrgsService.createAndReturnSocialLoginUser") {
+            noErrorStatusCodes.push(
+              ...[
+                // onboard user, user already has an org
+                400,
+                // existing extSSO-connection
+                412
+              ]
+            );
+          }
+          break;
+      }
+      if (noErrorStatusCodes.includes(response.status)) {
+        type2 = "success";
+      }
+      sendMetrics(payload, type2, {
+        duration,
+        statusCode: String(fetchResponse.status),
+        error: statusText
+      });
+    }
+    if (serveCachedAndReturnAfterNetwork && response.ok) {
+      log(payload, "debug", "stale cache updated, returning new data");
+    }
+    return response;
+  } catch (error) {
+    log(payload, "error", `request failed with no status`, {
+      baseUrl: base,
+      error
+    });
+    const duration = performance.now() - start;
+    let errorMessage;
+    if (error?.cause?.code) {
+      errorMessage = error?.cause?.code;
+    } else if (error?.message) {
+      errorMessage = error?.message;
+    }
+    sendMetrics(payload, "error", {
+      statusCode: "fetch-error",
+      duration,
+      error: errorMessage
+    });
+    const response = {
+      // eslint-disable-next-line id-length
+      ok: false,
+      status: 500,
+      statusText: "fetch error",
+      meta: {
+        duration
+      }
+    };
+    return response;
+  }
+}
+export {
+  log,
+  request
+};
+//# sourceMappingURL=api.js.map