@uappi/public-sdk 1.0.0

package/modules/Api/endpoints/BannerComposable.ts

@@ -0,0 +1,31 @@
+import { usePublicApi } from '..';
+
+import type { Banners } from '../types';
+
+export function listBanners<AdditionalParameters = []>(
+  codes: string,
+): Promise<Banners<AdditionalParameters>>;
+
+export function listBanners<AdditionalParameters = []>(
+  codes: Array<string>,
+): Promise<Array<Banners<AdditionalParameters>>>;
+
+export function listBanners<AdditionalParameters = []>(
+  codes: Array<string> | string,
+) {
+  if (Array.isArray(codes)) {
+    return usePublicApi<Array<Banners<AdditionalParameters>>>({
+      endpoint: '/publics/template/banners/',
+      params: {
+        codes
+      }
+    });
+  }
+
+  return usePublicApi<Array<Banners<AdditionalParameters>>>({
+    endpoint: '/publics/template/banners/',
+    params: {
+      codes: [codes]
+    }
+  }).then(data => data[0]);
+}

package/modules/Api/endpoints/BrandComposable.ts

@@ -0,0 +1,21 @@
+import { usePublicApi } from '..';
+
+import type {
+  Brand,
+  ApiParams,
+  BrandFields,
+  BrandConditions,
+  BrandOrders,
+} from '../types';
+
+export function listBrands(
+  options?: Pick<
+    ApiParams<BrandFields, BrandOrders, BrandConditions>,
+    'condition' | 'fields' | 'offset' | 'limit' | 'order'
+  >,
+) {
+  return usePublicApi<Brand, BrandFields, BrandOrders, BrandConditions>({
+    endpoint: '/publics/products/brands',
+    params: options,
+  });
+}

package/modules/Api/endpoints/CartComposable.ts

@@ -0,0 +1,121 @@
+import { usePublicApi } from '..';
+
+import type {
+  CartResponse,
+  DeleteCartRequest,
+  UpsertCartRequest,
+  ShipmentQuoteCartRequest,
+  SelectShipimentRequest,
+  AddressesToCartRequest,
+  PaymentResponse,
+  BuyCartRequest,
+  BuyCartResponse,
+} from '../types';
+
+export function listDetail() {
+  const response = usePublicApi<CartResponse>({
+    endpoint: '/cart',
+  });
+
+  return response;
+}
+
+export function addProduct(payload: UpsertCartRequest) {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart',
+    method: 'POST',
+    payload,
+  });
+}
+
+export function upsertProduct(payload: UpsertCartRequest) {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart',
+    method: 'PUT',
+    payload,
+  });
+}
+
+export function deleteProduct(payload: DeleteCartRequest) {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart',
+    method: 'DELETE',
+    payload,
+  });
+}
+
+export function shipmentQuote(payload: ShipmentQuoteCartRequest) {
+  return usePublicApi<CartResponse, ShipmentQuoteCartRequest>({
+    endpoint: '/cart/quote',
+    method: 'POST',
+    payload,
+  });
+}
+
+export function selectShipment(payload: SelectShipimentRequest) {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart/shipping',
+    method: 'PUT',
+    payload,
+  });
+}
+
+export function applyAddresses(payload: AddressesToCartRequest) {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart/address',
+    method: 'PUT',
+    payload,
+  });
+}
+
+export function applyWallet() {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart/promotionals/customer-wallet',
+    method: 'POST',
+  });
+}
+
+export function deleteWallet() {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart/promotionals/customer-wallet',
+    method: 'DELETE',
+  });
+}
+
+export function applyPoint() {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart/promotionals/point-system',
+    method: 'POST',
+  });
+}
+
+export function deletePoint() {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart/promotionals/point-system',
+    method: 'DELETE',
+  });
+}
+
+export function listPayments() {
+  return usePublicApi<PaymentResponse>({
+    endpoint: '/cart/payments',
+    method: 'GET',
+  });
+}
+
+export function buy(payload: BuyCartRequest) {
+  return usePublicApi<BuyCartResponse>({
+    endpoint: '/cart/buy',
+    method: 'POST',
+    payload,
+  });
+}
+
+
+export function recovery(recoveryCode: string) {
+  const response = usePublicApi<CartResponse>({
+    endpoint: `/cart/recovery/${recoveryCode}`,
+  });
+
+  return response;
+}

