@povio/ui 0.0.2 → 0.0.4

package/src/utils/rest/rest.utils.ts

@@ -0,0 +1,65 @@
+import axios, { type AxiosError, type AxiosResponseHeaders } from "axios";
+import { z } from "zod";
+
+export namespace RestUtils {
+  export const extractServerResponseCode = (e: unknown): string | null => {
+    if (e instanceof z.ZodError) {
+      return "validation-exception";
+    }
+
+    if (!axios.isAxiosError(e)) {
+      return null;
+    }
+
+    if (!e.response) {
+      return null;
+    }
+
+    const data = e.response.data as { code: unknown } | undefined;
+
+    if (typeof data?.code === "string") {
+      return data.code;
+    }
+
+    return null;
+  };
+
+  /**
+   * @deprecated should use response codes instead
+   */
+  export const doesServerErrorMessageContain = (e: AxiosError, text: string): boolean => {
+    const message = extractServerErrorMessage(e);
+    if (message == null) {
+      return false;
+    }
+
+    return message.toLowerCase().includes(text.toLowerCase());
+  };
+
+  export const extractServerErrorMessage = (e: unknown): string | null => {
+    if (e instanceof z.ZodError) {
+      return e.message;
+    }
+
+    if (!axios.isAxiosError(e)) {
+      return null;
+    }
+
+    if (!e.response) {
+      return null;
+    }
+
+    const data = e.response.data as { message: unknown } | undefined;
+
+    if (typeof data?.message === "string") {
+      return data.message;
+    }
+
+    return null;
+  };
+
+  export const extractContentDispositionFilename = (headers: AxiosResponseHeaders) => {
+    const contentDisposition = headers["content-disposition"] as string | undefined;
+    return contentDisposition ? /filename=["']?([^"';]+)/i.exec(contentDisposition)?.[1] : undefined;
+  };
+}

package/src/utils/routing.utils.ts

@@ -0,0 +1,12 @@
+export namespace RoutingUtils {
+  export const addQueryParams = (path: string, params: Record<string, string | number | boolean | undefined>) => {
+    const sParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value) {
+        sParams.append(key, value.toString());
+      }
+    }
+
+    return `${path}?${sParams.toString()}`;
+  };
+}

package/src/utils/string.utils.ts

@@ -0,0 +1,9 @@
+export namespace StringUtils {
+  export const containsCaseInsensitive = (str: string, substr: string) => {
+    return str.toLowerCase().includes(substr.toLowerCase());
+  };
+
+  export const capitalize = (str: string) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  };
+}

package/src/utils/vendor/error-handling.ts

