autumn-js/dist/next/client/hooks/useCustomer.js

Autumn JS Library

"use client";

import { useEffect, useState } from "react";
import { useAutumnContext } from "../AutumnContext";
import {
  getOrCreateCustomer,
  getCustomer,
  createEntityAction,
  deleteEntityAction
} from "../../server/cusActions";
import { toClientError, toClientErrorResponse } from "../clientUtils";
const defaultOptions = {
  expand: void 0,
  autoCreate: true,
  encryptedCustomerId: void 0,
  customerData: void 0,
  errorOnNotFound: true
};
const deleteEntity = async ({
  encryptedCustomerId,
  entityId
}) => {
  const result = await deleteEntityAction({
    encryptedCustomerId,
    entityId
  });
  if (result.error) {
    return toClientErrorResponse(result.error);
  }
  return result;
};
const useCustomer = (options) => {
  let finalOptions = defaultOptions;
  if (options) {
    finalOptions = { ...defaultOptions, ...options };
  }
  const { autoCreate } = finalOptions;
  const {
    encryptedCustomerId: contextEncryptedCustomerId,
    customerData: contextCustomerData,
    customer,
    setCustomer
  } = useAutumnContext();
  const encryptedCustomerId = finalOptions.encryptedCustomerId || contextEncryptedCustomerId;
  const customerData = finalOptions.customerData || contextCustomerData;
  const errorOnNotFound = finalOptions.errorOnNotFound;
  const [error, setError] = useState(null);
  const [isLoading, setIsLoading] = useState(true);
  const fetchCustomer = async () => {
    setIsLoading(true);
    let returnData = null;
    try {
      let data = null;
      let error2 = null;
      if (autoCreate) {
        const result = await getOrCreateCustomer({
          encryptedCustomerId,
          customerData,
          params: {
            expand: finalOptions.expand
          }
        });
        data = result.data;
        error2 = result.error;
      } else {
        const result = await getCustomer({
          encryptedCustomerId,
          params: {
            expand: finalOptions.expand
          }
        });
        data = result.data;
        error2 = result.error;
      }
      if (error2) {
        if (error2 && error2?.code == "no_customer_id" && !errorOnNotFound) {
        } else {
          setError(toClientError(error2, false));
        }
      } else {
        setCustomer(data);
        setError(null);
      }
      returnData = data;
    } catch (error2) {
      setError(toClientError(error2));
    }
    setIsLoading(false);
    return returnData;
  };
  const refetch = async () => {
    await fetchCustomer();
  };
  const createEntity = async (params) => {
    let snakeParams = [];
    if (Array.isArray(params)) {
      snakeParams = params.map((param) => ({
        ...param,
        feature_id: param.featureId
      }));
    } else {
      snakeParams = [{ ...params, feature_id: params.featureId }];
    }
    const result = await createEntityAction({
      encryptedCustomerId,
      entity: snakeParams
    });
    if (result.error) {
      return toClientErrorResponse(result.error);
    }
    return result;
  };
  useEffect(() => {
    fetchCustomer();
  }, [encryptedCustomerId]);
  return {
    customer,
    isLoading,
    error,
    refetch,
    createEntity,
    deleteEntity: (entityId) => deleteEntity({ encryptedCustomerId, entityId })
  };
};
export {
  useCustomer
};