package/modules/Api/endpoints/CommonComposable.ts

@@ -0,0 +1,24 @@
+import { usePublicApi } from '..';
+
+import type { CardFlags, CountryAlpha3, CountryResponse } from '../types';
+
+export function listContries() {
+  return usePublicApi<Array<CountryResponse>>({
+    method: 'GET',
+    endpoint: '/common/countries',
+  });
+}
+
+export function countryDetail(code: CountryAlpha3) {
+  return usePublicApi<CountryResponse>({
+    method: 'GET',
+    endpoint: `/common/country/${code}`,
+  });
+}
+
+export function listCardFlags() {
+  return usePublicApi<CardFlags>({
+    method: 'GET',
+    endpoint: '/publics/payments/card-flags',
+  });
+}

package/modules/Api/endpoints/CouponComposable.ts

@@ -0,0 +1,18 @@
+import { usePublicApi } from '..';
+
+import type { AddCouponRequest, CartResponse } from '../types';
+
+export function addCoupon(payload: AddCouponRequest) {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart/promotionals/coupon',
+    method: 'PUT',
+    payload,
+  });
+}
+
+export function deleteCoupon() {
+  return usePublicApi<CartResponse>({
+    endpoint: '/cart/promotionals/coupon',
+    method: 'DELETE',
+  });
+}

package/modules/Api/endpoints/CustomerComposable.ts

