@hellena-sdk/hellena 1.0.6 → 1.0.7

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,231 @@ 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: { page: params.page, limit: params.limit } });
+  }
+  searchProducts(params) {
+    const { ref, ...pagination } = params;
+    return this.connect.sendRestRequest("products/search", { query: { ref, ...pagination } });
+  }
+  getProductById(id) {
+    return this.connect.sendRestRequest(`products/${encodeURIComponent(id)}`);
+  }
+}
+
+// src/resources/product/product.feature.ts
+class ProductFeature {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  listProducts(params = {}) {
+    return this.service.getAllProducts(params);
+  }
+  searchProducts(params) {
+    return this.service.searchProducts(params);
+  }
+  getProductByIdOrSlug(id) {
+    return this.service.getProductById(id);
+  }
+}
+
+// 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) {
+    return this.service.summary(stockId);
+  }
+  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) {
+    return this.connect.sendRestRequest(`ratings/products/${encodeURIComponent(stockId)}/summary`);
+  }
+  findOne(params) {
+    return this.connect.sendRestRequest(`ratings/products/${encodeURIComponent(params.stockId)}`, { query: { customerId: params.customerId } });
+  }
+  create(data) {
+    return this.connect.sendRestRequest("ratings", { method: "POST", body: data });
+  }
+  delete(id) {
+    return this.connect.sendRestRequest(`ratings/${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/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);
+  constructor(apiKey, options = {}) {
+    super(apiKey, options);
   }
 }
 export {
+  HellenaAPIError,
   HellenaClient
 };

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;
+    }>;
+}

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

@@ -1,71 +1,76 @@
-export interface OrderDTO {
-    customerName?: string;
-    customerEmail?: string;
+export interface DashboardOrderInfoDTO {
     customerId?: string;
     customerProfile?: string;
+    customerName?: string;
+    customerEmail?: string;
+    customerPhone?: string;
+    customerNIF?: string;
     notes?: string;
     lat?: number;
     lng?: number;
-    origin?: string;
-    shippingMethod?: string;
-    paymentMethod?: string;
-    cupon?: string;
-    meta?: Record<string, any>;
     address?: string;
-    items: Order_ItemsDTO[];
 }
-interface Order_ItemsDTO {
+export interface DashboardOrderItemDTO {
     productId: string;
+    name: string;
+    category?: string;
+    image?: string;
     quantity: number;
+    size?: string;
+    color?: string;
+    material?: string;
+    model?: string;
+    gender?: string;
     price: number;
-    image?: string;
-    category?: string;
-    name?: string;
+}
+export interface OrderDTO {
+    info?: DashboardOrderInfoDTO;
+    items: DashboardOrderItemDTO[];
+    coupon?: string;
+    frete?: number;
+    localization?: string;
 }
 export interface Order_Return {
     id: string;
+    invoice?: string | null;
+    invoice_link?: string | null;
     organizationId: string;
-    createdAt: string;
-    updatedAt: any;
-    origin: string;
-    status: string;
     amount: number;
-    deletedAt: any;
-    deliveryDate: any;
-    dueDate: any;
-    trackingCode: any;
-    shippingMethod: any;
-    paymentMethod: any;
-    cupon: any;
-    meta: any;
-    orderInfo: OrderInfo;
-    items: Item[];
+    couponCode?: string | null;
+    couponDiscount?: number | null;
+    frete?: number | null;
+    status: string;
+    transactionId?: string;
+    [key: string]: unknown;
 }
-export interface OrderInfo {
-    id: string;
-    orderId: string;
-    customerId: any;
-    customerProfile: any;
-    customerName: string;
-    customerEmail: string;
-    notes: any;
-    lat: string;
-    lng: string;
-    address: string;
-    createdAt: string;
-    updatedAt: any;
+export interface GetFreteDTO {
+    localization?: string;
+    lat?: number;
+    long?: number;
+    coupon?: string;
+    items?: DashboardOrderItemDTO[];
 }
-export interface Item {
-    id: string;
-    orderId: string;
-    productId: string;
-    image: string;
-    category: string;
-    name: string;
-    quantity: number;
+export interface CouponDiscountDTO {
+    code: string;
+    items: DashboardOrderItemDTO[];
+    customerId?: string;
+    customerEmail?: string;
+    fretePrice?: number;
+}
+export interface FreteResponseDTO {
+    required: boolean;
     price: number;
-    createdAt: string;
-    updatedAt: any;
+    isFreeShipping: boolean;
+    message?: string;
+}
+export interface CouponDiscountResponseDTO {
+    valid: boolean;
+    message?: string;
+    code?: string;
+    discountType?: string;
+    discountValue?: number;
+    discountAmount?: number;
+    isFreeShipping?: boolean;
+    subtotal?: number;
+    finalAmount?: number;
 }
-export {};
-//# sourceMappingURL=order.dto.d.ts.map

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

@@ -1,8 +1,17 @@
-import type { Order_Return, OrderDTO } from "./dto/order.dto";
+import type { CouponDiscountDTO, CouponDiscountResponseDTO, GetFreteDTO, FreteResponseDTO, OrderDTO, Order_Return } from "./dto/order.dto";
 import type { OrderService } from "./service/order.ser";
 export declare class OrderFeature {
     private readonly service;
     constructor(service: OrderService);
-    new(data: OrderDTO): Promise<Order_Return>;
+    /** Cria uma encomenda através do serviço central de checkout Hellena. */
+    createOrder(data: OrderDTO): Promise<Order_Return>;
+    /** Renova o identificador de transação de uma encomenda existente. */
+    renewOrderTransactionId(id: string): Promise<{
+        id: string;
+        transactionId: string;
+    }>;
+    /** Calcula o custo de entrega para os artigos e a localização indicados. */
+    calculateShippingCost(data: GetFreteDTO): Promise<FreteResponseDTO>;
+    /** Calcula o desconto aplicável a um cupão e aos artigos indicados. */
+    calculateCouponDiscount(data: CouponDiscountDTO): Promise<CouponDiscountResponseDTO>;
 }
-//# sourceMappingURL=order.feature.d.ts.map

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

@@ -1,4 +1,3 @@
-import type { HellenaConnect } from "@//core/HellenaConnect";
 import { OrderFeature } from "./order.feature";
+import type { HellenaConnect } from "@/core/HellenaConnect";
 export declare function OrderModel(connect: HellenaConnect): OrderFeature;
-//# sourceMappingURL=order.model.d.ts.map

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

@@ -1,10 +1,15 @@
-import type { HellenaConnect } from "@//core/HellenaConnect";
-import type { Order_Return, OrderDTO } from "../dto/order.dto";
+import type { HellenaConnect } from "../../../core/HellenaConnect";
+import type { CouponDiscountDTO, CouponDiscountResponseDTO, GetFreteDTO, FreteResponseDTO, OrderDTO, Order_Return } from "../dto/order.dto";
 export declare class OrderService {
     private readonly connect;
     constructor(connect: HellenaConnect);
     make({ data }: {
         data: OrderDTO;
     }): Promise<Order_Return>;
+    renewTransactionId(id: string): Promise<{
+        id: string;
+        transactionId: string;
+    }>;
+    getFrete(payload: GetFreteDTO): Promise<FreteResponseDTO>;
+    calculateCouponDiscount(payload: CouponDiscountDTO): Promise<CouponDiscountResponseDTO>;
 }
-//# sourceMappingURL=order.ser.d.ts.map

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

@@ -24,4 +24,3 @@ export interface OrganizationLinkDTO {
     name: string;
     link: string;
 }
-//# sourceMappingURL=organization.dto.d.ts.map

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

@@ -3,7 +3,8 @@ import { OrganizationService } from "./service/organization.ser";
 export declare class OrganizationFeature {
     private readonly service;
     constructor(service: OrganizationService);
-    info(): Promise<OrganizationInfoResponseDTO>;
-    socialLinks(): Promise<OrganizationLinkDTO[]>;
+    /** Obtém as informações públicas da organização associada à API Key. */
+    getOrganizationInfo(): Promise<OrganizationInfoResponseDTO>;
+    /** Obtém os links sociais configurados pela organização. */
+    getOrganizationSocialLinks(): Promise<OrganizationLinkDTO[]>;
 }
-//# sourceMappingURL=organization.feature.d.ts.map