@hellena-sdk/hellena 1.0.6 → 1.0.8

package/dist/main.js

@@ -1,22 +1,100 @@
 // src/core/HellenaConnect.ts
+class HellenaAPIError extends Error {
+  status;
+  response;
+  path;
+  constructor(message, status, path, response) {
+    super(message);
+    this.name = "HellenaAPIError";
+    this.status = status;
+    this.path = path;
+    this.response = response;
+  }
+}
+
 class HellenaConnect {
   apiKey;
   apiUrl;
   apiVersion;
-  constructor(apiKey, apiUrl = "https://api.hellena.app", apiVersion = "v1") {
+  timeout;
+  constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
-    this.apiUrl = apiUrl;
-    this.apiVersion = apiVersion;
+    if (!apiKey?.trim()) {
+      throw new Error("A API Key da Hellena é obrigatória.");
+    }
+    this.apiUrl = (options.apiUrl ?? "https://api.hellena.app").replace(/\/+$/, "");
+    this.apiVersion = (options.apiVersion ?? "v1").replace(/^\/+|\/+$/g, "");
+    this.timeout = options.timeout ?? 30000;
   }
   get apiEndpoint() {
     return `${this.apiUrl}/${this.apiVersion}`;
   }
   getHeaders() {
     return {
+      Accept: "application/json",
       "Content-Type": "application/json",
       "x-hellena-api-key": this.apiKey
     };
   }
+  async sendRestRequest(path, options = {}) {
+    const normalizedPath = path.replace(/^\/+/, "");
+    const url = new URL(`${this.apiEndpoint}/${normalizedPath}`);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+      if (value !== undefined && value !== null)
+        url.searchParams.set(key, String(value));
+    }
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const externalSignal = options.signal;
+    const abortFromExternal = () => controller.abort();
+    externalSignal?.addEventListener("abort", abortFromExternal, { once: true });
+    try {
+      const response = await fetch(url, {
+        method: options.method ?? "GET",
+        headers: { ...this.getHeaders(), ...options.headers },
+        ...options.body !== undefined ? { body: JSON.stringify(options.body) } : {},
+        signal: externalSignal?.aborted ? externalSignal : controller.signal
+      });
+      const raw = await response.text();
+      let data = undefined;
+      if (raw) {
+        try {
+          data = JSON.parse(raw);
+        } catch {
+          data = raw;
+        }
+      }
+      if (!response.ok) {
+        const payload = data;
+        const message = Array.isArray(payload?.message) ? payload.message.join(", ") : typeof payload?.message === "string" ? payload.message : typeof payload?.error === "string" ? payload.error : `Pedido à Hellena falhou (${response.status} ${response.statusText})`;
+        throw new HellenaAPIError(message, response.status, url.toString(), data);
+      }
+      return data;
+    } catch (error) {
+      if (error instanceof HellenaAPIError)
+        throw error;
+      if (controller.signal.aborted) {
+        throw new Error(`O pedido à Hellena excedeu o limite de ${this.timeout} ms ou foi cancelado.`, { cause: error });
+      }
+      throw new Error(`Não foi possível comunicar com a API Hellena: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    } finally {
+      clearTimeout(timeoutId);
+      externalSignal?.removeEventListener("abort", abortFromExternal);
+    }
+  }
+  async graphql(query, variables) {
+    const response = await fetch(`${this.apiUrl}/graphql`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({ query, variables })
+    });
+    const payload = await response.json();
+    if (!response.ok || payload.errors?.length) {
+      const message = payload.errors?.map((item) => item.message ?? "Erro GraphQL").join("; ") ?? `Pedido GraphQL falhou (${response.status})`;
+      throw new HellenaAPIError(message, response.status, `${this.apiUrl}/graphql`, payload);
+    }
+    return payload.data;
+  }
 }
 
 // src/resources/order/service/order.ser.ts
@@ -25,20 +103,20 @@ class OrderService {
   constructor(connect) {
     this.connect = connect;
   }
-  async make({ data }) {
-    const response = await fetch(`${this.connect["apiEndpoint"]}/orders`, {
+  make({ data }) {
+    return this.connect.sendRestRequest("orders/new", {
       method: "POST",
-      headers: this.connect["getHeaders"](),
-      body: JSON.stringify(data)
+      body: data
     });
-    if (!response.ok) {
-      throw {
-        cause: `Erro ao cadastrar compra (${response.status})`,
-        status: response.status,
-        message: response.statusText
-      };
-    }
-    return response.json();
+  }
+  renewTransactionId(id) {
+    return this.connect.sendRestRequest(`orders/${encodeURIComponent(id)}/renew-transaction`, { method: "POST" });
+  }
+  getFrete(payload) {
+    return this.connect.sendRestRequest("orders/checkout/frete", { method: "POST", body: payload });
+  }
+  calculateCouponDiscount(payload) {
+    return this.connect.sendRestRequest("orders/checkout/coupon-discount", { method: "POST", body: payload });
   }
 }
 
@@ -48,9 +126,17 @@ class OrderFeature {
   constructor(service) {
     this.service = service;
   }
-  async new(data) {
-    const order = await this.service.make({ data });
-    return order;
+  createOrder(data) {
+    return this.service.make({ data });
+  }
+  renewOrderTransactionId(id) {
+    return this.service.renewTransactionId(id);
+  }
+  calculateShippingCost(data) {
+    return this.service.getFrete(data);
+  }
+  calculateCouponDiscount(data) {
+    return this.service.calculateCouponDiscount(data);
   }
 }
 
@@ -66,58 +152,318 @@ class ProductService {
   constructor(connect) {
     this.connect = connect;
   }
-  async getAllProducts() {
-    const response = await fetch(`${this.connect["apiEndpoint"]}/products/all`, {
+  getAllProducts(params = {}) {
+    return this.connect.sendRestRequest("products/all", { query: this.toQuery(params) });
+  }
+  searchProducts(params) {
+    const { ref, ...filters } = params;
+    return this.connect.sendRestRequest("products/search", {
+      query: { ...this.toQuery(filters), ...ref ? { ref } : {} }
+    });
+  }
+  getProductById(id) {
+    return this.connect.sendRestRequest(`products/${encodeURIComponent(id)}`);
+  }
+  toQuery(params) {
+    const list = (value) => Array.isArray(value) ? value.join(",") : value;
+    return {
+      page: params.page,
+      limit: params.limit,
+      q: params.q,
+      category: params.category,
+      color: list(params.color),
+      brand: params.brand,
+      model: list(params.model),
+      material: list(params.material),
+      size: list(params.size),
+      tags: list(params.tags),
+      gender: list(params.gender),
+      minPrice: params.minPrice,
+      maxPrice: params.maxPrice,
+      inStock: params.inStock,
+      sortBy: params.sortBy,
+      sortOrder: params.sortOrder
+    };
+  }
+}
+
+// src/resources/product/product.feature.ts
+class ProductFeature {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  listProducts(params = {}) {
+    this.validatePriceRange(params);
+    return this.service.getAllProducts(params);
+  }
+  filterProducts(filters = {}) {
+    return this.listProducts(filters);
+  }
+  searchProducts(params = {}) {
+    this.validatePriceRange(params);
+    return this.service.searchProducts(params);
+  }
+  getProductByIdOrSlug(id) {
+    if (!id?.trim()) {
+      throw new Error("O ID ou slug do produto é obrigatório.");
+    }
+    return this.service.getProductById(id.trim());
+  }
+  validatePriceRange(params) {
+    const { minPrice, maxPrice } = params;
+    if (minPrice !== undefined && (!Number.isFinite(minPrice) || minPrice < 0)) {
+      throw new Error("minPrice deve ser um número maior ou igual a zero.");
+    }
+    if (maxPrice !== undefined && (!Number.isFinite(maxPrice) || maxPrice < 0)) {
+      throw new Error("maxPrice deve ser um número maior ou igual a zero.");
+    }
+    if (minPrice !== undefined && maxPrice !== undefined && minPrice > maxPrice) {
+      throw new Error("minPrice não pode ser superior a maxPrice.");
+    }
+  }
+}
+
+// src/resources/product/product.model.ts
+function ProductModel(connect) {
+  const service = new ProductService(connect);
+  return new ProductFeature(service);
+}
+
+// src/resources/organization/service/organization.ser.ts
+class OrganizationService {
+  connect;
+  constructor(connect) {
+    this.connect = connect;
+  }
+  async getInfo() {
+    const response = await fetch(`${this.connect["apiEndpoint"]}/organization/info`, {
       method: "GET",
       headers: this.connect["getHeaders"]()
     });
     if (!response.ok) {
-      throw new Error(`Erro ao buscar produtos (${response.status})`);
+      throw new Error(`Erro ao buscar informações da organização (${response.status})`);
     }
     return response.json();
   }
-  async getProductById(id) {
-    const response = await fetch(`${this.connect["apiEndpoint"]}/products/${id}`, {
+  async getLinks() {
+    const response = await fetch(`${this.connect["apiEndpoint"]}/organization/links`, {
       method: "GET",
       headers: this.connect["getHeaders"]()
     });
     if (!response.ok) {
-      throw new Error(`Erro ao buscar produto (${response.status})`);
+      throw new Error(`Erro ao buscar links da organização (${response.status})`);
     }
     return response.json();
   }
 }
 
-// src/resources/product/product.feature.ts
-class ProductFeature {
+// src/resources/organization/organization.feature.ts
+class OrganizationFeature {
   service;
   constructor(service) {
     this.service = service;
   }
-  async findMany() {
-    const products = await this.service.getAllProducts();
-    return products;
+  getOrganizationInfo() {
+    return this.service.getInfo();
   }
-  async findOne({ id }) {
-    const product = await this.service.getProductById(id);
-    return product;
+  getOrganizationSocialLinks() {
+    return this.service.getLinks();
   }
 }
 
-// src/resources/product/product.model.ts
-function ProductModel(connect) {
-  const service = new ProductService(connect);
-  return new ProductFeature(service);
+// src/resources/organization/organization.model.ts
+function OrganizationModel(connect) {
+  const service = new OrganizationService(connect);
+  return new OrganizationFeature(service);
+}
+
+// src/resources/comment/comment.feature.ts
+class CommentFeature {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  listProductComments(params) {
+    return this.service.findMany(params);
+  }
+  getCommentById(id) {
+    return this.service.findOne(id);
+  }
+  createComment(data) {
+    return this.service.create(data);
+  }
+  updateComment(id, data) {
+    return this.service.update(id, data);
+  }
+  deleteComment(id) {
+    return this.service.delete(id);
+  }
+}
+
+// src/resources/comment/service/comment.ser.ts
+class CommentService {
+  connect;
+  constructor(connect) {
+    this.connect = connect;
+  }
+  findMany(params) {
+    return this.connect.sendRestRequest("comments", { query: params });
+  }
+  findOne(id) {
+    return this.connect.sendRestRequest(`comments/${encodeURIComponent(id)}`);
+  }
+  create(data) {
+    return this.connect.sendRestRequest("comments", { method: "POST", body: data });
+  }
+  update(id, data) {
+    return this.connect.sendRestRequest(`comments/${encodeURIComponent(id)}`, { method: "PATCH", body: data });
+  }
+  delete(id) {
+    return this.connect.sendRestRequest(`comments/${encodeURIComponent(id)}`, { method: "DELETE" });
+  }
+}
+
+// src/resources/comment/comment.model.ts
+function CommentModel(connect) {
+  return new CommentFeature(new CommentService(connect));
+}
+
+// src/resources/rating/rating.feature.ts
+class RatingFeature {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  getProductRatingSummary(stockId, params = {}) {
+    return this.service.summary(stockId, params);
+  }
+  listProductRatings(params) {
+    return this.service.findMany(params);
+  }
+  getCustomerProductRating(params) {
+    return this.service.findOne(params);
+  }
+  createProductRating(data) {
+    return this.service.create(data);
+  }
+  deleteProductRating(id) {
+    return this.service.delete(id);
+  }
+}
+
+// src/resources/rating/service/rating.ser.ts
+class RatingService {
+  connect;
+  constructor(connect) {
+    this.connect = connect;
+  }
+  summary(stockId, params = {}) {
+    return this.connect.sendRestRequest(`rating/products/${encodeURIComponent(stockId)}/summary`, { query: params });
+  }
+  findMany(params) {
+    const { stockId, ...pagination } = params;
+    return this.connect.sendRestRequest(`rating/products/${encodeURIComponent(stockId)}/ratings`, { query: pagination });
+  }
+  findOne(params) {
+    return this.connect.sendRestRequest(`rating/products/${encodeURIComponent(params.stockId)}`, { query: { customerId: params.customerId } });
+  }
+  create(data) {
+    return this.connect.sendRestRequest("rating", { method: "POST", body: data });
+  }
+  delete(id) {
+    return this.connect.sendRestRequest(`rating/${encodeURIComponent(id)}`, { method: "DELETE" });
+  }
+}
+
+// src/resources/rating/rating.model.ts
+function RatingModel(connect) {
+  return new RatingFeature(new RatingService(connect));
+}
+
+// src/resources/payment/payment.feature.ts
+class PaymentFeature {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  listAvailablePaymentMethods() {
+    return this.service.methods();
+  }
+  createWiPayPayment(data) {
+    return this.service.createWiPayPayment(data);
+  }
+}
+
+// src/resources/payment/service/payment.ser.ts
+class PaymentService {
+  connect;
+  constructor(connect) {
+    this.connect = connect;
+  }
+  methods() {
+    return this.connect.sendRestRequest("payment/methods");
+  }
+  createWiPayPayment(data) {
+    return this.connect.sendRestRequest("payment/wipay/create", { method: "POST", body: data });
+  }
+}
+
+// src/resources/payment/payment.model.ts
+function PaymentModel(connect) {
+  return new PaymentFeature(new PaymentService(connect));
+}
+
+// src/resources/category/category.feature.ts
+class CategoryFeature {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  listCategories(params = {}) {
+    return this.service.findMany(params);
+  }
+  getCategoryByRef(params) {
+    return this.service.findOne(params);
+  }
+}
+
+// src/resources/category/service/category.ser.ts
+class CategoryService {
+  connect;
+  constructor(connect) {
+    this.connect = connect;
+  }
+  findMany(params = {}) {
+    return this.connect.sendRestRequest("category", {
+      query: { page: params.page, limit: params.limit, search: params.search }
+    });
+  }
+  findOne(params) {
+    const { ref, ...pagination } = params;
+    return this.connect.sendRestRequest(`category/${encodeURIComponent(ref)}`, { query: pagination });
+  }
+}
+
+// src/resources/category/category.model.ts
+function CategoryModel(connect) {
+  return new CategoryFeature(new CategoryService(connect));
 }
 
 // src/main.ts
 class HellenaClient extends HellenaConnect {
   product = ProductModel(this);
   order = OrderModel(this);
-  constructor(apiKey) {
-    super(apiKey);
+  organization = OrganizationModel(this);
+  comment = CommentModel(this);
+  rating = RatingModel(this);
+  payment = PaymentModel(this);
+  category = CategoryModel(this);
+  constructor(apiKey, options = {}) {
+    super(apiKey, options);
   }
 }
 export {
+  HellenaAPIError,
   HellenaClient
 };

package/dist/resources/category/category.feature.d.ts

@@ -0,0 +1,10 @@
+import type { CategoryListParams, CategoryProductsParams, CategoryWithProductsDTO, PaginatedCategoriesDTO } from "./dto/category.dto";
+import type { CategoryService } from "./service/category.ser";
+export declare class CategoryFeature {
+    private readonly service;
+    constructor(service: CategoryService);
+    /** Lista as categorias da organização com paginação e pesquisa opcional. */
+    listCategories(params?: CategoryListParams): Promise<PaginatedCategoriesDTO>;
+    /** Obtém uma categoria pelo ID ou identificador e os respetivos produtos paginados. */
+    getCategoryByRef(params: CategoryProductsParams): Promise<CategoryWithProductsDTO>;
+}

package/dist/resources/category/category.model.d.ts

@@ -0,0 +1,3 @@
+import type { HellenaConnect } from "../../core/HellenaConnect";
+import { CategoryFeature } from "./category.feature";
+export declare function CategoryModel(connect: HellenaConnect): CategoryFeature;

package/dist/resources/category/dto/category.dto.d.ts

@@ -0,0 +1,26 @@
+import type { PaginatedResponse, ProductDTO, PaginationMeta } from "../../product/dto/product.dto";
+export interface CategoryDTO {
+    id: string;
+    name: string;
+    category: string;
+    icon?: string | null;
+    image?: string | null;
+    organizationId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface CategoryListParams {
+    page?: number;
+    limit?: number;
+    search?: string;
+}
+export interface CategoryProductsParams {
+    ref: string;
+    page?: number;
+    limit?: number;
+}
+export interface CategoryWithProductsDTO extends CategoryDTO {
+    products: ProductDTO[];
+    meta: PaginationMeta;
+}
+export type PaginatedCategoriesDTO = PaginatedResponse<CategoryDTO>;

package/dist/resources/category/service/category.ser.d.ts

@@ -0,0 +1,8 @@
+import type { HellenaConnect } from "../../../core/HellenaConnect";
+import type { CategoryListParams, CategoryProductsParams, CategoryWithProductsDTO, PaginatedCategoriesDTO } from "../dto/category.dto";
+export declare class CategoryService {
+    private readonly connect;
+    constructor(connect: HellenaConnect);
+    findMany(params?: CategoryListParams): Promise<PaginatedCategoriesDTO>;
+    findOne(params: CategoryProductsParams): Promise<CategoryWithProductsDTO>;
+}

package/dist/resources/comment/comment.feature.d.ts

@@ -0,0 +1,22 @@
+import type { AddCommentDTO, CommentDTO, PaginatedCommentsDTO, UpdateCommentDTO } from "./dto/comment.dto";
+import type { CommentService } from "./service/comment.ser";
+export declare class CommentFeature {
+    private readonly service;
+    constructor(service: CommentService);
+    /** Lista os comentários de um produto. */
+    listProductComments(params: {
+        stockId: string;
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedCommentsDTO>;
+    /** Obtém um comentário pelo seu identificador. */
+    getCommentById(id: string): Promise<CommentDTO>;
+    /** Publica um comentário num produto. */
+    createComment(data: AddCommentDTO): Promise<CommentDTO>;
+    /** Atualiza o conteúdo ou as reações de um comentário. */
+    updateComment(id: string, data: UpdateCommentDTO): Promise<CommentDTO>;
+    /** Elimina um comentário pelo seu identificador. */
+    deleteComment(id: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/resources/comment/comment.model.d.ts

@@ -0,0 +1,3 @@
+import type { HellenaConnect } from "../../core/HellenaConnect";
+import { CommentFeature } from "./comment.feature";
+export declare function CommentModel(connect: HellenaConnect): CommentFeature;

package/dist/resources/comment/dto/comment.dto.d.ts

@@ -0,0 +1,31 @@
+import type { PaginatedResponse } from "../../product/dto/product.dto";
+export interface CommentDTO {
+    id: string;
+    stockId: string;
+    content: string;
+    customerId?: string | null;
+    customerProfile?: string | null;
+    customerName?: string | null;
+    customerEmail?: string | null;
+    parentId?: string | null;
+    reactions?: string | null;
+    replies?: CommentDTO[];
+    parent?: CommentDTO | null;
+    createdAt?: string;
+    updatedAt?: string | null;
+}
+export interface AddCommentDTO {
+    stockId: string;
+    content: string;
+    customerId?: string;
+    customerProfile?: string;
+    customerName?: string;
+    customerEmail?: string;
+    parentId?: string;
+    reactions?: string;
+}
+export interface UpdateCommentDTO {
+    content?: string;
+    reactions?: string;
+}
+export type PaginatedCommentsDTO = PaginatedResponse<CommentDTO>;

package/dist/resources/comment/service/comment.ser.d.ts

@@ -0,0 +1,17 @@
+import type { HellenaConnect } from "../../../core/HellenaConnect";
+import type { AddCommentDTO, CommentDTO, PaginatedCommentsDTO, UpdateCommentDTO } from "../dto/comment.dto";
+export declare class CommentService {
+    private readonly connect;
+    constructor(connect: HellenaConnect);
+    findMany(params: {
+        stockId: string;
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedCommentsDTO>;
+    findOne(id: string): Promise<CommentDTO>;
+    create(data: AddCommentDTO): Promise<CommentDTO>;
+    update(id: string, data: UpdateCommentDTO): Promise<CommentDTO>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+}