@hellena-sdk/hellena 1.0.5 → 1.0.7

package/dist/main.js

@@ -1,13 +1,382 @@
-import { HellenaConnect } from "./core/HellenaConnect.js";
-import { OrderModel } from "./resources/order/order.model.js";
-import { OrganizationModel } from "./resources/organization/organization.model.js";
-import { ProductModel } from "./resources/product/product.model.js";
-export class HellenaClient extends HellenaConnect {
-    constructor(apiKey) {
-        super(apiKey);
-        this.product = ProductModel(this);
-        this.order = OrderModel(this);
-        this.organization = OrganizationModel(this);
-    }
-}
-//# sourceMappingURL=main.js.map
+// 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;
+  timeout;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    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
+class OrderService {
+  connect;
+  constructor(connect) {
+    this.connect = connect;
+  }
+  make({ data }) {
+    return this.connect.sendRestRequest("orders/new", {
+      method: "POST",
+      body: data
+    });
+  }
+  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 });
+  }
+}
+
+// src/resources/order/order.feature.ts
+class OrderFeature {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  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);
+  }
+}
+
+// src/resources/order/order.model.ts
+function OrderModel(connect) {
+  const service = new OrderService(connect);
+  return new OrderFeature(service);
+}
+
+// src/resources/product/service/product.ser.ts
+class ProductService {
+  connect;
+  constructor(connect) {
+    this.connect = connect;
+  }
+  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 informações da organização (${response.status})`);
+    }
+    return response.json();
+  }
+  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 links da organização (${response.status})`);
+    }
+    return response.json();
+  }
+}
+
+// src/resources/organization/organization.feature.ts
+class OrganizationFeature {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  getOrganizationInfo() {
+    return this.service.getInfo();
+  }
+  getOrganizationSocialLinks() {
+    return this.service.getLinks();
+  }
+}
+
+// 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);
+  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,29 +1,76 @@
-export interface OrderDTO {
-    info: Order_InfoDTO;
-    items: Order_ItemsDTO[];
-}
-interface Order_InfoDTO {
+export interface DashboardOrderInfoDTO {
+    customerId?: string;
+    customerProfile?: string;
     customerName?: string;
     customerEmail?: string;
+    customerPhone?: string;
+    customerNIF?: string;
     notes?: string;
     lat?: number;
     lng?: number;
     address?: string;
 }
-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;
-    origin: string | null;
-    createdAt: Date;
-    updatedAt: Date;
-    organizationId: string | null;
+    invoice?: string | null;
+    invoice_link?: string | null;
+    organizationId: string;
+    amount: number;
+    couponCode?: string | null;
+    couponDiscount?: number | null;
+    frete?: number | null;
+    status: string;
+    transactionId?: string;
+    [key: string]: unknown;
+}
+export interface GetFreteDTO {
+    localization?: string;
+    lat?: number;
+    long?: number;
+    coupon?: string;
+    items?: DashboardOrderItemDTO[];
+}
+export interface CouponDiscountDTO {
+    code: string;
+    items: DashboardOrderItemDTO[];
+    customerId?: string;
+    customerEmail?: string;
+    fretePrice?: number;
+}
+export interface FreteResponseDTO {
+    required: boolean;
+    price: number;
+    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.js";
-import type { OrderService } from "./service/order.ser.js";
+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.js";
-import { OrderFeature } from "./order.feature.js";
+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.js";
-import type { Order_Return, OrderDTO } from "../dto/order.dto.js";
+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

@@ -1,9 +1,10 @@
-import type { OrganizationInfoResponseDTO, OrganizationLinkDTO } from "./dto/organization.dto.js";
-import { OrganizationService } from "./service/organization.ser.js";
+import type { OrganizationInfoResponseDTO, OrganizationLinkDTO } from "./dto/organization.dto";
+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

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

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

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

@@ -1,9 +1,8 @@
-import type { HellenaConnect } from "@/core/HellenaConnect.js";
-import type { OrganizationInfoResponseDTO, OrganizationLinkDTO } from "../dto/organization.dto.js";
+import type { HellenaConnect } from "@//core/HellenaConnect";
+import type { OrganizationInfoResponseDTO, OrganizationLinkDTO } from "../dto/organization.dto";
 export declare class OrganizationService {
     private readonly connect;
     constructor(connect: HellenaConnect);
     getInfo(): Promise<OrganizationInfoResponseDTO>;
     getLinks(): Promise<OrganizationLinkDTO[]>;
 }
-//# sourceMappingURL=organization.ser.d.ts.map

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

@@ -0,0 +1,14 @@
+export interface PaymentMethodDTO {
+    id: string;
+    method: string;
+    testMode: boolean;
+}
+export interface CreateWiPayPaymentDTO {
+    customer: string;
+    reference: string;
+    failure_url: string;
+    success_url: string;
+}
+export interface CreateWiPayPaymentResponseDTO {
+    url: string;
+}

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

@@ -0,0 +1,10 @@
+import type { CreateWiPayPaymentDTO, CreateWiPayPaymentResponseDTO, PaymentMethodDTO } from "./dto/payment.dto";
+import type { PaymentService } from "./service/payment.ser";
+export declare class PaymentFeature {
+    private readonly service;
+    constructor(service: PaymentService);
+    /** Lista os métodos de pagamento configurados para a organização. */
+    listAvailablePaymentMethods(): Promise<PaymentMethodDTO[]>;
+    /** Cria uma sessão de pagamento WiPay e devolve o URL para continuar o fluxo. */
+    createWiPayPayment(data: CreateWiPayPaymentDTO): Promise<CreateWiPayPaymentResponseDTO>;
+}