typedapi-client-helpers 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -20,67 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  TypedApiToastProvider: () => TypedApiToastProvider,
   buildQuery: () => buildQuery,
-  extractArgsToastsAndParams: () => extractArgsToastsAndParams,
+  extractArgsCallbacksAndParams: () => extractArgsCallbacksAndParams,
   getSortDirectionFromSortType: () => getSortDirectionFromSortType,
   getSortTypeFromSortDirection: () => getSortTypeFromSortDirection,
   handleApiResponse: () => handleApiResponse,
-  resetUnauthorizedHandling: () => resetUnauthorizedHandling,
   sortTypes: () => sortTypes,
-  toFormData: () => toFormData,
-  toast: () => toast
+  toFormData: () => toFormData
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/toast/toast.tsx
-var import_react_toastify = require("react-toastify");
-var import_jsx_runtime = require("react/jsx-runtime");
-function ToastContent({ title, message }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: title }),
-    message && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: message })
-  ] });
-}
-var toast = {
-  success(message, title = "Success!") {
-    import_react_toastify.toast.success(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(ToastContent, { title, message }));
-  },
-  error(message, title = "Error!") {
-    import_react_toastify.toast.error(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(ToastContent, { title, message }));
-  },
-  warning(message, title = "Warning!") {
-    import_react_toastify.toast.warning(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(ToastContent, { title, message }));
-  },
-  info(message, title = "Info") {
-    import_react_toastify.toast.info(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(ToastContent, { title, message }));
-  },
-  async errorResponse(error) {
-    let message = "Something went wrong.";
-    try {
-      if (error instanceof Response) {
-        const text = await error.text();
-        message = text || message;
-      } else if (error instanceof Error) {
-        message = error.message;
-      } else if (typeof error === "string") {
-        message = error;
-      } else if (error && typeof error === "object") {
-        message = JSON.stringify(error);
-      }
-    } catch {
-    }
-    import_react_toastify.toast.error(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(ToastContent, { title: "Error!", message }));
-  }
-};
-
-// src/toast/ToastProvider.tsx
-var import_react_toastify2 = require("react-toastify");
-var import_jsx_runtime2 = require("react/jsx-runtime");
-function TypedApiToastProvider() {
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_toastify2.ToastContainer, { position: "bottom-right" });
-}
-
 // src/utils/buildQuery.ts
 function buildQuery(filters, page = 1, pageSize = 100, sortBy = null, sortDirection) {
   let isPageSizeSet = pageSize > 0;
@@ -150,111 +99,81 @@ function convertType(type, value) {
 }
 
 // src/utils/extractArgsToastsAndParams.ts
-function isToastOptions(value) {
-  return typeof value === "object" && value !== null && ("toastSuccess" in value || "toastError" in value);
+function isCallback(value) {
+  return typeof value === "function";
 }
 function isRequestParams(value) {
-  return typeof value === "object" && value !== null && !isToastOptions(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function extractArgsToastsAndParams(argsWithToast) {
-  const args = [...argsWithToast];
-  let toastOptions;
+function extractArgsCallbacksAndParams(argsWithCallbacks) {
+  const values = [...argsWithCallbacks];
+  let onSuccess;
+  let onError;
   let params;
-  const lastArg = args[args.length - 1];
-  if (isRequestParams(lastArg)) {
-    params = lastArg;
-    args.pop();
+  let lastArgument = values[values.length - 1];
+  if (isRequestParams(lastArgument)) {
+    params = lastArgument;
+    values.pop();
+  }
+  lastArgument = values[values.length - 1];
+  if (isCallback(lastArgument)) {
+    onError = lastArgument;
+    values.pop();
   }
-  const newLastArg = args[args.length - 1];
-  if (isToastOptions(newLastArg)) {
-    toastOptions = newLastArg;
-    args.pop();
+  lastArgument = values[values.length - 1];
+  if (isCallback(lastArgument)) {
+    onSuccess = lastArgument;
+    values.pop();
   }
   return {
-    args,
-    toastOptions,
+    args: values,
+    onSuccess,
+    onError,
     params
   };
 }
 
 // src/utils/handleApiResponse.ts
-var isHandlingUnauthorized = false;
-function handleUnauthorized() {
-  if (isHandlingUnauthorized) {
-    return {
-      ok: false,
-      status: 401,
-      response: void 0,
-      error: new Error("Unauthorized")
-    };
+async function readResponseBody(response) {
+  if (response.status === 204) {
+    return void 0;
   }
-  isHandlingUnauthorized = true;
-  localStorage.removeItem("loggedInUser");
-  sessionStorage.clear();
-  toast.error("Your session has expired. Please log in again.", "Session Expired");
-  if (window.location.pathname !== "/login") {
-    window.dispatchEvent(new Event("unauthorized"));
+  const text = await response.text();
+  if (!text) {
+    return void 0;
   }
-  return {
-    ok: false,
-    status: 401,
-    response: void 0,
-    error: new Error("Unauthorized")
-  };
-}
-function resetUnauthorizedHandling() {
-  isHandlingUnauthorized = false;
+  const contentType = response.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    return JSON.parse(text);
+  }
+  return text;
 }
-async function handleApiResponse(call, toastOptions) {
+async function handleApiResponse(call, options) {
   let response;
   try {
     response = await call();
-    if (response.status === 401) {
-      return handleUnauthorized();
-    }
-    let data;
-    try {
-      const textData = await response.text();
-      data = textData ? JSON.parse(textData) : void 0;
-    } catch {
-      data = void 0;
-    }
+    const data = await readResponseBody(response);
     if (response.ok) {
-      if (toastOptions?.toastSuccess) {
-        toast.success(
-          toastOptions.toastSuccess.message,
-          toastOptions.toastSuccess.title
-        );
-      }
+      await options?.onSuccess?.(data);
       return {
         ok: true,
         status: response.status,
         response: data
       };
     }
-    if (toastOptions?.toastError) {
-      toast.error(
-        toastOptions.toastError.message,
-        toastOptions.toastError.title
-      );
-    } else {
-      await toast.errorResponse(response);
-    }
+    const errorData = data;
+    await options?.onError?.(errorData);
     return {
       ok: false,
       status: response.status,
       response: data,
-      error: null
+      error: errorData
     };
   } catch (error) {
-    const status = error instanceof Response ? error.status : response?.status ?? 0;
-    if (status === 401) {
-      return handleUnauthorized();
-    }
-    await toast.errorResponse(error);
+    await options?.onError?.(error);
     return {
       ok: false,
-      status,
+      status: error instanceof Response ? error.status : response?.status ?? 0,
       response: void 0,
       error
     };
@@ -292,6 +211,514 @@ function getSortDirectionFromSortType(sortType) {
   }
 }
 
+// src/api/generated/http-client.ts
+var HttpClient = class {
+  constructor(apiConfig = {}) {
+    this.baseUrl = "https://localhost:7000";
+    this.securityData = null;
+    this.abortControllers = /* @__PURE__ */ new Map();
+    this.customFetch = (...fetchParams) => fetch(...fetchParams);
+    this.baseApiParams = {
+      credentials: "same-origin",
+      headers: {},
+      redirect: "follow",
+      referrerPolicy: "no-referrer"
+    };
+    this.setSecurityData = (data) => {
+      this.securityData = data;
+    };
+    this.contentFormatters = {
+      ["application/json" /* Json */]: (input) => input !== null && (typeof input === "object" || typeof input === "string") ? JSON.stringify(input) : input,
+      ["application/vnd.api+json" /* JsonApi */]: (input) => input !== null && (typeof input === "object" || typeof input === "string") ? JSON.stringify(input) : input,
+      ["text/plain" /* Text */]: (input) => input !== null && typeof input !== "string" ? JSON.stringify(input) : input,
+      ["multipart/form-data" /* FormData */]: (input) => {
+        if (input instanceof FormData) {
+          return input;
+        }
+        return Object.keys(input || {}).reduce((formData, key) => {
+          const property = input[key];
+          formData.append(
+            key,
+            property instanceof Blob ? property : typeof property === "object" && property !== null ? JSON.stringify(property) : `${property}`
+          );
+          return formData;
+        }, new FormData());
+      },
+      ["application/x-www-form-urlencoded" /* UrlEncoded */]: (input) => this.toQueryString(input)
+    };
+    this.createAbortSignal = (cancelToken) => {
+      if (this.abortControllers.has(cancelToken)) {
+        const abortController2 = this.abortControllers.get(cancelToken);
+        if (abortController2) {
+          return abortController2.signal;
+        }
+        return void 0;
+      }
+      const abortController = new AbortController();
+      this.abortControllers.set(cancelToken, abortController);
+      return abortController.signal;
+    };
+    this.abortRequest = (cancelToken) => {
+      const abortController = this.abortControllers.get(cancelToken);
+      if (abortController) {
+        abortController.abort();
+        this.abortControllers.delete(cancelToken);
+      }
+    };
+    this.request = async ({
+      body,
+      secure,
+      path,
+      type,
+      query,
+      format,
+      baseUrl,
+      cancelToken,
+      ...params
+    }) => {
+      const secureParams = (typeof secure === "boolean" ? secure : this.baseApiParams.secure) && this.securityWorker && await this.securityWorker(this.securityData) || {};
+      const requestParams = this.mergeRequestParams(params, secureParams);
+      const queryString = query && this.toQueryString(query);
+      const payloadFormatter = this.contentFormatters[type || "application/json" /* Json */];
+      const responseFormat = format || requestParams.format;
+      return this.customFetch(
+        `${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`,
+        {
+          ...requestParams,
+          headers: {
+            ...requestParams.headers || {},
+            ...type && type !== "multipart/form-data" /* FormData */ ? { "Content-Type": type } : {}
+          },
+          signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
+          body: typeof body === "undefined" || body === null ? null : payloadFormatter(body)
+        }
+      ).then(async (response) => {
+        const r = response;
+        r.data = null;
+        r.error = null;
+        const responseToParse = responseFormat ? response.clone() : response;
+        const data = !responseFormat ? r : await responseToParse[responseFormat]().then((data2) => {
+          if (r.ok) {
+            r.data = data2;
+          } else {
+            r.error = data2;
+          }
+          return r;
+        }).catch((e) => {
+          r.error = e;
+          return r;
+        });
+        if (cancelToken) {
+          this.abortControllers.delete(cancelToken);
+        }
+        if (!response.ok) throw data;
+        return data;
+      });
+    };
+    Object.assign(this, apiConfig);
+  }
+  encodeQueryParam(key, value) {
+    const encodedKey = encodeURIComponent(key);
+    return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
+  }
+  addQueryParam(query, key) {
+    return this.encodeQueryParam(key, query[key]);
+  }
+  addArrayQueryParam(query, key) {
+    const value = query[key];
+    return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+  }
+  toQueryString(rawQuery) {
+    const query = rawQuery || {};
+    const keys = Object.keys(query).filter(
+      (key) => "undefined" !== typeof query[key]
+    );
+    return keys.map(
+      (key) => Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)
+    ).join("&");
+  }
+  addQueryParams(rawQuery) {
+    const queryString = this.toQueryString(rawQuery);
+    return queryString ? `?${queryString}` : "";
+  }
+  mergeRequestParams(params1, params2) {
+    return {
+      ...this.baseApiParams,
+      ...params1,
+      ...params2 || {},
+      headers: {
+        ...this.baseApiParams.headers || {},
+        ...params1.headers || {},
+        ...params2 && params2.headers || {}
+      }
+    };
+  }
+};
+
+// src/api/generated/Import.ts
+var Import = class extends HttpClient {
+  constructor() {
+    super(...arguments);
+    /**
+     * No description
+     *
+     * @tags Import
+     * @name UploadProductFile
+     * @request POST:/api/import/products
+     */
+    this.uploadProductFile = (data, params = {}) => this.request({
+      path: `/api/import/products`,
+      method: "POST",
+      body: data,
+      type: "multipart/form-data" /* FormData */,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Import
+     * @name UploadSupplierFile
+     * @request POST:/api/import/suppliers
+     */
+    this.uploadSupplierFile = (data, params = {}) => this.request({
+      path: `/api/import/suppliers`,
+      method: "POST",
+      body: data,
+      type: "multipart/form-data" /* FormData */,
+      format: "json",
+      ...params
+    });
+  }
+};
+
+// src/api/methods/Import.api.ts
+var importApi = new Import();
+
+// src/api/generated/Order.ts
+var Order = class extends HttpClient {
+  constructor() {
+    super(...arguments);
+    /**
+     * No description
+     *
+     * @tags Order
+     * @name GetOrders
+     * @request GET:/api/orders
+     */
+    this.getOrders = (query = {}, params = {}) => this.request({
+      path: `/api/orders`,
+      method: "GET",
+      query,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Order
+     * @name CreateOrder
+     * @request POST:/api/orders
+     */
+    this.createOrder = (data, params = {}) => this.request({
+      path: `/api/orders`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Order
+     * @name GetOrderById
+     * @request GET:/api/orders/{id}
+     */
+    this.getOrderById = ({ id }, params = {}) => this.request({
+      path: `/api/orders/${id}`,
+      method: "GET",
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Order
+     * @name ApproveOrder
+     * @request PUT:/api/orders/{id}/approve
+     */
+    this.approveOrder = ({ id }, data, params = {}) => this.request({
+      path: `/api/orders/${id}/approve`,
+      method: "PUT",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json",
+      ...params
+    });
+  }
+};
+
+// src/api/methods/Order.api.ts
+var orderApi = new Order();
+async function getOrders(query, onSuccess, onError, params) {
+  return handleApiResponse(
+    () => orderApi.getOrders(query, params ?? {}),
+    { onSuccess, onError }
+  );
+}
+
+// src/api/generated/Product.ts
+var Product = class extends HttpClient {
+  constructor() {
+    super(...arguments);
+    /**
+     * No description
+     *
+     * @tags Product
+     * @name GetProducts
+     * @request GET:/api/products
+     */
+    this.getProducts = (query = {}, params = {}) => this.request({
+      path: `/api/products`,
+      method: "GET",
+      query,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Product
+     * @name CreateProduct
+     * @request POST:/api/products
+     */
+    this.createProduct = (data, params = {}) => this.request({
+      path: `/api/products`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Product
+     * @name GetProductById
+     * @request GET:/api/products/{id}
+     */
+    this.getProductById = ({ id }, params = {}) => this.request({
+      path: `/api/products/${id}`,
+      method: "GET",
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Product
+     * @name UpdateProduct
+     * @request PUT:/api/products/{id}
+     */
+    this.updateProduct = ({ id }, data, params = {}) => this.request({
+      path: `/api/products/${id}`,
+      method: "PUT",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Product
+     * @name DeleteProduct
+     * @request DELETE:/api/products/{id}
+     */
+    this.deleteProduct = ({ id }, params = {}) => this.request({
+      path: `/api/products/${id}`,
+      method: "DELETE",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Product
+     * @name SearchProducts
+     * @request GET:/api/products/search
+     */
+    this.searchProducts = (query = {}, params = {}) => this.request({
+      path: `/api/products/search`,
+      method: "GET",
+      query,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Product
+     * @name ExportProducts
+     * @request GET:/api/products/export
+     */
+    this.exportProducts = (query = {}, params = {}) => this.request({
+      path: `/api/products/export`,
+      method: "GET",
+      query,
+      ...params
+    });
+  }
+};
+
+// src/api/methods/Product.api.ts
+var productApi = new Product();
+
+// src/api/generated/Report.ts
+var Report = class extends HttpClient {
+  constructor() {
+    super(...arguments);
+    /**
+     * No description
+     *
+     * @tags Report
+     * @name GetInventorySummary
+     * @request GET:/api/reports/summary
+     */
+    this.getInventorySummary = (query = {}, params = {}) => this.request({
+      path: `/api/reports/summary`,
+      method: "GET",
+      query,
+      format: "json",
+      ...params
+    });
+  }
+};
+
+// src/api/methods/Report.api.ts
+var reportApi = new Report();
+
+// src/api/generated/Supplier.ts
+var Supplier = class extends HttpClient {
+  constructor() {
+    super(...arguments);
+    /**
+     * No description
+     *
+     * @tags Supplier
+     * @name GetSuppliers
+     * @request GET:/api/suppliers
+     */
+    this.getSuppliers = (query = {}, params = {}) => this.request({
+      path: `/api/suppliers`,
+      method: "GET",
+      query,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Supplier
+     * @name CreateSupplier
+     * @request POST:/api/suppliers
+     */
+    this.createSupplier = (data, params = {}) => this.request({
+      path: `/api/suppliers`,
+      method: "POST",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Supplier
+     * @name GetSupplierById
+     * @request GET:/api/suppliers/{id}
+     */
+    this.getSupplierById = ({ id }, params = {}) => this.request({
+      path: `/api/suppliers/${id}`,
+      method: "GET",
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Supplier
+     * @name UpdateSupplier
+     * @request PUT:/api/suppliers/{id}
+     */
+    this.updateSupplier = ({ id }, data, params = {}) => this.request({
+      path: `/api/suppliers/${id}`,
+      method: "PUT",
+      body: data,
+      type: "application/json" /* Json */,
+      format: "json",
+      ...params
+    });
+    /**
+     * No description
+     *
+     * @tags Supplier
+     * @name DeleteSupplier
+     * @request DELETE:/api/suppliers/{id}
+     */
+    this.deleteSupplier = ({ id }, params = {}) => this.request({
+      path: `/api/suppliers/${id}`,
+      method: "DELETE",
+      ...params
+    });
+  }
+};
+
+// src/api/methods/Supplier.api.ts
+var supplierApi = new Supplier();
+async function createSupplier(...argsWithCallbacks) {
+  const {
+    args,
+    onSuccess,
+    onError,
+    params
+  } = extractArgsCallbacksAndParams(argsWithCallbacks);
+  const requestArgs = [
+    ...args,
+    params ?? {}
+  ];
+  return handleApiResponse(
+    () => supplierApi.createSupplier(
+      ...requestArgs
+    ),
+    {
+      onSuccess,
+      onError
+    }
+  );
+}
+async function getSupplierById(...argsWithCallbacks) {
+  const {
+    args,
+    onSuccess,
+    onError,
+    params
+  } = extractArgsCallbacksAndParams(argsWithCallbacks);
+  const requestArgs = [
+    ...args,
+    params ?? {}
+  ];
+  return handleApiResponse(
+    () => supplierApi.getSupplierById(
+      ...requestArgs
+    ),
+    {
+      onSuccess,
+      onError
+    }
+  );
+}
+
 // src/utils/toFormData.ts
 function toFormData(payload) {
   const formData = new FormData();
@@ -324,16 +751,49 @@ function appendFormDataValue(formData, key, value) {
   }
   formData.append(key, JSON.stringify(value));
 }
+var x = createSupplier(
+  { id: "", name: "Test Supplier", active: true, countryCode: "US", email: "test.supplier@example.com", rating: 4.5 },
+  () => {
+    console.info("Created");
+  },
+  (error) => {
+    console.error("Error", error);
+  }
+);
+var y = getOrders(
+  {},
+  (response) => {
+    console.info("Created", response);
+  },
+  (error) => {
+    console.error("Error", error);
+  }
+);
+var x2 = getSupplierById(
+  { id: "1" },
+  () => {
+    console.info("Created");
+  },
+  (error) => {
+    console.error("Error", error);
+  }
+);
+var y2 = getSupplierById(
+  { id: "1" },
+  (response) => {
+    console.info("Created", response);
+  },
+  (error) => {
+    console.error("Error", error);
+  }
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  TypedApiToastProvider,
   buildQuery,
-  extractArgsToastsAndParams,
+  extractArgsCallbacksAndParams,
   getSortDirectionFromSortType,
   getSortTypeFromSortDirection,
   handleApiResponse,
-  resetUnauthorizedHandling,
   sortTypes,
-  toFormData,
-  toast
+  toFormData
 });