@@ -0,0 +1,255 @@
+import { usePublicApi } from '..';
+
+import type {
+  ApiParams,
+  CustomerResponse,
+  SignupCustomer,
+  SigninCustomerByDocument,
+  SigninCustomerByEmail,
+  ResponseSigninCustomer,
+  CheckCustomer,
+  ChangePasswordCustomerAuthenticated,
+  UpdateCustomer,
+  PasswordRecoveryCustomer,
+  CustomerFields,
+  CustomerSortFields,
+  CustomerConditionFields,
+  ChangePasswordCustomerByCode,
+  UpsertCustomerAddressRequest,
+  CustomerAddressResponse,
+  CustomerAddressesResponse,
+  CustomerOrderResponse,
+  CustomerOrderGroupFields,
+  CustomerOrderGroupConditionFields,
+  CustomerOrderGroupSortFields,
+  CustomerOrderItemHistoriesResponse,
+  CustomerOrdersResponse,
+  CustomerOrderItemHistorySortFields,
+  CustomerOrderItemHistoryConditionFields,
+  CustomerHistoryResponse,
+  CustomerHistorySortFields,
+  CustomerHistoryConditionFields,
+  AddCustomerToNewsletterRequest,
+  AddCustomerToNewsletterResponse,
+  CheckCustomerResponse,
+  UpdateCustomerDocument,
+  UpdateCustomerDocumentResponse,
+} from '../types';
+
+export function detail(
+  options?: Pick<
+    ApiParams<CustomerFields, CustomerSortFields, CustomerConditionFields>,
+    'condition' | 'fields' | 'order'
+  >,
+) {
+  return usePublicApi<
+    CustomerResponse,
+    CustomerFields,
+    CustomerSortFields,
+    CustomerConditionFields
+  >({ endpoint: '/customer', params: options });
+}
+
+export function signup(payload: SignupCustomer) {
+  return usePublicApi<CustomerResponse>({
+    endpoint: '/customer',
+    method: 'POST',
+    payload,
+  });
+}
+
+export function signinByEmail(payload: SigninCustomerByEmail) {
+  return usePublicApi<ResponseSigninCustomer>({
+    endpoint: '/customer/login/email',
+    method: 'POST',
+    payload,
+  });
+}
+
+export function signinByDocument(payload: SigninCustomerByDocument) {
+  return usePublicApi<ResponseSigninCustomer>({
+    endpoint: '/customer/login/document',
+    method: 'POST',
+    payload,
+  });
+}
+
+export function check(payload: CheckCustomer) {
+  return usePublicApi<CheckCustomerResponse>({
+    endpoint: '/customer/login/check',
+    method: 'POST',
+    payload,
+  });
+}
+
+export function update(payload: UpdateCustomer) {
+  return usePublicApi<CustomerResponse>({
+    endpoint: '/customer',
+    method: 'PUT',
+    payload,
+  });
+}
+
+export function updateDocument(payload: UpdateCustomerDocument) {
+  return usePublicApi<UpdateCustomerDocumentResponse>({
+    endpoint: '/customer/document',
+    method: 'PUT',
+    payload,
+  });
+}
+
+export function changePasswordByAuthenticated(
+  payload: ChangePasswordCustomerAuthenticated,
+) {
+  return usePublicApi<boolean>({
+    endpoint: '/customer/password',
+    method: 'PUT',
+    payload,
+  });
+}
+
+export function passwordRecovery(payload: PasswordRecoveryCustomer) {
+  return usePublicApi<boolean>({
+    endpoint: '/customer/password-recovery',
+    method: 'POST',
+    payload,
+  });
+}
+
+// TODO validar retorno
+export function changePasswordByCode(payload: ChangePasswordCustomerByCode) {
+  return usePublicApi<boolean>({
+    endpoint: '/customer/password-recovery',
+    method: 'PUT',
+    payload,
+  });
+}
+
+export function createAddress(payload: UpsertCustomerAddressRequest) {
+  return usePublicApi<CustomerAddressResponse>({
+    method: 'POST',
+    endpoint: '/customer/address',
+    payload,
+  });
+}
+
+export function updateAddress(
+  addressId: number,
+  payload: UpsertCustomerAddressRequest,
+) {
+  return usePublicApi<CustomerAddressResponse>({
+    method: 'PUT',
+    endpoint: `/customer/address/${addressId}`,
+    payload,
+  });
+}
+
+export function updatePrimaryAddress(addressId: number) {
+  return usePublicApi<CustomerAddressResponse>({
+    method: 'PUT',
+    endpoint: `/customer/address/main/${addressId}`,
+  });
+}
+
+export function deleteAddress(addressId: number) {
+  return usePublicApi<CustomerAddressResponse>({
+    method: 'DELETE',
+    endpoint: `/customer/address/${addressId}`,
+  });
+}
+
+export function listAddress() {
+  return usePublicApi<CustomerAddressesResponse>({
+    method: 'GET',
+    endpoint: '/customer/address',
+  });
+}
+
+export function detailOrderGroup(
+  orderId: number,
+  options?: Pick<ApiParams<CustomerOrderGroupFields>, 'fields'>,
+) {
+  return usePublicApi<CustomerOrderResponse, CustomerOrderGroupFields>({
+    method: 'GET',
+    endpoint: `/customer/orders/groups/${orderId}`,
+    params: options,
+  });
+}
+
+export function listOrderGroups(
+  options?: Pick<
+    ApiParams<
+      CustomerOrderGroupFields,
+      CustomerOrderGroupSortFields,
+      CustomerOrderGroupConditionFields
+    >,
+    'condition' | 'fields' | 'limit' | 'offset' | 'order'
+  >,
+) {
+  return usePublicApi<
+    CustomerOrdersResponse,
+    CustomerOrderGroupFields,
+    CustomerOrderGroupSortFields,
+    CustomerOrderGroupConditionFields
+  >({
+    method: 'GET',
+    endpoint: '/customer/orders/groups',
+    params: options,
+  });
+}
+
+export function listOrderItemHistory(
+  orderId: number,
+  options?: Pick<
+    ApiParams<
+      '',
+      CustomerOrderItemHistorySortFields,
+      CustomerOrderItemHistoryConditionFields
+    >,
+    'condition' | 'fields' | 'limit' | 'offset' | 'order'
+  >,
+) {
+  return usePublicApi<
+    CustomerOrderItemHistoriesResponse,
+    '',
+    CustomerOrderItemHistorySortFields,
+    CustomerOrderItemHistoryConditionFields
+  >({
+    method: 'GET',
+    endpoint: `/customer/orders/${orderId}/history`,
+    params: options,
+  });
+}
+
+export function addNewsletter(payload: AddCustomerToNewsletterRequest) {
+  return usePublicApi<AddCustomerToNewsletterResponse>({
+    method: 'POST',
+    endpoint: '/customer/newsletter',
+    payload,
+  });
+}
+
+export function deleteNewsletter() {
+  return usePublicApi<CustomerOrderResponse, CustomerOrderGroupFields>({
+    method: 'DELETE',
+    endpoint: '/customer/newsletter',
+  });
+}
+
+export function listCustomerHistory(
+  options?: Pick<
+    ApiParams<'', CustomerHistorySortFields, CustomerHistoryConditionFields>,
+    'condition' | 'limit' | 'offset' | 'order'
+  >,
+) {
+  return usePublicApi<
+    CustomerHistoryResponse,
+    '',
+    CustomerHistorySortFields,
+    CustomerHistoryConditionFields
+  >({
+    endpoint: '/customer/history',
+    method: 'GET',
+    params: options,
+  });
+}

