@pakento/cms-sdk 4.3.1 → 4.3.2

package/dist/index.js

@@ -30,25 +30,28 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  CacheService: () => CacheService,
-  pakentoCMSAPI: () => pakentoCMSAPI,
-  parseRawItemToItem: () => parseRawItemToItem,
-  parseRawItemsToItems: () => parseRawItemsToItems
+  ApiClient: () => ApiClient,
+  brandsApi: () => brandsApi,
+  categoriesApi: () => categoriesApi,
+  contactApi: () => contactApi,
+  customApi: () => customApi,
+  entityApi: () => entityApi,
+  itemsApi: () => itemsApi,
+  ordersApi: () => ordersApi
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/services/api.ts
+// src/api/core/apiClient.ts
 var import_axios = __toESM(require("axios"));
+var import_zod = require("zod");
 
-// src/services/cache.ts
+// src/api/core/cache.ts
 var import_redis = require("@upstash/redis");
 var import_crypto = require("crypto");
 var CacheService = class {
-  isCacheEnvelope(value) {
-    return typeof value === "object" && value !== null && "__pakento_cache_version" in value && "data" in value;
-  }
-  constructor(defaultTTL, apiKey) {
-    this.defaultTTL = defaultTTL;
+  // 24 hours
+  constructor(apiKey) {
+    this.defaultTTL = 86400;
     this.apiKeyHash = (0, import_crypto.createHash)("sha256").update(apiKey).digest("hex").substring(0, 8);
     if (process.env.UPSTASH_REDIS_REST_URL && process.env.UPSTASH_REDIS_REST_TOKEN) {
       this.redis = new import_redis.Redis({
@@ -58,269 +61,51 @@ var CacheService = class {
     }
   }
   generateParamsHash(params) {
-    const canonicalize = (value) => {
-      if (value === void 0) return void 0;
-      if (value === null) return null;
-      if (Array.isArray(value)) {
-        return value.map((v) => canonicalize(v));
-      }
-      if (typeof value === "object") {
-        const obj = value;
-        const result = {};
-        Object.keys(obj).sort().forEach((key) => {
-          const canon = canonicalize(obj[key]);
-          if (canon !== void 0) {
-            result[key] = canon;
-          }
-        });
-        return result;
-      }
-      return value;
-    };
-    const canonicalParams = canonicalize(params);
-    const paramsString = JSON.stringify(canonicalParams);
+    const paramsString = JSON.stringify(params, Object.keys(params).sort());
     return (0, import_crypto.createHash)("sha256").update(paramsString).digest("hex").substring(0, 16);
   }
   buildCacheKey(functionName, params = {}) {
     const paramsHash = this.generateParamsHash(params);
     return `pakento:${this.apiKeyHash}:${functionName}:${paramsHash}`;
   }
-  safeJsonParse(data) {
-    try {
-      if (typeof data === "object" && data !== null) {
-        return data;
-      }
-      if (typeof data === "string") {
-        return JSON.parse(data);
-      }
-      return data;
-    } catch (error) {
-      console.warn("[PakentoSDK] Error en safeJsonParse:", error);
-      console.warn("[PakentoSDK] Datos que causaron error:", {
-        type: typeof data,
-        isArray: Array.isArray(data),
-        data
-      });
-      return null;
-    }
-  }
-  serializeForCache(value) {
-    try {
-      const cacheData = {
-        __pakento_cache_version: "2.0",
-        __pakento_timestamp: Date.now(),
-        data: value
-      };
-      return JSON.stringify(cacheData);
-    } catch (error) {
-      console.warn("[PakentoSDK] Error en serializeForCache:", error);
-      return JSON.stringify(value);
-    }
-  }
-  async getCachedOrFetch(key, fetcher, ttl, skipCache = false) {
-    if (!this.redis || skipCache) {
+  async cacheWrap(key, fetcher) {
+    if (!this.redis) {
       return fetcher();
     }
+    let cached = null;
     try {
-      const cached = await this.redis.get(key);
-      if (cached !== null && cached !== void 0) {
-        try {
-          const parsed = this.safeJsonParse(cached);
-          if (parsed !== null) {
-            if (this.isCacheEnvelope(parsed)) {
-              console.log("[PakentoSDK] Cache encontrado y devuelto");
-              return parsed.data;
-            } else {
-              console.log("[PakentoSDK] Cache encontrado y devuelto");
-              return parsed;
-            }
-          } else {
-            console.warn(`[PakentoSDK] \u26A0\uFE0F Error parseando cache para: ${key}`);
-            console.warn(`[PakentoSDK] Datos raw del cache:`, {
-              type: typeof cached,
-              value: cached
-            });
-            this.clearCorruptedCache(key).catch(
-              (err) => console.warn(
-                `[PakentoSDK] Error limpiando cache corrupto: ${err}`
-              )
-            );
-          }
-        } catch (parseError) {
-          console.warn(
-            `[PakentoSDK] \u26A0\uFE0F Excepci\xF3n parseando cache para: ${key}:`,
-            parseError
-          );
-          this.clearCorruptedCache(key).catch(
-            (err) => console.warn(`[PakentoSDK] Error limpiando cache corrupto: ${err}`)
-          );
-        }
+      cached = await this.redis.get(key);
+      if (typeof cached === "object" && cached !== null) {
+        console.log("[Cache] \u2705 Reading from cache:", key);
+        return cached;
+      }
+      if (cached) {
+        console.log("[Cache] \u2705 Reading from cache:", key);
+        return JSON.parse(cached);
       }
     } catch (err) {
-      console.warn("[PakentoSDK] Error leyendo cache Redis", err);
+      console.warn("[Cache] \u274C Error reading from cache:", err);
+      console.log(`[Cache] \u274C Key: ${key}, type: ${typeof cached}`);
     }
     const result = await fetcher();
     try {
-      const serializedData = this.serializeForCache(result);
-      await this.redis.set(key, serializedData, {
-        ex: ttl ?? this.defaultTTL
+      console.log("[Cache] \u2705 Writing to cache:", key);
+      await this.redis.set(key, JSON.stringify(result), {
+        ex: this.defaultTTL
       });
-      console.log(
-        "[PakentoSDK] Cache no encontrado, se guarda y se devuelve uno nuevo"
-      );
     } catch (err) {
-      console.warn("[PakentoSDK] Error escribiendo cache Redis", err);
-      console.warn("[PakentoSDK] Detalles del error:", {
-        error: err,
-        key,
-        resultType: typeof result,
-        resultSize: JSON.stringify(result).length
-      });
+      console.warn("[Cache] \u274C Error writing to cache:", err);
     }
     return result;
   }
-  async hasCache(functionName, params = {}) {
-    if (!this.redis) {
-      console.warn("[PakentoSDK] Redis no configurado");
-      return false;
-    }
-    try {
-      const key = this.buildCacheKey(functionName, params);
-      const cached = await this.redis.get(key);
-      if (cached === null || cached === void 0) {
-        return false;
-      }
-      const parsed = this.safeJsonParse(cached);
-      return parsed !== null;
-    } catch (err) {
-      console.warn("[PakentoSDK] Error verificando cache", err);
-      return false;
-    }
-  }
-  /**
-   * Limpia un cache específico si está corrupto
-   */
-  async clearCorruptedCache(key) {
-    if (!this.redis) {
-      return false;
-    }
-    try {
-      await this.redis.del(key);
-      return true;
-    } catch (err) {
-      console.warn("[PakentoSDK] Error limpiando cache corrupto", err);
-      return false;
-    }
-  }
-  getCacheKey(functionName, params = {}) {
-    return this.buildCacheKey(functionName, params);
-  }
-  async clearCache(functionName, params = {}) {
-    if (!this.redis) {
-      console.warn("[PakentoSDK] Redis no configurado");
-      return false;
-    }
-    try {
-      const key = this.buildCacheKey(functionName, params);
-      await this.redis.del(key);
-      return true;
-    } catch (err) {
-      console.warn("[PakentoSDK] Error limpiando cache", err);
-      return false;
-    }
-  }
-  async clearAllCache() {
-    if (!this.redis) {
-      console.warn("[PakentoSDK] Redis no configurado");
-      return false;
-    }
-    try {
-      const pattern = `pakento:${this.apiKeyHash}:*`;
-      const keys = await this.redis.keys(pattern);
-      if (keys.length > 0) {
-        await this.redis.del(...keys);
-      }
-      return true;
-    } catch (err) {
-      console.warn("[PakentoSDK] Error limpiando todo el cache", err);
-      return false;
-    }
-  }
-  async getCacheInfo(functionName, params = {}) {
-    if (!this.redis) {
-      console.warn("[PakentoSDK] Redis no configurado");
-      return {
-        exists: false,
-        key: this.buildCacheKey(functionName, params)
-      };
-    }
-    try {
-      const key = this.buildCacheKey(functionName, params);
-      const exists = await this.redis.exists(key);
-      const ttl = exists ? await this.redis.ttl(key) : void 0;
-      return {
-        exists: exists === 1,
-        key,
-        ttl: ttl === -1 ? void 0 : ttl
-      };
-    } catch (err) {
-      console.warn("[PakentoSDK] Error obteniendo info del cache", err);
-      return {
-        exists: false,
-        key: this.buildCacheKey(functionName, params)
-      };
-    }
-  }
 };
 
-// src/services/api.ts
-var import_zod = require("zod");
-
-// src/utils/itemParser.ts
-function parseRawItemToItem(rawItem) {
-  const firstPrice = rawItem.item_prices.docs[0];
-  const images = rawItem.images.map((img) => ({
-    url: img.url,
-    thumbnail_url: img.thumbnailURL
-  }));
-  const coverImageUrl = rawItem.coverImage?.url || rawItem.images[0]?.url || "";
-  const coverImageThumbnailUrl = rawItem.coverImage?.thumbnailURL || rawItem.images[0]?.thumbnailURL || "";
-  return {
-    id: rawItem.id,
-    name: rawItem.name,
-    featured: rawItem.featured,
-    url_safe_name: rawItem.url_safe_name,
-    currency_prefix: "$",
-    // Default currency prefix, could be made configurable
-    description: rawItem.description,
-    old_price: firstPrice?.old_price || 0,
-    item_category_name: rawItem.item_category?.name || "",
-    item_category_id: parseInt(rawItem.item_category?.id || "0"),
-    price_text: firstPrice?.price_text || "",
-    price_notes: firstPrice?.price_notes || "",
-    // Not available in raw response
-    price: firstPrice?.amount || 0,
-    brand_id: parseInt(rawItem.brand?.id || "0"),
-    brand_name: rawItem.brand?.name || "",
-    cover_image_url: coverImageUrl,
-    cover_image_thumbnail_url: coverImageThumbnailUrl,
-    images
-  };
-}
-function parseRawItemsToItems(rawItems) {
-  return rawItems.map(parseRawItemToItem);
-}
-
-// src/services/api.ts
-var PakentoCMSAPI = class {
-  constructor(config) {
-    this.defaultTTL = 86400;
+// src/api/core/apiClient.ts
+var ApiClient = class {
+  constructor() {
     this.baseURL = process.env.PAKENTO_CMS_BASE_URL || "";
     this.apiKey = process.env.PAKENTO_API_KEY || "";
-    if (config?.cacheTTL && typeof config.cacheTTL === "number") {
-      this.defaultTTL = config.cacheTTL;
-    }
-    this.cache = new CacheService(this.defaultTTL, this.apiKey);
+    this.cache = new CacheService(this.apiKey);
     this.client = import_axios.default.create({
       baseURL: this.baseURL,
       headers: {
@@ -329,17 +114,14 @@ var PakentoCMSAPI = class {
       }
     });
     this.client.interceptors.request.use(
-      (config2) => {
-        const fullUrl = `${config2.baseURL}${config2.url}`;
-        console.log(`\u{1F310} API Call: ${config2.method?.toUpperCase()} ${fullUrl}`);
-        return config2;
+      (config) => {
+        const fullUrl = `${config.baseURL}${config.url}`;
+        console.log(`\u{1F310} API Call: ${config.method?.toUpperCase()} ${fullUrl}`);
+        return config;
       },
-      (error) => {
-        return Promise.reject(error);
-      }
+      (error) => Promise.reject(error)
     );
   }
-  // Centralized error handler
   handleApiError(error, context) {
     if (error instanceof import_axios.AxiosError) {
       const status = error.response?.status;
@@ -355,7 +137,6 @@ var PakentoCMSAPI = class {
     }
     return "Error desconocido";
   }
-  // Generic GraphQL fetcher
   async fetchGraphQL(query, variables, extractData) {
     try {
       const response = await this.client.post("/api/graphql", {
@@ -373,25 +154,64 @@ var PakentoCMSAPI = class {
       return { data: null, error: true, errorMessage };
     }
   }
+};
+
+// src/api/items/parsers.ts
+function parseRawItemToItem(rawItem) {
+  const firstPrice = rawItem.item_prices.docs[0];
+  const images = rawItem.images.map((img) => ({
+    url: img.url,
+    thumbnail_url: img.thumbnailURL
+  }));
+  const coverImageUrl = rawItem.coverImage?.url || rawItem.images[0]?.url || "";
+  const coverImageThumbnailUrl = rawItem.coverImage?.thumbnailURL || rawItem.images[0]?.thumbnailURL || "";
+  return {
+    id: rawItem.id,
+    name: rawItem.name,
+    featured: rawItem.featured,
+    url_safe_name: rawItem.url_safe_name,
+    currency_prefix: "$",
+    // Default currency prefix, could be made configurable
+    description: rawItem.description,
+    old_price: firstPrice?.old_price || 0,
+    item_category_name: rawItem.item_category?.name || "",
+    item_category_id: parseInt(rawItem.item_category?.id || "0"),
+    price_text: firstPrice?.price_text || "",
+    price_notes: firstPrice?.price_notes || "",
+    price: firstPrice?.amount || 0,
+    brand_id: parseInt(rawItem.brand?.id || "0"),
+    brand_name: rawItem.brand?.name || "",
+    cover_image_url: coverImageUrl,
+    cover_image_thumbnail_url: coverImageThumbnailUrl,
+    images
+  };
+}
+function parseRawItemsToItems(rawItems) {
+  return rawItems.map(parseRawItemToItem);
+}
+
+// src/api/items/validators.ts
+var import_zod2 = require("zod");
+var itemsParamsSchema = import_zod2.z.object({
+  where: import_zod2.z.object({
+    item_category_id: import_zod2.z.object({ equals: import_zod2.z.string().optional() }).optional(),
+    item_super_category_id: import_zod2.z.object({ equals: import_zod2.z.string().optional() }).optional(),
+    brand_id: import_zod2.z.object({ equals: import_zod2.z.string().optional() }).optional(),
+    id: import_zod2.z.object({ equals: import_zod2.z.string().optional() }).optional()
+  }).optional(),
+  onlyOffers: import_zod2.z.boolean().optional(),
+  limit: import_zod2.z.coerce.number().optional(),
+  page: import_zod2.z.coerce.number().optional(),
+  search: import_zod2.z.string().optional(),
+  sort: import_zod2.z.string().optional(),
+  minPrice: import_zod2.z.coerce.number().optional(),
+  maxPrice: import_zod2.z.coerce.number().optional()
+});
+
+// src/api/items/api.ts
+var ItemsApi = class extends ApiClient {
   async getItems(params = {}) {
-    const itemsSchema = import_zod.z.object({
-      where: import_zod.z.object({
-        item_category_id: import_zod.z.object({ equals: import_zod.z.string().optional() }).optional(),
-        item_super_category_id: import_zod.z.object({ equals: import_zod.z.string().optional() }).optional(),
-        brand_id: import_zod.z.object({ equals: import_zod.z.string().optional() }).optional(),
-        id: import_zod.z.object({ equals: import_zod.z.string().optional() }).optional()
-      }).optional(),
-      onlyOffers: import_zod.z.boolean().optional(),
-      limit: import_zod.z.coerce.number().optional(),
-      page: import_zod.z.coerce.number().optional(),
-      search: import_zod.z.string().optional(),
-      sort: import_zod.z.string().optional(),
-      minPrice: import_zod.z.coerce.number().optional(),
-      maxPrice: import_zod.z.coerce.number().optional(),
-      skipCache: import_zod.z.boolean().optional(),
-      cacheTTL: import_zod.z.number().optional()
-    });
-    const validatedParams = itemsSchema.safeParse(params);
+    const validatedParams = itemsParamsSchema.safeParse(params);
     if (!validatedParams.success) {
       const errorMessage = this.handleApiError(
         validatedParams.error,
@@ -407,25 +227,16 @@ var PakentoCMSAPI = class {
         errorMessage
       };
     }
-    const { skipCache = false, cacheTTL, ...rest } = validatedParams.data;
-    const cacheKey = this.cache.buildCacheKey("GetEcommerceItems", rest);
-    const finalData = await this.cache.getCachedOrFetch(
+    const cacheKey = this.cache.buildCacheKey(
+      "GetEcommerceItems",
+      validatedParams.data
+    );
+    return this.cache.cacheWrap(
       cacheKey,
-      () => this.fetchItemsFromAPI(rest),
-      cacheTTL,
-      skipCache
+      () => this.fetchItemsFromAPI(validatedParams.data)
     );
-    return {
-      data: finalData.data,
-      totalDocs: finalData.totalDocs,
-      totalPages: finalData.totalPages,
-      prevPage: finalData.prevPage,
-      nextPage: finalData.nextPage,
-      error: false,
-      errorMessage: null
-    };
   }
-  async fetchItemsFromAPI(params = {}) {
+  async fetchItemsFromAPI(params) {
     if (!this.baseURL || !this.apiKey) {
       return {
         data: null,
@@ -543,21 +354,42 @@ var PakentoCMSAPI = class {
       errorMessage: null
     };
   }
+};
+var itemsApi = new ItemsApi();
+
+// src/api/categories/validators.ts
+var import_zod3 = require("zod");
+var categoriesParamsSchema = import_zod3.z.object({
+  where: import_zod3.z.object({
+    item_super_category_id: import_zod3.z.object({ equals: import_zod3.z.string().optional() }).optional(),
+    brand_id: import_zod3.z.object({ equals: import_zod3.z.string().optional() }).optional()
+  }).optional(),
+  limit: import_zod3.z.coerce.number().optional(),
+  page: import_zod3.z.coerce.number().optional(),
+  sort: import_zod3.z.string().optional()
+});
+
+// src/api/categories/api.ts
+var CategoriesApi = class extends ApiClient {
   async getCategories(params = {}) {
-    const {
-      skipCache = false,
-      cacheTTL,
-      ...rest
-    } = params;
-    const cacheKey = this.cache.buildCacheKey("GetEcommerceCategories", rest);
-    return this.cache.getCachedOrFetch(
+    const validatedParams = categoriesParamsSchema.safeParse(params);
+    if (!validatedParams.success) {
+      const errorMessage = this.handleApiError(
+        validatedParams.error,
+        "getCategories validation"
+      );
+      return { data: null, categories: [], error: true, errorMessage };
+    }
+    const cacheKey = this.cache.buildCacheKey(
+      "GetEcommerceCategories",
+      validatedParams.data
+    );
+    return this.cache.cacheWrap(
       cacheKey,
-      () => this.fetchCategoriesFromAPI(rest),
-      cacheTTL,
-      skipCache
+      () => this.fetchCategoriesFromAPI(validatedParams.data)
     );
   }
-  async fetchCategoriesFromAPI(params = {}) {
+  async fetchCategoriesFromAPI(params) {
     if (!this.baseURL || !this.apiKey) {
       return {
         data: null,
@@ -593,12 +425,7 @@ var PakentoCMSAPI = class {
       (responseData) => responseData.GetEcommerceCategories
     );
     if (error) {
-      return {
-        data: null,
-        categories: [],
-        error: true,
-        errorMessage
-      };
+      return { data: null, categories: [], error: true, errorMessage };
     }
     return {
       data: data.docs,
@@ -607,17 +434,53 @@ var PakentoCMSAPI = class {
       errorMessage: null
     };
   }
+};
+var categoriesApi = new CategoriesApi();
+
+// src/api/brands/validators.ts
+var import_zod4 = require("zod");
+var brandsParamsSchema = import_zod4.z.object({
+  limit: import_zod4.z.coerce.number().optional(),
+  page: import_zod4.z.coerce.number().optional(),
+  sort: import_zod4.z.string().optional()
+});
+
+// src/api/brands/api.ts
+var BrandsApi = class extends ApiClient {
   async getBrands(params = {}) {
-    const { skipCache = false, cacheTTL, ...rest } = params;
-    const cacheKey = this.cache.buildCacheKey("GetEcommerceBrands", rest);
-    return this.cache.getCachedOrFetch(
+    const validatedParams = brandsParamsSchema.safeParse(params);
+    if (!validatedParams.success) {
+      const errorMessage = this.handleApiError(
+        validatedParams.error,
+        "getBrands validation"
+      );
+      return {
+        data: null,
+        brands: [],
+        hasNextPage: false,
+        hasPrevPage: false,
+        limit: 0,
+        nextPage: 0,
+        offset: 0,
+        page: 0,
+        pagingCounter: 0,
+        prevPage: 0,
+        totalDocs: 0,
+        totalPages: 0,
+        error: true,
+        errorMessage
+      };
+    }
+    const cacheKey = this.cache.buildCacheKey(
+      "GetEcommerceBrands",
+      validatedParams.data
+    );
+    return this.cache.cacheWrap(
       cacheKey,
-      () => this.fetchBrandsFromAPI(rest),
-      cacheTTL,
-      skipCache
+      () => this.fetchBrandsFromAPI(validatedParams.data)
     );
   }
-  async fetchBrandsFromAPI(params = {}) {
+  async fetchBrandsFromAPI(params) {
     if (!this.baseURL || !this.apiKey) {
       return {
         data: null,
@@ -709,17 +572,19 @@ var PakentoCMSAPI = class {
       errorMessage: null
     };
   }
+};
+var brandsApi = new BrandsApi();
+
+// src/api/entity/api.ts
+var EntityApi = class extends ApiClient {
   async getEntity(params = {}) {
-    const { skipCache = false, cacheTTL, ...rest } = params;
-    const cacheKey = this.cache.buildCacheKey("GetEntity", rest);
-    return this.cache.getCachedOrFetch(
+    const cacheKey = this.cache.buildCacheKey("GetEntity", params);
+    return this.cache.cacheWrap(
       cacheKey,
-      () => this.fetchEntityFromAPI(rest),
-      cacheTTL,
-      skipCache
+      () => this.fetchEntityFromAPI(params)
     );
   }
-  async fetchEntityFromAPI(params = {}) {
+  async fetchEntityFromAPI(params) {
     if (!this.baseURL || !this.apiKey) {
       return {
         data: null,
@@ -769,23 +634,39 @@ var PakentoCMSAPI = class {
     const { data, error, errorMessage } = await this.fetchGraphQL(
       query,
       params,
-      (responseData) => responseData.GetEntity
+      (responseData) => responseData
     );
     if (error) {
-      return {
-        data: null,
-        entity: null,
-        error: true,
-        errorMessage
-      };
+      return { data: null, entity: null, error: true, errorMessage };
     }
     return {
-      data,
-      entity: data,
+      data: data.GetEntity,
+      entity: data.GetEntity,
       error: false,
       errorMessage: null
     };
   }
+};
+var entityApi = new EntityApi();
+
+// src/api/orders/validators.ts
+var import_zod5 = require("zod");
+var orderSchema = import_zod5.z.object({
+  name: import_zod5.z.string().min(1),
+  email: import_zod5.z.string().email(),
+  phone: import_zod5.z.string().optional(),
+  notes: import_zod5.z.string().optional(),
+  tin: import_zod5.z.string().optional(),
+  items: import_zod5.z.array(
+    import_zod5.z.object({ id: import_zod5.z.number().positive(), quantity: import_zod5.z.number().positive() })
+  ).min(1),
+  delivery_address: import_zod5.z.string().optional(),
+  delivery_instructions: import_zod5.z.string().optional(),
+  payment_method: import_zod5.z.enum(["cash", "transfer"]).optional()
+});
+
+// src/api/orders/api.ts
+var OrdersApi = class extends ApiClient {
   async createEcommerceOrder(params) {
     if (!this.baseURL || !this.apiKey) {
       return {
@@ -794,22 +675,6 @@ var PakentoCMSAPI = class {
         errorMessage: "SDK no configurado"
       };
     }
-    const orderSchema = import_zod.z.object({
-      name: import_zod.z.string().min(1),
-      email: import_zod.z.string().email(),
-      phone: import_zod.z.string().optional(),
-      notes: import_zod.z.string().optional(),
-      tin: import_zod.z.string().optional(),
-      items: import_zod.z.array(
-        import_zod.z.object({
-          id: import_zod.z.number().positive(),
-          quantity: import_zod.z.number().positive()
-        })
-      ).min(1),
-      delivery_address: import_zod.z.string().optional(),
-      delivery_instructions: import_zod.z.string().optional(),
-      payment_method: import_zod.z.enum(["cash", "transfer"]).optional()
-    });
     const validated = orderSchema.safeParse(params);
     if (!validated.success) {
       const errorMessage = this.handleApiError(
@@ -839,6 +704,62 @@ var PakentoCMSAPI = class {
       return { message: errorMessage, error: true, errorMessage };
     }
   }
+};
+var ordersApi = new OrdersApi();
+
+// src/api/contact/validators.ts
+var import_zod6 = require("zod");
+var contactUsSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1),
+  email: import_zod6.z.string().email(),
+  phone: import_zod6.z.string().optional(),
+  subject: import_zod6.z.string().optional(),
+  notes: import_zod6.z.string().min(1)
+});
+
+// src/api/contact/api.ts
+var ContactApi = class extends ApiClient {
+  async sendContactUsEmail(params) {
+    if (!this.baseURL || !this.apiKey) {
+      return {
+        message: "SDK no configurado",
+        error: true,
+        errorMessage: "SDK no configurado"
+      };
+    }
+    const validated = contactUsSchema.safeParse(params);
+    if (!validated.success) {
+      const errorMessage = this.handleApiError(
+        validated.error,
+        "sendContactUsEmail validation"
+      );
+      return { message: errorMessage, error: true, errorMessage };
+    }
+    try {
+      const response = await this.client.post(
+        "/api/entities/send-contact-us-email",
+        validated.data
+      );
+      if (response.status === 200) {
+        return {
+          message: response.data.message || "Mensaje enviado exitosamente",
+          error: false,
+          errorMessage: null
+        };
+      } else {
+        const errorMessage = response.data.message || "Error al enviar el mensaje";
+        return { message: errorMessage, error: true, errorMessage };
+      }
+    } catch (error) {
+      const errorMessage = this.handleApiError(error, "sendContactUsEmail");
+      return { message: errorMessage, error: true, errorMessage };
+    }
+  }
+};
+var contactApi = new ContactApi();
+
+// src/api/custom/api.ts
+var CustomApi = class extends ApiClient {
   async executeCustomQuery(params) {
     if (!this.baseURL || !this.apiKey) {
       return {
@@ -873,117 +794,21 @@ var PakentoCMSAPI = class {
         errorMessage: null
       };
     } catch (error) {
-      let errorMessage = "Error desconocido";
-      if (error instanceof import_axios.AxiosError) {
-        const status = error.response?.status;
-        if (status === 401) {
-          errorMessage = "API Key inv\xE1lida o expirada";
-        } else if (status === 404) {
-          errorMessage = "Endpoint GraphQL no encontrado";
-        } else if (status === 400) {
-          errorMessage = "Query GraphQL inv\xE1lido o malformado";
-        } else if (status && status >= 500) {
-          errorMessage = "Error del servidor CMS";
-        } else {
-          errorMessage = `Error de conexi\xF3n: ${error.message}`;
-        }
-      } else if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      return {
-        data: null,
-        error: true,
-        errorMessage
-      };
-    }
-  }
-  async sendContactUsEmail(params) {
-    if (!this.baseURL || !this.apiKey) {
-      return {
-        message: "SDK no configurado: PAKENTO_CMS_BASE_URL o PAKENTO_API_KEY faltantes.",
-        error: true,
-        errorMessage: "SDK no configurado: PAKENTO_CMS_BASE_URL o PAKENTO_API_KEY faltantes."
-      };
-    }
-    const contactUsSchema = import_zod.z.object({
-      name: import_zod.z.string().min(1),
-      email: import_zod.z.email(),
-      phone: import_zod.z.string().optional(),
-      subject: import_zod.z.string().optional(),
-      message: import_zod.z.string().min(1)
-    });
-    const validated = contactUsSchema.safeParse(params);
-    if (!validated.success) {
-      const errorMessage = this.handleApiError(
-        validated.error,
-        "sendContactUsEmail validation"
-      );
-      return { message: errorMessage, error: true, errorMessage };
-    }
-    try {
-      const response = await this.client.post(
-        "/api/entities/send-contact-us-email",
-        validated.data
-      );
-      if (response.status === 200) {
-        return {
-          message: response.data.message || "Mensaje enviado exitosamente",
-          error: false,
-          errorMessage: null
-        };
-      } else {
-        const errorMessage = response.data.message || "Error al enviar el mensaje";
-        return { message: errorMessage, error: true, errorMessage };
-      }
-    } catch (error) {
-      const errorMessage = this.handleApiError(error, "sendContactUsEmail");
-      return { message: errorMessage, error: true, errorMessage };
+      const errorMessage = this.handleApiError(error, "Custom GraphQL");
+      return { data: null, error: true, errorMessage };
     }
   }
-  /**
-   * Verifica si existe cache para una función y parámetros específicos
-   */
-  async hasCache(functionName, params = {}) {
-    return this.cache.hasCache(functionName, params);
-  }
-  /**
-   * Obtiene la key de cache para una función y parámetros específicos
-   */
-  getCacheKey(functionName, params = {}) {
-    return this.cache.getCacheKey(functionName, params);
-  }
-  /**
-   * Limpia el cache para una función y parámetros específicos
-   */
-  async clearCache(functionName, params = {}) {
-    return this.cache.clearCache(functionName, params);
-  }
-  /**
-   * Limpia todo el cache relacionado con este API Key
-   */
-  async clearAllCache() {
-    return this.cache.clearAllCache();
-  }
-  /**
-   * Obtiene información del cache (útil para debugging)
-   */
-  async getCacheInfo(functionName, params = {}) {
-    return this.cache.getCacheInfo(functionName, params);
-  }
-  /**
-   * Limpia un cache específico que pueda estar corrupto
-   */
-  async clearCorruptedCache(functionName, params = {}) {
-    const key = this.cache.getCacheKey(functionName, params);
-    return this.cache.clearCorruptedCache(key);
-  }
 };
-var pakentoCMSAPI = new PakentoCMSAPI();
+var customApi = new CustomApi();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CacheService,
-  pakentoCMSAPI,
-  parseRawItemToItem,
-  parseRawItemsToItems
+  ApiClient,
+  brandsApi,
+  categoriesApi,
+  contactApi,
+  customApi,
+  entityApi,
+  itemsApi,
+  ordersApi
 });
 //# sourceMappingURL=index.js.map