@@ -0,0 +1,170 @@
+/* do not edit this unless you are bootstraping the project and know what you are doing */
+
+import axios from "axios";
+import i18n from "i18next";
+import { z } from "zod";
+
+import { ns } from "#ui/config/i18n";
+import { logger } from "#ui/utils/logger";
+import { RestUtils } from "#ui/utils/rest/rest.utils";
+
+// codes that we want to handle in every scenario
+export type GeneralErrorCodes =
+  | "DATA_VALIDATION_ERROR"
+  | "NETWORK_ERROR"
+  | "CANCELED_ERROR"
+  | "INTERNAL_ERROR"
+  | "UNKNOWN_ERROR";
+
+export class ApplicationException<CodeT> extends Error {
+  public code: CodeT;
+
+  public serverMessage: string | null = null;
+
+  constructor(message: string, code: CodeT, serverMessage: string | null) {
+    super(message);
+
+    this.code = code;
+    this.serverMessage = serverMessage;
+  }
+}
+
+interface ErrorEntry<CodeT> {
+  code: CodeT;
+  condition: (error: unknown) => boolean;
+  getMessage: (error: unknown) => string;
+}
+
+export class ErrorHandler<CodeT extends string> {
+  entries: ErrorEntry<CodeT | GeneralErrorCodes>[] = [];
+
+  constructor(entries: ErrorEntry<CodeT>[]) {
+    type ICodeT = CodeT | GeneralErrorCodes;
+
+    // implement checking for each of the general errors
+
+    const dataValidationError: ErrorEntry<ICodeT> = {
+      code: "DATA_VALIDATION_ERROR",
+      condition: (e) => {
+        return e instanceof z.ZodError;
+      },
+      getMessage: () =>
+        i18n.t(($) => $.sharedErrors.dataValidation, {
+          ns,
+        }),
+    };
+
+    const internalError: ErrorEntry<ICodeT> = {
+      code: "INTERNAL_ERROR",
+      condition: (e) => {
+        if (axios.isAxiosError(e)) {
+          return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
+        }
+
+        return false;
+      },
+      getMessage: () =>
+        i18n.t(($) => $.sharedErrors.internalError, {
+          ns,
+        }),
+    };
+
+    const networkError: ErrorEntry<ICodeT> = {
+      code: "NETWORK_ERROR",
+      condition: (e) => {
+        if (axios.isAxiosError(e)) {
+          return e.code === "ERR_NETWORK";
+        }
+
+        return false;
+      },
+      getMessage: () =>
+        i18n.t(($) => $.sharedErrors.networkError, {
+          ns,
+        }),
+    };
+
+    const canceledError: ErrorEntry<ICodeT> = {
+      code: "CANCELED_ERROR",
+      condition: (e) => {
+        if (axios.isCancel(e)) {
+          return true;
+        }
+
+        if (axios.isAxiosError(e) && e.code === "ECONNABORTED") {
+          return true;
+        }
+
+        return false;
+      },
+      getMessage: () =>
+        i18n.t(($) => $.sharedErrors.canceledError, {
+          ns,
+        }),
+    };
+
+    const unknownError: ErrorEntry<ICodeT> = {
+      code: "UNKNOWN_ERROR",
+      condition: () => true,
+      getMessage: () =>
+        i18n.t(($) => $.sharedErrors.unknownError, {
+          ns,
+        }),
+    };
+
+    // general errors have the lowest priority
+    this.entries = [...entries, dataValidationError, internalError, networkError, canceledError, unknownError];
+  }
+
+  // convert the error into an application exception
+  public rethrowError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes> {
+    logger.error(error);
+    const errorEntry = this.entries.find((entry) => entry.condition(error ?? {}))!;
+
+    const serverMessage = RestUtils.extractServerErrorMessage(error);
+    throw new ApplicationException(errorEntry.getMessage(error), errorEntry.code, serverMessage);
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  public getError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes> | null {
+    if (error instanceof ApplicationException) {
+      return error;
+    }
+
+    return null;
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  public getErrorCode(error: unknown): CodeT | GeneralErrorCodes | null {
+    if (error instanceof ApplicationException) {
+      return error.code as CodeT;
+    }
+
+    return null;
+  }
+
+  public static getErrorMessage(error: unknown, fallbackToUnknown = true): string | null {
+    if (typeof error === "string") {
+      return error;
+    }
+
+    if (error instanceof Error) {
+      return error.message;
+    }
+
+    if (error instanceof ApplicationException) {
+      return error.message;
+    }
+
+    if (fallbackToUnknown) {
+      return i18n.t(($) => $.sharedErrors.unknownError, {
+        ns,
+      });
+    }
+
+    return null;
+  }
+}
+
+// can be used for endpoints that only need general error handling
+export const SharedErrorHandler = new ErrorHandler<never>([]);

package/src/utils/zod.utils.ts

@@ -0,0 +1,95 @@
+// oxlint-disable no-explicit-any
+import { z } from "zod";
+
+export namespace ZodUtils {
+  export type UnwrapZod<T> = T extends z.ZodOptional<infer U>
+    ? UnwrapZod<U>
+    : T extends z.ZodNullable<infer U>
+      ? UnwrapZod<U>
+      : T;
+
+  export type IsZodType<T, Z> = UnwrapZod<T> extends Z ? true : false;
+
+  export type IsZodNumber<T> = IsZodType<T, z.ZodNumber>;
+  export type IsZodEnum<T> = IsZodType<T, z.ZodEnum<any>>;
+  export type IsZodDateTime<T> = IsZodType<T, z.ZodISODateTime>;
+  export type IsZodString<T> = IsZodType<T, z.ZodString>;
+  export type IsZodEmail<T> = IsZodType<T, z.ZodEmail>;
+  export type IsZodDateRange<T> = UnwrapZod<T> extends z.ZodObject
+    ? UnwrapZod<UnwrapZod<T>["shape"]["start"]> extends z.ZodISODateTime
+      ? UnwrapZod<UnwrapZod<T>["shape"]["end"]> extends z.ZodISODateTime
+        ? true
+        : false
+      : false
+    : false;
+  export type IsZodTextEditor<T> = UnwrapZod<T> extends z.ZodObject
+    ? UnwrapZod<UnwrapZod<T>["shape"]["html"]> extends z.ZodString
+      ? UnwrapZod<UnwrapZod<T>["shape"]["json"]> extends z.ZodObject<any>
+        ? true
+        : false
+      : false
+    : false;
+  export type IsZodObject<T> = IsZodType<T, z.ZodObject<any>>;
+  export type IsZodArray<T> = IsZodType<T, z.ZodArray<any>>;
+
+  export type ZodType<T> = IsZodType<T, z.ZodBoolean> extends true
+    ? "boolean"
+    : IsZodNumber<T> extends true
+      ? "number"
+      : IsZodEnum<T> extends true
+        ? "enum"
+        : IsZodDateTime<T> extends true
+          ? "datetime"
+          : IsZodString<T> extends true
+            ? "string"
+            : IsZodEmail<T> extends true
+              ? "email"
+              : IsZodDateRange<T> extends true
+                ? "dateRange"
+                : IsZodTextEditor<T> extends true
+                  ? "textEditor"
+                  : IsZodObject<T> extends true
+                    ? "object"
+                    : IsZodArray<T> extends true
+                      ? "array"
+                      : never;
+
+  export type ZodTypeSwitch<
+    TZodType extends z.ZodType,
+    T extends Record<ZodType<TZodType> | "unknown", unknown>,
+  > = ZodType<TZodType> extends never ? never : T[ZodType<TZodType>];
+
+  export const unwrapZodType = (schemaType: z.core.$ZodType) => {
+    let unwrappedType = schemaType;
+    while (unwrappedType instanceof z.ZodNullable || unwrappedType instanceof z.ZodOptional) {
+      unwrappedType = unwrappedType.unwrap();
+    }
+    return unwrappedType;
+  };
+
+  const hasZodObjectProperty = (schemaType: z.ZodObject, property: string, type: z.core.$constructor<any, any>) => {
+    return (
+      property in schemaType.shape &&
+      schemaType.shape[property] instanceof z.core.$ZodType &&
+      unwrapZodType(schemaType.shape[property]) instanceof type
+    );
+  };
+
+  export const isDateRange = (schemaType: z.core.$ZodType) => {
+    const unwrappedType = unwrapZodType(schemaType);
+    return (
+      unwrappedType instanceof z.ZodObject &&
+      hasZodObjectProperty(unwrappedType, "start", z.ZodISODateTime) &&
+      hasZodObjectProperty(unwrappedType, "end", z.ZodISODateTime)
+    );
+  };
+
+  export const isTextEditor = (schemaType: z.core.$ZodType) => {
+    const unwrappedType = unwrapZodType(schemaType);
+    return (
+      unwrappedType instanceof z.ZodObject &&
+      hasZodObjectProperty(unwrappedType, "html", z.ZodString) &&
+      hasZodObjectProperty(unwrappedType, "json", z.ZodObject)
+    );
+  };
+}