@povio/openapi-codegen-cli 2.0.2 → 2.0.3-rc.2

package/dist/lib/rest/error-handling.mjs

@@ -0,0 +1,129 @@
+import { isAxiosError, isCancel } from "axios";
+import { z } from "zod";
+import { defaultT } from "../config/i18n.mjs";
+import { RestUtils } from "./rest.utils.mjs";
+class ApplicationException extends Error {
+  code;
+  serverMessage = null;
+  constructor(message, code, serverMessage) {
+    super(message);
+    this.code = code;
+    this.serverMessage = serverMessage;
+  }
+}
+class ErrorHandler {
+  entries = [];
+  t;
+  onRethrowError;
+  constructor({ entries, t = defaultT, onRethrowError }) {
+    this.t = t;
+    this.onRethrowError = onRethrowError;
+    const dataValidationError = {
+      code: "DATA_VALIDATION_ERROR",
+      condition: (e) => {
+        return e instanceof z.ZodError;
+      },
+      getMessage: () => this.t("openapi.sharedErrors.dataValidation")
+    };
+    const internalError = {
+      code: "INTERNAL_ERROR",
+      condition: (e) => {
+        if (isAxiosError(e)) {
+          return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
+        }
+        return false;
+      },
+      getMessage: () => this.t("openapi.sharedErrors.internalError")
+    };
+    const networkError = {
+      code: "NETWORK_ERROR",
+      condition: (e) => {
+        if (isAxiosError(e)) {
+          return e.code === "ERR_NETWORK";
+        }
+        return false;
+      },
+      getMessage: () => this.t("openapi.sharedErrors.networkError")
+    };
+    const canceledError = {
+      code: "CANCELED_ERROR",
+      condition: (e) => {
+        if (isCancel(e)) {
+          return true;
+        }
+        if (isAxiosError(e) && e.code === "ECONNABORTED") {
+          return true;
+        }
+        return false;
+      },
+      getMessage: () => this.t("openapi.sharedErrors.canceledError")
+    };
+    const unknownError = {
+      code: "UNKNOWN_ERROR",
+      condition: () => true,
+      getMessage: (_, e) => {
+        const code = RestUtils.extractServerResponseCode(e);
+        const serverMessage = RestUtils.extractServerErrorMessage(e);
+        if (code) {
+          let message = `Unknown error, message from server: ${code}`;
+          if (serverMessage) {
+            message += ` ${serverMessage}`;
+          }
+          return message;
+        }
+        return this.t("openapi.sharedErrors.unknownError");
+      }
+    };
+    this.entries = [...entries, dataValidationError, internalError, networkError, canceledError, unknownError];
+  }
+  matchesEntry(error, entry, code) {
+    if (entry.condition) {
+      return entry.condition(error);
+    }
+    return code === entry.code;
+  }
+  setTranslateFunction(t) {
+    this.t = t;
+  }
+  rethrowError(error) {
+    const code = RestUtils.extractServerResponseCode(error);
+    const errorEntry = this.entries.find((entry) => this.matchesEntry(error, entry, code));
+    const serverMessage = RestUtils.extractServerErrorMessage(error);
+    const exception = new ApplicationException(errorEntry.getMessage(this.t, error), errorEntry.code, serverMessage);
+    this.onRethrowError?.(error, exception);
+    throw exception;
+  }
+  getError(error) {
+    if (error instanceof ApplicationException) {
+      return error;
+    }
+    return null;
+  }
+  getErrorCode(error) {
+    if (error instanceof ApplicationException) {
+      return error.code;
+    }
+    return null;
+  }
+  static getErrorMessage(error, fallbackToUnknown = true) {
+    if (typeof error === "string") {
+      return error;
+    }
+    if (error instanceof Error) {
+      return error.message;
+    }
+    if (error instanceof ApplicationException) {
+      return error.message;
+    }
+    if (fallbackToUnknown) {
+      return defaultT("openapi.sharedErrors.unknownError");
+    }
+    return null;
+  }
+}
+const SharedErrorHandler = new ErrorHandler({ entries: [] });
+export {
+  ApplicationException,
+  ErrorHandler,
+  SharedErrorHandler
+};

package/dist/lib/rest/rest-client.d.ts

