@povio/ui 0.0.5 → 0.0.7

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

@@ -1,170 +0,0 @@
-/* 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

@@ -1,95 +0,0 @@
-// 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)
-    );
-  };
-}