package/modules/Api/endpoints/InterestComposable.ts

@@ -0,0 +1,11 @@
+import { usePublicApi } from '..';
+
+import type { RequestInterest, ResponseInterest } from '../types';
+
+export function createInterest(payload: RequestInterest) {
+  return usePublicApi<ResponseInterest, RequestInterest>({
+    endpoint: '/publics/products/interests',
+    method: 'POST',
+    payload,
+  });
+}

package/modules/Api/endpoints/LoggoutComposable.ts

@@ -0,0 +1,8 @@
+import { usePublicApi } from '..';
+
+export function loggout() {
+  return usePublicApi<boolean>({
+    method: 'DELETE',
+    endpoint: '/logout',
+  });
+}

package/modules/Api/endpoints/MenuComposable.ts

@@ -0,0 +1,25 @@
+import { usePublicApi } from '..';
+
+import type { Menu } from '../types';
+
+export function listMenu(codes: string): Promise<Menu>;
+
+export function listMenu(codes: Array<string>): Promise<Array<Menu>>;
+
+export function listMenu(codes: Array<string> | string) {
+  if (Array.isArray(codes)) {
+    return usePublicApi<Array<Menu>>({
+      endpoint: '/publics/template/menus/',
+      params: {
+        codes,
+      },
+    });
+  }
+
+  return usePublicApi<Array<Menu>>({
+    endpoint: '/publics/template/menus/',
+    params: {
+      codes: [codes],
+    },
+  }).then(data => data[0]);
+}

package/modules/Api/endpoints/PairOfferComposable.ts

@@ -0,0 +1,14 @@
+import { usePublicApi } from '..';
+
+import type { ApiParams, ProductFields, PairOfferResponse } from '../types';
+
+export function listPairOffers(
+  productId: number,
+  options?: Pick<ApiParams<ProductFields>, 'fields' | 'variationMap'>,
+) {
+  return usePublicApi<PairOfferResponse, ProductFields>({
+    endpoint: `/publics/products/${productId}/pair-offers`,
+    method: 'GET',
+    params: options,
+  });
+}

package/modules/Api/endpoints/PaymentComposable.ts

@@ -0,0 +1,14 @@
+import { usePublicApi } from '..';
+
+import type {
+  PaymentConditionsRequest,
+  PaymentConditionsResponse,
+} from '../types';
+
+export function paymentConditions(payload: PaymentConditionsRequest) {
+  return usePublicApi<PaymentConditionsResponse>({
+    endpoint: '/publics/payments/conditions',
+    method: 'POST',
+    payload,
+  });
+}

package/modules/Api/endpoints/ProductCommentComposable.ts