@@ -1,7 +1,7 @@
-import { AxiosRequestConfig, CreateAxiosDefaults } from "axios";
-import { ErrorHandler, GeneralErrorCodes } from "./error-handling";
-import { RestClient as IRestClient, RequestConfig, RequestInfo, Response } from "./rest-client.types";
-import { RestInterceptor } from "./rest-interceptor";
+import { AxiosRequestConfig, CreateAxiosDefaults } from 'axios';
+import { ErrorHandler, GeneralErrorCodes } from './error-handling';
+import { RestClient as IRestClient, RequestConfig, RequestInfo, Response } from './rest-client.types';
+import { RestInterceptor } from './rest-interceptor';
 export declare class RestClient implements IRestClient {
     private readonly client;
     private readonly errorHandler;

package/dist/lib/rest/rest-client.mjs

@@ -0,0 +1,62 @@
+import axios from "axios";
+import { z } from "zod";
+import { SharedErrorHandler } from "./error-handling.mjs";
+class RestClient {
+  client;
+  errorHandler;
+  constructor({
+    config,
+    interceptors,
+    errorHandler
+  } = {}) {
+    this.client = axios.create(config);
+    this.errorHandler = errorHandler ?? SharedErrorHandler;
+    this.attachInterceptors(interceptors);
+  }
+  attachInterceptors(interceptors, ...args) {
+    if (interceptors != null) {
+      interceptors.forEach((interceptor) => this.attachInterceptor(interceptor, ...args));
+    }
+  }
+  attachInterceptor(interceptor, ...args) {
+    interceptor.addInterceptor(this.client, ...args);
+  }
+  ejectInterceptor(interceptor) {
+    interceptor.removeInterceptor(this.client);
+  }
+  async get(requestInfo, url, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "get", url });
+  }
+  async post(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "post", url, data });
+  }
+  async patch(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "patch", url, data });
+  }
+  async put(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "put", url, data });
+  }
+  async delete(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "delete", url, data });
+  }
+  async makeRequest(requestInfo, requestConfig) {
+    const errorStack = new Error().stack;
+    try {
+      const { rawResponse, ...config } = requestConfig;
+      const res = await this.client(config);
+      const resData = requestInfo.resSchema.parse(res.data);
+      return rawResponse ? { ...res, data: resData } : resData;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        error.name = "BE Response schema mismatch - ZodError";
+        error.stack = [error.stack, ...errorStack?.split("\n").slice(2) ?? []].join("\n");
+      }
+      const errorHandler = requestInfo.errorHandler ?? this.errorHandler;
+      errorHandler.rethrowError(error);
+      throw error;
+    }
+  }
+}
+export {
+  RestClient
+};

package/dist/lib/rest/rest-client.types.d.ts

@@ -1,7 +1,7 @@
-import { AxiosRequestConfig, AxiosResponse } from "axios";
-import { z } from "zod";
-import { ErrorHandler } from "./error-handling";
-import { RestInterceptor } from "./rest-interceptor";
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { z } from 'zod';
+import { ErrorHandler } from './error-handling';
+import { RestInterceptor } from './rest-interceptor';
 export type GeneralErrorCodes = string;
 export interface RequestInfo<ZOutput, ECodes extends string> {
     resSchema: z.ZodType<ZOutput>;

package/dist/lib/rest/rest-interceptor.d.ts

@@ -1,4 +1,4 @@
-import { AxiosInstance } from "axios";
+import { AxiosInstance } from 'axios';
 export declare class RestInterceptor<T extends any[]> {
     private applyInterceptor;
     private interceptorIdMap;

package/dist/lib/rest/rest-interceptor.mjs

@@ -0,0 +1,21 @@
+class RestInterceptor {
+  constructor(applyInterceptor) {
+    this.applyInterceptor = applyInterceptor;
+  }
+  interceptorIdMap = [];
+  addInterceptor(client, ...args) {
+    this.removeInterceptor(client);
+    const interceptorId = this.applyInterceptor(client, ...args);
+    this.interceptorIdMap.push({ client, interceptorId });
+  }
+  removeInterceptor(client) {
+    const interceptorId = this.interceptorIdMap.find((i) => i.client === client)?.interceptorId;
+    if (interceptorId != null) {
+      client.interceptors.request.eject(interceptorId);
+      this.interceptorIdMap = this.interceptorIdMap.filter((i) => i.client !== client);
+    }
+  }
+}
+export {
+  RestInterceptor
+};

package/dist/lib/rest/rest.utils.d.ts

@@ -1,4 +1,4 @@
-import { AxiosError, AxiosResponseHeaders } from "axios";
+import { AxiosError, AxiosResponseHeaders } from 'axios';
 export declare namespace RestUtils {
     const extractServerResponseCode: (e: unknown) => string | null;
     const doesServerErrorMessageContain: (e: AxiosError, text: string) => boolean;

package/dist/lib/rest/rest.utils.mjs

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { isAxiosError } from "axios";
+var RestUtils;
+((RestUtils2) => {
+  RestUtils2.extractServerResponseCode = (e) => {
+    if (e instanceof z.ZodError) {
+      return "validation-exception";
+    }
+    if (!isAxiosError(e)) {
+      return null;
+    }
+    if (!e.response) {
+      return null;
+    }
+    const data = e.response.data;
+    if (typeof data?.code === "string") {
+      return data.code;
+    }
+    return null;
+  };
+  RestUtils2.doesServerErrorMessageContain = (e, text) => {
+    const message = (0, RestUtils2.extractServerErrorMessage)(e);
+    if (message === null || message === void 0) {
+      return false;
+    }
+    return message.toLowerCase().includes(text.toLowerCase());
+  };
+  RestUtils2.extractServerErrorMessage = (e) => {
+    if (e instanceof z.ZodError) {
+      return e.message;
+    }
+    if (!isAxiosError(e)) {
+      return null;
+    }
+    if (!e.response) {
+      return null;
+    }
+    const data = e.response.data;
+    if (typeof data?.message === "string") {
+      return data.message;
+    }
+    return null;
+  };
+  RestUtils2.extractContentDispositionFilename = (headers) => {
+    const contentDisposition = headers["content-disposition"];
+    return contentDisposition ? /filename=["']?([^"';]+)/i.exec(contentDisposition)?.[1] : void 0;
+  };
+})(RestUtils || (RestUtils = {}));
+export {
+  RestUtils
+};