@jwork-space/strapi-sdk 1.0.1

package/dist/index.js

@@ -0,0 +1,1043 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseAPI: () => BaseAPI,
+  BaseUploaderAPI: () => BaseUploaderAPI,
+  LocalStoreManager: () => LocalStoreManager,
+  StrapiSDK: () => StrapiSDK,
+  StrapiUploaderSDK: () => StrapiUploaderSDK,
+  buildPath: () => buildPath,
+  generateFakeFirebaseUID: () => generateFakeFirebaseUID,
+  getKeyByValue: () => getKeyByValue,
+  helperStrapiAPI: () => helperStrapiAPI,
+  isDefined: () => isDefined,
+  isEmptyObject: () => isEmptyObject,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  publicRoutes: () => publicRoutes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var publicRoutes = [
+  "auth/local",
+  "auth/local/register",
+  "recovery-codes"
+];
+function isObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function getKeyByValue(object, value) {
+  return Object.keys(object).find(
+    (key) => object[key] === value
+  );
+}
+function isEmptyObject(object) {
+  return Object.entries(object).length === 0;
+}
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+var generateUID = (length) => {
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * characters.length));
+  }
+  return result;
+};
+var generateFakeFirebaseUID = () => generateUID(10);
+
+// src/base-api-helper.ts
+var HelperStrapiAPI = class {
+  getSortingLocal(values, defaultSorter = "name") {
+    if (!values?.order || !values?.field) return defaultSorter;
+    const map = {
+      ascend: "asc",
+      descend: "desc"
+    };
+    const field = values.field.toString();
+    return `${field}:${map[values.order]}`;
+  }
+  getPayload(object) {
+    const formData = new FormData();
+    const data = { data: {} };
+    Object.keys(object).forEach((proprerty) => {
+      if (object[proprerty] instanceof File) {
+        formData.append(`files.${proprerty}`, object[proprerty]);
+      } else {
+        const value = object[proprerty];
+        data.data[proprerty] = value;
+      }
+    });
+    if (this.isFormDataEmpty(formData)) return data;
+    formData.append("data", JSON.stringify({ data: data.data }));
+    return formData;
+  }
+  isFormDataEmpty(formData) {
+    for (const item of formData.entries()) if (item) return false;
+    return true;
+  }
+};
+var helperStrapiAPI = new HelperStrapiAPI();
+
+// src/http-layer.ts
+var import_axios = __toESM(require("axios"));
+var import_dayjs = __toESM(require("dayjs"));
+var import_qs = __toESM(require("qs"));
+var LocalStoreManager = class {
+  constructor(tokenKey = "jwt") {
+    this.tokenKey = tokenKey;
+  }
+  getLocalStorageKey(key) {
+    return localStorage.getItem(key);
+  }
+  removeStorageKey(key) {
+    localStorage.removeItem(key);
+  }
+  setLocalStorage(key, value) {
+    const existValue = this.getLocalStorageKey(key);
+    if (existValue && existValue !== value) {
+      this.removeStorageKey(key);
+    }
+    localStorage.setItem(key, value);
+  }
+  getToken() {
+    return this.getLocalStorageKey(this.tokenKey);
+  }
+  setToken(token) {
+    const existToken = this.getToken();
+    if (existToken && existToken !== token) {
+      this.removeStorageKey(this.tokenKey);
+    }
+    this.setLocalStorage(this.tokenKey, token);
+  }
+  removeToken() {
+    this.removeStorageKey(this.tokenKey);
+  }
+};
+var HttpLayer = class {
+  constructor(tokenKey) {
+    this.tokenManager = new LocalStoreManager(tokenKey);
+  }
+  mergeHeaders(uri, options) {
+    const baseHeaders = this.getHeaders(options, uri);
+    return {
+      ...baseHeaders,
+      ...options?.headers
+    };
+  }
+  getHeaders({ auth = true, headers }, uri) {
+    const localHeaders = new import_axios.default.AxiosHeaders({
+      ...headers
+    });
+    if (auth) {
+      if (uri.includes("strapi/") && publicRoutes.includes(uri.slice(7)))
+        return localHeaders;
+      localHeaders.Authorization = `Bearer ${this.tokenManager.getToken()}`;
+    }
+    return localHeaders;
+  }
+  async makeRequest(uri, method, opt = {}) {
+    const headers = this.getHeaders(opt, uri);
+    const httpMethod = import_axios.default[method];
+    const config = { headers };
+    if (opt.query) {
+      config.params = { ...opt.query, ...opt.query.extraQuery };
+      delete config.params.extraQuery;
+      config.paramsSerializer = (query) => import_qs.default.stringify(query, { encodeValuesOnly: true });
+    }
+    if (["get", "delete"].includes(method)) {
+      const { data: data2 } = await httpMethod(uri, config);
+      return data2;
+    }
+    const { data } = await httpMethod(uri, opt.body, config);
+    return data;
+  }
+  executeRequest(uri, method, opt = {}) {
+    const httpMethod = import_axios.default[method];
+    const config = {
+      headers: this.mergeHeaders(uri, opt)
+    };
+    if (opt.query) {
+      config.params = { ...opt.query, ...opt.query.extraQuery };
+      delete config.params.extraQuery;
+      config.paramsSerializer = (query) => import_qs.default.stringify(query, { encodeValuesOnly: true });
+    }
+    if (["get", "delete"].includes(method)) return httpMethod(uri, config);
+    return httpMethod(uri, opt.body, config);
+  }
+  async makeRequestV2(uri, method, opt = {}) {
+    const headers = this.getHeaders(opt, uri);
+    const httpMethod = import_axios.default[method];
+    const config = { headers };
+    if (opt.query) {
+      config.params = { ...opt.query, ...opt.query.extraQuery };
+      delete config.params.extraQuery;
+      config.paramsSerializer = (query) => import_qs.default.stringify(query, { encodeValuesOnly: true });
+    }
+    if (["get", "delete"].includes(method))
+      return await httpMethod(uri, config);
+    return await httpMethod(uri, opt.body, config);
+  }
+  getFileName(contentDisposition) {
+    let filename = "file";
+    if (contentDisposition && contentDisposition.includes("filename="))
+      filename = contentDisposition.split("filename=")[1].replaceAll(/["']/g, "");
+    return filename;
+  }
+  async getFileFromAPI({
+    uri,
+    method,
+    opt = {},
+    fileName
+  }) {
+    const headers = this.getHeaders(opt, uri);
+    const config = {
+      headers,
+      responseType: "blob",
+      params: opt.query,
+      data: opt.body
+    };
+    const response = await import_axios.default[method](uri, opt.body, config);
+    const blob = new Blob([response.data], {
+      type: response.headers["content-type"] || "application/octet-stream"
+    });
+    const url = window.URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = fileName ?? this.getFileName(response.headers["content-disposition"]) ?? (0, import_dayjs.default)().format("DDMMYYYYhhmmss");
+    document.body.append(link);
+    link.click();
+    link.remove();
+    window.URL.revokeObjectURL(url);
+  }
+  getCall(uri, opt = {}) {
+    return this.makeRequest(uri, "get", opt);
+  }
+  postCall(uri, opt = {}) {
+    return this.makeRequest(uri, "post", opt);
+  }
+  putCall(uri, opt = {}) {
+    return this.makeRequest(uri, "put", opt);
+  }
+  deleteCall(uri, opt = {}) {
+    return this.makeRequest(uri, "delete", opt);
+  }
+};
+
+// src/base-api.ts
+var buildPath = (...segments) => `/${segments.filter(Boolean).map((s) => s.replaceAll(/^\/|\/$/g, "")).join("/")}`;
+var BaseAPI = class extends HttpLayer {
+  constructor(resource, prefix, tokenKey, baseURL) {
+    super(tokenKey);
+    this.resource = resource;
+    this.prefix = prefix;
+    this.tokenKey = tokenKey;
+    this.baseURL = baseURL;
+    this.buildPath = buildPath;
+    this.normalizePath = (value) => value.replace(/\/+$/, "");
+    const paths = [prefix, resource];
+    const pathURL = this.normalizePath(this.buildPath(...paths));
+    this.endpoint = `${baseURL}${pathURL}`;
+  }
+};
+
+// src/base-api-uploader.ts
+var BaseUploaderAPI = class extends HttpLayer {
+  constructor(resource, prefix, tokenKey, baseURL) {
+    super(tokenKey);
+    this.resource = resource;
+    this.prefix = prefix;
+    this.tokenKey = tokenKey;
+    this.baseURL = baseURL;
+    this.buildPath = buildPath;
+    this.normalizePath = (value) => value.replace(/\/+$/, "");
+    const paths = [prefix, resource];
+    const pathURL = this.normalizePath(this.buildPath(...paths));
+    this.endpoint = `${baseURL}${pathURL}`;
+  }
+};
+
+// src/strapi-sdk.ts
+var import_react_query = require("@tanstack/react-query");
+var StrapiSDK = class extends BaseAPI {
+  constructor(resource, config) {
+    const tokenKey = config?.tokenKey ?? "jwt";
+    const baseURL = config?.baseURL ?? "";
+    const prefix = config?.prefix ?? "";
+    super(resource, prefix, config?.tokenKey, baseURL);
+    this.exist = async (opt) => {
+      const uri = opt?.url ?? this.endpoint;
+      const { data } = await this.getCall(
+        uri,
+        this.getRequestParams({
+          ...opt,
+          pagination: {
+            page: 1,
+            pageSize: 1
+          }
+        })
+      );
+      const list = data;
+      return list.length > 0;
+    };
+    this.listAll = async (opt) => {
+      const uri = opt?.url ?? this.endpoint;
+      const { data, meta } = await this.getCall(
+        uri,
+        this.getRequestParams(opt)
+      );
+      return {
+        data,
+        pagination: {
+          ...meta.pagination,
+          currentTotal: data.length
+        }
+      };
+    };
+    this.getAllData = async (options) => {
+      const list = [];
+      const opt = {
+        sort: "id:asc",
+        pagination: {
+          page: 1,
+          pageSize: 100
+        },
+        ...options
+      };
+      let currentPage = opt.pagination.page;
+      let pageCount = 1;
+      while (currentPage <= pageCount) {
+        const { data, pagination } = await this.listAll(opt);
+        list.push(...data);
+        pageCount = pagination.pageCount;
+        currentPage += 1;
+        opt.pagination.page = currentPage;
+      }
+      return {
+        data: list,
+        opt,
+        paging: { pageCount },
+        pagination: opt.pagination
+      };
+    };
+    this.show = async (id, opt) => {
+      const uri = `${opt?.url ?? this.endpoint}/${id}`;
+      const { data } = await this.getCall(
+        uri,
+        this.getRequestParams(opt)
+      );
+      return data;
+    };
+    this.patchRequest = (options, id, opt) => {
+      if (id) {
+        return {
+          uri: `${opt?.url ?? this.endpoint}/${id}`
+        };
+      }
+      return {
+        uri: opt?.url ?? this.endpoint,
+        options: ["id", ...options.exclude ?? []]
+      };
+    };
+    this.buildPayloadToStore = (model, id) => {
+      const isNew = !id || id === 0;
+      const keyUID = this.config.onCreate.keyUID ?? "strapiUID";
+      const createUID = this.config.onCreate.generateUID ?? true;
+      const isAllowedCreateUID = isNew && createUID;
+      model = {
+        ...model,
+        ...!model.createdAtFirebase && isNew && { createdAtFirebase: /* @__PURE__ */ new Date() },
+        ...!model.strapiUID && isAllowedCreateUID && { [keyUID]: generateFakeFirebaseUID() }
+      };
+      if (id) {
+        delete model.createdAtFirebase;
+        delete model[keyUID];
+      }
+      return model;
+    };
+    this.store = async (model, id, opt, serializeOptions) => {
+      model = this.buildPayloadToStore(model, id);
+      if (opt?.forceUpdateStrapiUID) {
+        model = {
+          ...model,
+          [this.config.onCreate.keyUID ?? "strapiUID"]: generateFakeFirebaseUID()
+        };
+      }
+      const options = { ...serializeOptions };
+      const { uri, options: customOptions } = this.patchRequest(options, id, opt);
+      options.exclude = customOptions;
+      const { id: modelId, ...payload } = model;
+      const data = this.getRequestParams({
+        ...opt,
+        pagination: {
+          page: 1,
+          pageSize: 1
+        }
+      });
+      data.body = this.normalizeBody(
+        payload,
+        id ? "update" : "save",
+        opt ?? {},
+        options
+      );
+      if (id) {
+        const response = await this.putCall(uri, data);
+        return response.data;
+      } else {
+        const { data: dataResponse } = await this.postCall(
+          uri,
+          data
+        );
+        return dataResponse;
+      }
+    };
+    this.save = async (model, opt, serializeOptions) => {
+      if (typeof model.id === "number" && model.id >= 0) {
+        const { id, ...payload } = model;
+        return await this.store(payload, 0, opt, serializeOptions);
+      }
+      return await this.store(model, 0, opt, serializeOptions);
+    };
+    this.update = async (id, model, opt, serializeOptions) => {
+      return await this.store(model, id, opt, serializeOptions);
+    };
+    this.updateOne = async (model, opt, serializeOptions, _createRelations) => {
+      const { id, ...payload } = model;
+      const { data } = await this.makeRequestV2(
+        `${opt?.url ?? this.endpoint}`,
+        "put",
+        {
+          body: this.normalizeBody(
+            payload,
+            "update",
+            opt ?? {},
+            serializeOptions
+          ),
+          ...this.getRequestParams({
+            ...opt,
+            pagination: {
+              page: 1,
+              pageSize: 1
+            }
+          })
+        }
+      );
+      return data;
+    };
+    this.destroy = async (id, opt) => {
+      const uri = `${opt?.url ?? this.endpoint}/${id}`;
+      await this.deleteCall(
+        uri,
+        this.getRequestParams({
+          ...opt,
+          pagination: {
+            page: 1,
+            pageSize: 1
+          }
+        })
+      );
+      return true;
+    };
+    this.findOne = async (opt) => {
+      const uri = opt?.url ?? this.endpoint;
+      if (opt) delete opt.sort;
+      const method = opt?.method ?? "get";
+      opt = {
+        ...opt,
+        pagination: {
+          page: 1,
+          pageSize: 1
+        }
+      };
+      const { data } = method === "get" ? await this.getCall(uri, this.getRequestParams(opt)) : await this.postCall(uri, this.getRequestParams(opt));
+      return data.length > 0 ? data[0] : null;
+    };
+    this.findById = async (id, opt) => {
+      const uri = `${opt?.url ?? this.endpoint}/${id}`;
+      if (opt) delete opt.sort;
+      const { data } = opt?.method === "get" ? await this.getCall(uri, this.getRequestParams(opt)) : await this.postCall(uri, this.getRequestParams(opt));
+      return data;
+    };
+    this.useListAll = (opt) => {
+      return (0, import_react_query.useQuery)({
+        queryKey: [this.endpoint, "listAll", opt],
+        queryFn: async () => {
+          return await this.listAll(opt);
+        }
+      });
+    };
+    this.useListAllCustom = (opt, enabled = true) => {
+      return (0, import_react_query.useQuery)({
+        queryKey: [this.endpoint, "listAll", opt],
+        queryFn: async () => {
+          try {
+            return await this.listAll(opt);
+          } catch (error) {
+            console.error("Error al obtener los datos:", error);
+            return {
+              data: [],
+              pagination: {
+                page: 0,
+                pageCount: 0,
+                pageSize: 0,
+                total: 0,
+                currentTotal: 0
+              }
+            };
+          }
+        },
+        enabled
+      });
+    };
+    this.useGetAllData = (opt) => {
+      return (0, import_react_query.useQuery)({
+        queryKey: [this.endpoint, "getAllData", opt],
+        queryFn: async () => {
+          return await this.getAllData(opt);
+        }
+      });
+    };
+    this.useGetAllDataCustom = (opt, enabled = true) => {
+      return (0, import_react_query.useQuery)({
+        queryKey: [this.endpoint, "listAll", opt],
+        queryFn: async () => {
+          try {
+            const result = await this.getAllData(opt);
+            return result.data ?? [];
+          } catch (error) {
+            console.error("Error al obtener los datos:", error);
+            return [];
+          }
+        },
+        enabled
+      });
+    };
+    //in process
+    this.useExistEntity = (opt) => {
+      return (0, import_react_query.useQuery)({
+        queryKey: [this.endpoint, "exist", opt],
+        queryFn: async () => await this.exist(opt),
+        enabled: false
+      });
+    };
+    this.useShow = (id, opt) => {
+      return (0, import_react_query.useQuery)({
+        queryKey: [this.endpoint, "show", id],
+        queryFn: async () => await this.show(id, opt),
+        enabled: !!id
+      });
+    };
+    this.useFindOneAsync = (opt, enabled) => {
+      return (0, import_react_query.useQuery)({
+        queryKey: [this.endpoint, "findOne"],
+        queryFn: async () => await this.findOne(opt),
+        enabled
+      });
+    };
+    this.useFindOne = (opt) => {
+      return (0, import_react_query.useQuery)({
+        queryKey: [this.endpoint, "findOne", opt],
+        queryFn: async () => {
+          return await this.findOne(opt);
+        }
+      });
+    };
+    this.useFindById = (id, opt) => {
+      return (0, import_react_query.useQuery)({
+        queryKey: [this.endpoint, "findOne", id, opt],
+        queryFn: async () => {
+          return await this.findById(id, opt);
+        }
+      });
+    };
+    this.useStore = (opt) => {
+      const queryClient = (0, import_react_query.useQueryClient)();
+      const keys = this.getInvalidateKeys("update", opt);
+      return (0, import_react_query.useMutation)({
+        mutationFn: async ({
+          data,
+          id,
+          requestOptions,
+          serializeOptions
+        }) => await this.store(data, id, requestOptions, serializeOptions),
+        onSuccess: (data) => {
+          for (const key of keys) {
+            queryClient.invalidateQueries({
+              queryKey: Array.isArray(key) ? key : [key]
+            });
+          }
+          opt?.onSuccess?.(data);
+        },
+        onError: (error) => opt?.onError?.(error)
+      });
+    };
+    this.useSave = (opt) => {
+      const queryClient = (0, import_react_query.useQueryClient)();
+      const keys = this.getInvalidateKeys("save", opt);
+      return (0, import_react_query.useMutation)({
+        mutationFn: async ({
+          data,
+          requestOptions,
+          serializeOptions
+        }) => {
+          return await this.store(
+            data,
+            void 0,
+            requestOptions,
+            serializeOptions
+          );
+        },
+        onSuccess: (data) => {
+          for (const key of keys) {
+            queryClient.invalidateQueries({
+              queryKey: Array.isArray(key) ? key : [key]
+            });
+          }
+          opt?.onSuccess?.(data);
+          return data;
+        },
+        onError: (error) => opt?.onError?.(error)
+      });
+    };
+    this.useUpdate = (opt) => {
+      const queryClient = (0, import_react_query.useQueryClient)();
+      const keys = this.getInvalidateKeys("update", opt);
+      return (0, import_react_query.useMutation)({
+        mutationFn: async ({
+          data,
+          id,
+          requestOptions,
+          serializeOptions
+        }) => await this.store(data, id, requestOptions, serializeOptions),
+        onSuccess: (data) => {
+          for (const key of keys) {
+            queryClient.invalidateQueries({
+              queryKey: Array.isArray(key) ? key : [key]
+            });
+          }
+          opt?.onSuccess?.(data);
+        },
+        onError: (error) => opt?.onError?.(error)
+      });
+    };
+    this.useUpsert = (opt) => {
+      const queryClient = (0, import_react_query.useQueryClient)();
+      const keys = this.getInvalidateKeys("update", opt);
+      return (0, import_react_query.useMutation)({
+        mutationFn: async ({
+          data,
+          id,
+          requestOptions,
+          serializeOptions
+        }) => await this.store(data, id, requestOptions, serializeOptions),
+        onSuccess: (data) => {
+          for (const key of keys) {
+            queryClient.invalidateQueries({
+              queryKey: Array.isArray(key) ? key : [key]
+            });
+          }
+          opt?.onSuccess?.(data);
+        },
+        onError: (error) => opt?.onError?.(error)
+      });
+    };
+    this.useDestroy = (opt) => {
+      const queryClient = (0, import_react_query.useQueryClient)();
+      return (0, import_react_query.useMutation)({
+        mutationFn: async (id) => await this.destroy(id),
+        onSuccess: () => {
+          queryClient.invalidateQueries({ queryKey: [this.endpoint] });
+          opt?.onSuccess?.();
+        },
+        onError: (error) => opt?.onError?.(error)
+      });
+    };
+    this.finOneEntity = async (opt) => {
+      const uri = opt?.url ?? this.endpoint;
+      opt = {
+        ...opt,
+        pagination: { page: 1, pageSize: 2 }
+      };
+      const { data } = await this.getCall(
+        uri,
+        this.getRequestParams({
+          ...opt,
+          pagination: {
+            page: 1,
+            pageSize: 2
+          }
+        })
+      );
+      const list = data;
+      return list.length > 0 ? list[0] : null;
+    };
+    this.config = {
+      onCreate: {
+        generateUID: config?.onCreate?.generateUID ?? true,
+        keyUID: config?.onCreate?.keyUID ?? "strapiUID"
+      },
+      defaultQueriesInvalidations: config?.defaultQueriesInvalidations ?? {},
+      prefix,
+      tokenKey,
+      wrapBodyInData: config?.wrapBodyInData ?? true,
+      transformResponse: config?.transformResponse ?? true,
+      pageSize: config?.pageSize ?? 15,
+      baseURL
+    };
+  }
+  getQueryParams(opt) {
+    const query = {
+      sort: opt?.sort || "id:asc",
+      pagination: {
+        page: opt?.pagination?.page || 1,
+        pageSize: opt?.pagination?.pageSize || this.config.pageSize
+      }
+    };
+    if (opt?.populate) query.populate = opt.populate;
+    query.filters = {
+      ...query.filters,
+      ...opt?.filters
+    };
+    if (opt?.fields) query.fields = opt.fields;
+    return query;
+  }
+  normalizeBody(model, action, { multipart, transformModel }, serializeOptions) {
+    if (multipart) return multipart(model, action);
+    const data = transformModel ? transformModel(model, action) : model;
+    const body = this.serialize(data, serializeOptions);
+    return this.config.wrapBodyInData ? { data: body } : body;
+  }
+  getRequestParams(opt) {
+    const options = {
+      auth: opt?.auth ?? true,
+      query: this.getQueryParams(opt)
+    };
+    return options;
+  }
+  async requestExecutor({ uri, data }) {
+    return await this.postCall(uri, data);
+  }
+  serialize(model, options) {
+    const payload = {};
+    const opt = this.buildOptions(options);
+    for (const [key, value] of Object.entries(model)) {
+      if (this.shouldSkipKey(key, value, opt)) continue;
+      payload[key] = this.transformValue(key, value, opt);
+    }
+    return payload;
+  }
+  shouldSkipKey(key, value, opt) {
+    return opt.exclude.includes(key) || !opt.preserveBlank && (!isDefined(value) || value === "");
+  }
+  transformValue(key, value, opt) {
+    if (Array.isArray(value)) {
+      return this.serializeArray(value, key, opt);
+    }
+    if (isObject(value)) {
+      if (value.id === 0) delete value.id;
+      return opt.onlyIdForRelations && !opt.preserveRelations.includes(key) ? value.id : value;
+    }
+    return value;
+  }
+  // Utils
+  buildOptions(options) {
+    return {
+      preserveBlank: options?.preserveBlank ?? false,
+      onlyIdForRelations: options?.onlyIdForRelations ?? false,
+      preserveRelations: options?.preserveRelations ?? [],
+      exclude: options?.exclude ?? [],
+      removeEmptyArrays: options?.removeEmptyArrays ?? true,
+      removeEmptyObjects: options?.removeEmptyObjects ?? true
+    };
+  }
+  serializeArray(value, _key, opt) {
+    if (value.every((item) => isObject(item))) {
+      return value.map((item) => {
+        return opt.onlyIdForRelations ? item.id : item;
+      });
+    }
+    if (!opt.removeEmptyArrays || value.length > 0) {
+      return value;
+    }
+  }
+  getInvalidateKeys(method, opt) {
+    const defaultKeys = this.defaultInvalidateKeys?.[method] ?? [[]];
+    const extraKeys = opt?.invalidateKeys ?? [];
+    return [...defaultKeys, ...extraKeys, [this.endpoint]];
+  }
+  async findOrCreate(data, optFind, optPayload, serializeOptionsPayload) {
+    const exist = await this.finOneEntity(optFind);
+    if (exist) return exist;
+    return await this.store(data, 0, optPayload, serializeOptionsPayload);
+  }
+  async findAndUpdate(data, optFilter, optPayload, serializeOptionsPayload) {
+    const exist = await this.finOneEntity(optFilter);
+    if (exist) {
+      return await this.store(
+        data,
+        exist.id,
+        optPayload,
+        serializeOptionsPayload
+      );
+    }
+  }
+  async upsert(data, opt, serializeOptions) {
+    const exist = await this.finOneEntity(opt);
+    if (exist) {
+      return await this.store(data, exist.id, opt, serializeOptions);
+    }
+    return await this.store(data, 0, opt, serializeOptions);
+  }
+};
+
+// src/strapi-uploader.sdk.ts
+var import_react_query2 = require("@tanstack/react-query");
+var StrapiUploaderSDK = class extends BaseUploaderAPI {
+  constructor(resource, config) {
+    const tokenKey = config?.tokenKey ?? "jwt";
+    const baseURL = config?.baseURL ?? "";
+    const prefix = config?.prefix ?? "";
+    super(resource, prefix, config?.tokenKey, baseURL);
+    this.uploadStrapiFile = async (resource, opt) => {
+      const uri = opt?.url ?? `${this.baseURL}/upload`;
+      const data = this.getRequestParams(opt);
+      const formData = new FormData();
+      const isMultiple = Array.isArray(resource);
+      const files = isMultiple ? resource : [resource];
+      files.forEach((file) => {
+        formData.append("files", file);
+      });
+      const fileInfos = files.map((file) => {
+        const fileName = file.name || "uploaded_file";
+        const info = { name: fileName };
+        if (opt?.folder) {
+          info.folder = opt.folder;
+        }
+        return info;
+      });
+      const fileInfoPayload = fileInfos.length === 1 ? fileInfos[0] : fileInfos;
+      formData.append("fileInfo", JSON.stringify(fileInfoPayload));
+      data.body = formData;
+      try {
+        const dataResponse = await this.postCall(
+          uri,
+          data
+        );
+        if (!dataResponse || !Array.isArray(dataResponse)) {
+          throw new Error("Respuesta inesperada del servidor");
+        }
+        return dataResponse;
+      } catch (error) {
+        console.error("\u274C Error al subir archivo:", error);
+        throw error;
+      }
+    };
+    this.downloadFile = async (data, fileName, optRequest) => {
+      const uri = `${this.baseURL}/data-log/export-to-excel`;
+      const method = "post";
+      const opt = {
+        body: { data },
+        responseType: "blob",
+        ...optRequest
+      };
+      await this.getFileFromAPI({ uri, method, opt, fileName });
+    };
+    this.uploadStrapiImages = async (fileList, oldImages = []) => {
+      const oldFiles = new Set(
+        fileList.filter((f) => !f.originFileObj).map((item) => Number(item.uid))
+      );
+      const filesToUpload = fileList.map((f) => f.originFileObj).filter((f) => !!f);
+      const imagesUpdates = oldImages.filter((image) => oldFiles.has(image.id));
+      if (filesToUpload.length === 0) {
+        return imagesUpdates;
+      }
+      try {
+        const newsImages = await this.uploadStrapiFile(filesToUpload);
+        return [...imagesUpdates, ...newsImages];
+      } catch (error) {
+        console.error("Error al subir archivos:", error);
+        return [];
+      }
+    };
+    this.useUploadImages = (opt) => {
+      return (0, import_react_query2.useMutation)({
+        mutationFn: async ({
+          fileList,
+          oldImages = []
+        }) => {
+          const oldFiles = new Set(
+            fileList.filter((f) => !f.originFileObj).map((item) => Number(item.uid))
+          );
+          const filesToUpload = fileList.map((f) => f.originFileObj).filter((f) => !!f);
+          const imagesUpdates = oldImages?.filter(
+            (image) => oldFiles.has(image.id)
+          );
+          if (filesToUpload.length === 0) {
+            return imagesUpdates;
+          }
+          try {
+            const newsImages = await this.uploadStrapiFile(filesToUpload);
+            return [...imagesUpdates, ...newsImages];
+          } catch (error) {
+            console.error("Error al subir archivos:", error);
+            return [];
+          }
+        },
+        onSuccess: (data) => {
+          opt?.onSuccess?.(data);
+        },
+        onError: (error) => opt?.onError?.(error)
+      });
+    };
+    this.useUploadImagesCreate = (opt) => {
+      const queryClient = (0, import_react_query2.useQueryClient)();
+      const keys = this.getInvalidateKeys("save", opt);
+      return (0, import_react_query2.useMutation)({
+        mutationFn: async ({ fileList }) => {
+          const filesToUpload = fileList.map((f) => f.originFileObj).filter((f) => !!f);
+          try {
+            if (filesToUpload.length === 0) return [];
+            return await this.uploadStrapiFile(filesToUpload);
+          } catch (error) {
+            console.error("Error al subir archivos:", error);
+            return [];
+          }
+        },
+        onSuccess: (data) => {
+          for (const key of keys) {
+            queryClient.invalidateQueries({
+              queryKey: Array.isArray(key) ? key : [key]
+            });
+          }
+          opt?.onSuccess?.(data);
+        },
+        onError: (error) => opt?.onError?.(error)
+      });
+    };
+    this.uploadMergerImages = async (fileList, oldImages = []) => {
+      const oldFiles = new Set(
+        fileList.filter((f) => !f.originFileObj).map((item) => Number(item.uid))
+      );
+      const filesToUpload = fileList.map((f) => f.originFileObj).filter((f) => !!f);
+      const imagesUpdates = oldImages.filter((image) => oldFiles.has(image.id));
+      if (filesToUpload.length === 0) {
+        return imagesUpdates;
+      }
+      try {
+        const newsImages = await this.uploadStrapiFile(filesToUpload);
+        return [...imagesUpdates, ...newsImages];
+      } catch (error) {
+        console.error("Error al subir archivos:", error);
+        return [];
+      }
+    };
+    this.newUploadFile = async (resource, opt, serializeOptions) => {
+      const options = { ...serializeOptions };
+      const uri = opt?.url ?? "/strapi/upload-file";
+      const data = this.getRequestParams(opt);
+      options.exclude = ["id", ...options.exclude ?? []];
+      const formData = new FormData();
+      formData.append("files.files", resource);
+      data.body = formData;
+      const dataResponse = await this.postCall(uri, data);
+      return dataResponse;
+    };
+    this.config = {
+      onCreate: {
+        generateUID: config?.onCreate?.generateUID ?? true,
+        keyUID: config?.onCreate?.keyUID ?? "strapiUID"
+      },
+      defaultQueriesInvalidations: config?.defaultQueriesInvalidations ?? {},
+      prefix,
+      tokenKey,
+      wrapBodyInData: config?.wrapBodyInData ?? true,
+      transformResponse: config?.transformResponse ?? true,
+      pageSize: config?.pageSize ?? 15,
+      baseURL
+    };
+  }
+  getQueryParams(opt) {
+    const query = {
+      sort: opt?.sort || "id:asc",
+      pagination: {
+        page: opt?.pagination?.page || 1,
+        pageSize: opt?.pagination?.pageSize || this.config.pageSize
+      }
+    };
+    if (opt?.populate) query.populate = opt.populate;
+    query.filters = {
+      ...query.filters,
+      ...opt?.filters
+    };
+    if (opt?.fields) query.fields = opt.fields;
+    return query;
+  }
+  getRequestParams(opt) {
+    const options = {
+      auth: opt?.auth ?? true,
+      query: this.getQueryParams(opt)
+    };
+    return options;
+  }
+  async destroyFile(id) {
+    const uri = `${this.baseURL}/strapi/upload/files/${id}`;
+    await this.deleteCall(uri);
+    return true;
+  }
+  getInvalidateKeys(method, opt) {
+    const defaultKeys = this.defaultInvalidateKeys?.[method] ?? [[]];
+    const extraKeys = opt?.invalidateKeys ?? [];
+    return [...defaultKeys, ...extraKeys, [this.endpoint]];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseAPI,
+  BaseUploaderAPI,
+  LocalStoreManager,
+  StrapiSDK,
+  StrapiUploaderSDK,
+  buildPath,
+  generateFakeFirebaseUID,
+  getKeyByValue,
+  helperStrapiAPI,
+  isDefined,
+  isEmptyObject,
+  isObject,
+  isPlainObject,
+  publicRoutes
+});