@@ -0,0 +1,51 @@
+import { usePublicApi } from '..';
+
+import type {
+  ApiParams,
+  ProductComment,
+  CreateProductComment,
+  ProductCommentConditionFields,
+  ProductCommentFields,
+  ProductCommentSortFields,
+  ProductCommentsResponse,
+} from '../types';
+
+export function listProductComments(
+  options?: Pick<
+    ApiParams<
+      ProductCommentFields,
+      ProductCommentSortFields,
+      ProductCommentConditionFields
+    >,
+    'condition' | 'order' | 'limit' | 'offset' | 'fields'
+  >,
+) {
+  return usePublicApi<
+    ProductCommentsResponse,
+    ProductCommentFields,
+    ProductCommentSortFields,
+    ProductCommentConditionFields
+  >({
+    endpoint: '/publics/products/comments',
+    method: 'GET',
+    params: options,
+  });
+}
+
+export function createProductComment(
+  productId: number,
+  payload: CreateProductComment,
+) {
+  return usePublicApi<ProductComment, CreateProductComment>({
+    endpoint: `/publics/products/${productId}/comments`,
+    method: 'POST',
+    payload,
+  });
+}
+
+export function deleteProductComment(commentId: number) {
+  return usePublicApi<boolean>({
+    endpoint: `/publics/products/comments/${commentId}`,
+    method: 'DELETE',
+  });
+}

package/modules/Api/endpoints/ProductQuoteShipment.ts

@@ -0,0 +1,20 @@
+import { usePublicApi } from '..';
+
+import type {
+  ApiParams,
+  ShipmentQuoteProductRequest,
+  ShipmentQuoteProductResponse,
+} from '../types';
+
+export async function listShipmentQuoteProduct(
+  payload: Pick<ApiParams, 'targetCountryCode' | 'targetZipCode' | 'items'>,
+) {
+  return usePublicApi<
+    ShipmentQuoteProductResponse,
+    ShipmentQuoteProductRequest
+  >({
+    endpoint: '/publics/products/quote',
+    method: 'GET',
+    params: payload,
+  });
+}

package/modules/Api/endpoints/PublicComposable.ts

@@ -0,0 +1,9 @@
+import { usePublicApi } from "..";
+
+export function contact<D>(payload: D) {
+  return usePublicApi<boolean, D>({
+    endpoint: '/publics/contact-center',
+    method: 'POST',
+    payload
+  });
+}

package/modules/Api/endpoints/ReviewComposable.ts

@@ -0,0 +1,64 @@
+import { usePublicApi } from '..';
+
+import type {
+  ApiParams,
+  ProductReviewRequest,
+  ProductReviewResponse,
+  ReviewConditionFields,
+  ReviewFields,
+  ReviewSortFields,
+} from '../types';
+
+export function listProductReview(
+  options?: Pick<
+    ApiParams<ReviewFields, ReviewSortFields, ReviewConditionFields>,
+    'condition' | 'order' | 'fields' | 'limit' | 'offset'
+  >,
+) {
+  return usePublicApi<
+    ProductReviewResponse,
+    ReviewFields,
+    ReviewSortFields,
+    ReviewConditionFields
+  >({
+    endpoint: '/review/product',
+    method: 'GET',
+    params: options,
+  });
+}
+
+export function createProductReview(
+  productId: number,
+  payload: ProductReviewRequest,
+) {
+  return usePublicApi<ProductReviewRequest>({
+    endpoint: `/review/product/${productId}`,
+    method: 'POST',
+    payload,
+  });
+}
+
+export function listStoreReview() {
+  return usePublicApi<ProductReviewResponse>({
+    endpoint: '/review/sales-channel',
+    method: 'GET',
+  });
+}
+
+export function listCustomerReview(
+  options?: Pick<
+    ApiParams<ReviewFields, ReviewSortFields, ReviewConditionFields>,
+    'condition' | 'order' | 'fields' | 'limit' | 'offset'
+  >,
+) {
+  return usePublicApi<
+    ProductReviewResponse,
+    ReviewFields,
+    ReviewSortFields,
+    ReviewConditionFields
+  >({
+    endpoint: '/review/product/customer',
+    method: 'GET',
+    params: options,
+  });
+}