@evenicanpm/storefront-core 1.1.0 → 1.2.0

package/src/api-manager/services/create-query.ts

@@ -1,14 +1,14 @@
 /* eslint-disable  @typescript-eslint/no-explicit-any */
 // TODO: use api manager types to remove type any
-import createApiManager from "@/api-manager/index";
+import createApiManager from "@evenicanpm/storefront-core/src/api-manager/index";
 import { isServer, QueryClient } from "@tanstack/query-core";
 import {
-  UseQueryResult,
-  UseSuspenseQueryResult,
-  useQuery,
-  useSuspenseQuery,
+	UseQueryResult,
+	UseSuspenseQueryResult,
+	useQuery,
+	useSuspenseQuery,
 } from "@tanstack/react-query";
-import { DatasourceApis } from "@/api-manager/types/Datasource";
+import { DatasourceApis } from "@evenicanpm/storefront-core/src/api-manager/types/Datasource";
 import { Mutex } from "async-mutex";
 import { manuallyRetrieveSessionCookie } from "@/auth/next-auth-cookie-manager";
 import { getSession } from "next-auth/react";
@@ -30,240 +30,240 @@ const mutex = new Mutex();
  * @returns
  */
 export const createQuery = <TInput, TOutput>(
-  apiManagerPath: ApiPath<keyof DatasourceApis>,
-  config?: {
-    queryKey?: string;
-    disableProperties?: Array<keyof TInput>;
-  },
+	apiManagerPath: ApiPath<keyof DatasourceApis>,
+	config?: {
+		queryKey?: string;
+		disableProperties?: Array<keyof TInput>;
+	},
 ) => {
-  /**
-   * Generates the configuration object for a query, including the query function, cache key, and enabled state.
-   *
-   * The query function (`queryFn`) is determined based on the execution environment (server or client):
-   * - On the server, it checks for token expiry, refreshes the token if needed, creates an API manager, and invokes the appropriate API function.
-   * - On the client, it checks for token expiry and either refreshes the token or performs a fetch operation.
-   *
-   * The `enabled` property is computed based on the presence and truthiness of specified properties in the input, if `disableProperties` are provided in options.
-   *
-   * @param input - Optional input parameters for the query and API function.
-   * @returns An object containing:
-   *   - `queryKey`: The cache key for the query, built from the input.
-   *   - `queryFn`: The asynchronous function to execute for the query.
-   *   - `enabled`: A boolean indicating whether the query should be enabled.
-   */
-  const getQueryData = (input?: TInput) => {
-    const queryFn = isServer
-      ? /// Server ///
-        async () => {
-          const apiManager = await createApiManager();
-          const apiFunction = getApiFromPath(apiManager, apiManagerPath);
-          const result = await apiFunction(input);
-          return result;
-        }
-      : /// Client ///
-        async () => {
-          // Check if token is expired
-          const shouldRefreshToken = await checkTokenExpiry();
-          if (shouldRefreshToken) {
-            return await handleTokenRefreshClient(input);
-          } else {
-            return await doFetch(input, apiManagerPath);
-          }
-        };
+	/**
+	 * Generates the configuration object for a query, including the query function, cache key, and enabled state.
+	 *
+	 * The query function (`queryFn`) is determined based on the execution environment (server or client):
+	 * - On the server, it checks for token expiry, refreshes the token if needed, creates an API manager, and invokes the appropriate API function.
+	 * - On the client, it checks for token expiry and either refreshes the token or performs a fetch operation.
+	 *
+	 * The `enabled` property is computed based on the presence and truthiness of specified properties in the input, if `disableProperties` are provided in options.
+	 *
+	 * @param input - Optional input parameters for the query and API function.
+	 * @returns An object containing:
+	 *   - `queryKey`: The cache key for the query, built from the input.
+	 *   - `queryFn`: The asynchronous function to execute for the query.
+	 *   - `enabled`: A boolean indicating whether the query should be enabled.
+	 */
+	const getQueryData = (input?: TInput) => {
+		const queryFn = isServer
+			? /// Server ///
+				async () => {
+					const apiManager = await createApiManager();
+					const apiFunction = getApiFromPath(apiManager, apiManagerPath);
+					const result = await apiFunction(input);
+					return result;
+				}
+			: /// Client ///
+				async () => {
+					// Check if token is expired
+					const shouldRefreshToken = await checkTokenExpiry();
+					if (shouldRefreshToken) {
+						return await handleTokenRefreshClient(input);
+					} else {
+						return await doFetch(input, apiManagerPath);
+					}
+				};
 
-    // if disable props specified then use them to compute enabled
-    const enabled: boolean = config?.disableProperties
-      ? config.disableProperties.every((prop) => !!input?.[prop])
-      : true;
+		// if disable props specified then use them to compute enabled
+		const enabled: boolean = config?.disableProperties
+			? config.disableProperties.every((prop) => !!input?.[prop])
+			: true;
 
-    const data = {
-      queryKey: buildCacheKey(input),
-      queryFn,
-      enabled,
-    };
-    return data;
-  };
+		const data = {
+			queryKey: buildCacheKey(input),
+			queryFn,
+			enabled,
+		};
+		return data;
+	};
 
-  /**
-   * Sends a POST request to the specified route with the provided input and API manager path.
-   *
-   * @template TInput - The type of the input parameter.
-   * @param input - The input data to be sent in the request body. Can be undefined.
-   * @param route - The endpoint URL to which the request is sent.
-   * @param apiManagerPath - The API manager path used to identify the API endpoint.
-   * @returns A promise that resolves to the response of the fetch request.
-   */
-  const doFetch = async (
-    input: TInput | undefined,
-    apiManagerPath: ApiPath<keyof DatasourceApis>,
-    additionalHeaders?: HeadersInit,
-  ) => {
-    // Merge headers
-    const headers = new Headers(additionalHeaders);
-    // generic route handler (new) - will refactor all queries to use this
-    const result = await fetch(QUERY_ROUTE, {
-      method: "POST",
-      body: JSON.stringify({ input, apiManagerPath }),
-      headers,
-    });
+	/**
+	 * Sends a POST request to the specified route with the provided input and API manager path.
+	 *
+	 * @template TInput - The type of the input parameter.
+	 * @param input - The input data to be sent in the request body. Can be undefined.
+	 * @param route - The endpoint URL to which the request is sent.
+	 * @param apiManagerPath - The API manager path used to identify the API endpoint.
+	 * @returns A promise that resolves to the response of the fetch request.
+	 */
+	const doFetch = async (
+		input: TInput | undefined,
+		apiManagerPath: ApiPath<keyof DatasourceApis>,
+		additionalHeaders?: HeadersInit,
+	) => {
+		// Merge headers
+		const headers = new Headers(additionalHeaders);
+		// generic route handler (new) - will refactor all queries to use this
+		const result = await fetch(QUERY_ROUTE, {
+			method: "POST",
+			body: JSON.stringify({ input, apiManagerPath }),
+			headers,
+		});
 
-    if (result.status === 401) {
-      // If unauthenticated , sign out the user
-      signOut();
-    }
-    return await result.json();
-  };
+		if (result.status === 401) {
+			// If unauthenticated , sign out the user
+			signOut();
+		}
+		return await result.json();
+	};
 
-  /**
-   * Client-side hook to call data from react query cache
-   * @returns
-   */
-  const useData = (
-    input?: TInput,
-    options?: { enabled: boolean },
-  ): UseQueryResult<TOutput> => {
-    return useQuery({ ...getQueryData(input), enabled: options?.enabled });
-  };
+	/**
+	 * Client-side hook to call data from react query cache
+	 * @returns
+	 */
+	const useData = (
+		input?: TInput,
+		options?: { enabled: boolean },
+	): UseQueryResult<TOutput> => {
+		return useQuery({ ...getQueryData(input), enabled: options?.enabled });
+	};
 
-  /**
-   * Client-side hook to call data from react query cache,
-   * used with suspense for suspense loading state handling
-   * @returns
-   */
-  const useSuspenseData = (input?: TInput): UseSuspenseQueryResult<TOutput> => {
-    return useSuspenseQuery(getQueryData(input));
-  };
+	/**
+	 * Client-side hook to call data from react query cache,
+	 * used with suspense for suspense loading state handling
+	 * @returns
+	 */
+	const useSuspenseData = (input?: TInput): UseSuspenseQueryResult<TOutput> => {
+		return useSuspenseQuery(getQueryData(input));
+	};
 
-  /**
-   * Called on server to fetch query and load cache
-   * @param queryClient
-   * @returns
-   */
-  const fetchData = async (queryClient: QueryClient, input?: TInput) => {
-    return await queryClient.fetchQuery(getQueryData(input));
-  };
+	/**
+	 * Called on server to fetch query and load cache
+	 * @param queryClient
+	 * @returns
+	 */
+	const fetchData = async (queryClient: QueryClient, input?: TInput) => {
+		return await queryClient.fetchQuery(getQueryData(input));
+	};
 
-  /**
-   * Called on server to fetch query and load cache in anticipation
-   * of client using data
-   * @param queryClient
-   */
-  const prefetchData = async (queryClient: QueryClient, input?: TInput) => {
-    return await queryClient.prefetchQuery(getQueryData(input));
-  };
+	/**
+	 * Called on server to fetch query and load cache in anticipation
+	 * of client using data
+	 * @param queryClient
+	 */
+	const prefetchData = async (queryClient: QueryClient, input?: TInput) => {
+		return await queryClient.prefetchQuery(getQueryData(input));
+	};
 
-  /**
-   * Wrapper on getQueryData
-   * TODO: need to fix this naming so we're properly shadowing
-   * the names of tanstack-query
-   */
-  const getData = async (
-    queryClient: QueryClient,
-  ): Promise<TOutput | undefined> => {
-    const cacheKey = buildCacheKey();
-    return await queryClient.getQueryData(cacheKey);
-  };
+	/**
+	 * Wrapper on getQueryData
+	 * TODO: need to fix this naming so we're properly shadowing
+	 * the names of tanstack-query
+	 */
+	const getData = async (
+		queryClient: QueryClient,
+	): Promise<TOutput | undefined> => {
+		const cacheKey = buildCacheKey();
+		return await queryClient.getQueryData(cacheKey);
+	};
 
-  /**
-   *
-   * @param queryClient react-query client
-   * @param data the data to set the query to
-   * @param input the input of the query that's used to generate cache key
-   * returns a promise of QueryResult for query
-   */
-  const setQueryData = async (
-    queryClient: QueryClient,
-    data: TOutput,
-    input?: TInput,
-  ) => {
-    const key = buildCacheKey(input);
-    return await queryClient.setQueryData(key, data);
-  };
+	/**
+	 *
+	 * @param queryClient react-query client
+	 * @param data the data to set the query to
+	 * @param input the input of the query that's used to generate cache key
+	 * returns a promise of QueryResult for query
+	 */
+	const setQueryData = async (
+		queryClient: QueryClient,
+		data: TOutput,
+		input?: TInput,
+	) => {
+		const key = buildCacheKey(input);
+		return await queryClient.setQueryData(key, data);
+	};
 
-  /**
-   *
-   * @param input the input for the query of TInput
-   * @returns if no input, the query key, if input, query key and input in array
-   */
-  const buildCacheKey = (input?: TInput) => {
-    const prefix = config?.queryKey ?? apiManagerPath;
-    return input ? [prefix, input] : [prefix];
-  };
+	/**
+	 *
+	 * @param input the input for the query of TInput
+	 * @returns if no input, the query key, if input, query key and input in array
+	 */
+	const buildCacheKey = (input?: TInput) => {
+		const prefix = config?.queryKey ?? apiManagerPath;
+		return input ? [prefix, input] : [prefix];
+	};
 
-  /**
-   * Asynchronously checks whether the current session's access token has expired.
-   *
-   * Retrieves the current session and decodes the access token to extract its expiration time.
-   * Compares the token's expiration (`exp`) claim with the current time.
-   *
-   * @returns A promise that resolves to `true` if the token is expired, or `false` otherwise.
-   */
-  const checkTokenExpiry = async () => {
-    let token: string | undefined;
-    if (isServer) {
-      // Server-side: retrieve session from cookies
-      const session = (await manuallyRetrieveSessionCookie()) ?? undefined;
-      token = session?.accessToken;
-    } else {
-      const session = await getSession();
-      token = session?.accessToken;
-    }
+	/**
+	 * Asynchronously checks whether the current session's access token has expired.
+	 *
+	 * Retrieves the current session and decodes the access token to extract its expiration time.
+	 * Compares the token's expiration (`exp`) claim with the current time.
+	 *
+	 * @returns A promise that resolves to `true` if the token is expired, or `false` otherwise.
+	 */
+	const checkTokenExpiry = async () => {
+		let token: string | undefined;
+		if (isServer) {
+			// Server-side: retrieve session from cookies
+			const session = (await manuallyRetrieveSessionCookie()) ?? undefined;
+			token = session?.accessToken;
+		} else {
+			const session = await getSession();
+			token = session?.accessToken;
+		}
 
-    const decoded = token && (jwt.decode(token) as { exp?: number } | null);
+		const decoded = token && (jwt.decode(token) as { exp?: number } | null);
 
-    const currentTime = Math.floor(Date.now() / 1000);
+		const currentTime = Math.floor(Date.now() / 1000);
 
-    // Use this for testing - expires after 60 seconds (1 min) from issued-at time
-    // const isExpired = !!decoded && typeof decoded.iat === "number" && currentTime > decoded.iat + 60;
+		// Use this for testing - expires after 60 seconds (1 min) from issued-at time
+		// const isExpired = !!decoded && typeof decoded.iat === "number" && currentTime > decoded.iat + 60;
 
-    const isExpired =
-      !!decoded && typeof decoded.exp === "number" && decoded.exp < currentTime;
+		const isExpired =
+			!!decoded && typeof decoded.exp === "number" && decoded.exp < currentTime;
 
-    return isExpired;
-  };
+		return isExpired;
+	};
 
-  /**
-   * Handles fetching data with token refresh logic in a thread-safe manner.
-   *
-   * Acquires a mutex lock to ensure only one token refresh operation occurs at a time.
-   * Checks if the token is expired and, if so, adds a header to indicate that the token should be refreshed.
-   * Performs the fetch operation with the appropriate headers and returns the parsed JSON response.
-   * Releases the mutex lock after the operation completes, regardless of success or failure.
-   *
-   * @param input - The input data for the fetch operation, which may be undefined.
-   * @returns A promise that resolves to the parsed JSON response from the fetch operation.
-   * @throws An error if the fetch operation fails.
-   */
-  const handleTokenRefreshClient = async (input: TInput | undefined) => {
-    const release = await mutex.acquire();
-    try {
-      // Check if token is expired again
-      const stillShouldRefreshToken = await checkTokenExpiry();
-      const headers = new Headers();
-      if (stillShouldRefreshToken) {
-        // Add refresh token header
-        headers.append("should-refresh-token", "true");
-      }
-      // Call do fetch with the headers
-      return await doFetch(input, apiManagerPath, headers);
-    } catch (error) {
-      // Handle API Error
-      console.error("Error fetching data:", error);
-      throw new Error("Failed to fetch data");
-    } finally {
-      release();
-    }
-  };
+	/**
+	 * Handles fetching data with token refresh logic in a thread-safe manner.
+	 *
+	 * Acquires a mutex lock to ensure only one token refresh operation occurs at a time.
+	 * Checks if the token is expired and, if so, adds a header to indicate that the token should be refreshed.
+	 * Performs the fetch operation with the appropriate headers and returns the parsed JSON response.
+	 * Releases the mutex lock after the operation completes, regardless of success or failure.
+	 *
+	 * @param input - The input data for the fetch operation, which may be undefined.
+	 * @returns A promise that resolves to the parsed JSON response from the fetch operation.
+	 * @throws An error if the fetch operation fails.
+	 */
+	const handleTokenRefreshClient = async (input: TInput | undefined) => {
+		const release = await mutex.acquire();
+		try {
+			// Check if token is expired again
+			const stillShouldRefreshToken = await checkTokenExpiry();
+			const headers = new Headers();
+			if (stillShouldRefreshToken) {
+				// Add refresh token header
+				headers.append("should-refresh-token", "true");
+			}
+			// Call do fetch with the headers
+			return await doFetch(input, apiManagerPath, headers);
+		} catch (error) {
+			// Handle API Error
+			console.error("Error fetching data:", error);
+			throw new Error("Failed to fetch data");
+		} finally {
+			release();
+		}
+	};
 
-  return {
-    useData,
-    useSuspenseData,
-    setQueryData,
-    fetchData,
-    prefetchData,
-    buildCacheKey,
-    getData,
-  };
+	return {
+		useData,
+		useSuspenseData,
+		setQueryData,
+		fetchData,
+		prefetchData,
+		buildCacheKey,
+		getData,
+	};
 };
 
 /**
@@ -271,8 +271,8 @@ export const createQuery = <TInput, TOutput>(
  * of first item
  */
 export type ApiPath<T extends keyof DatasourceApis = keyof DatasourceApis> = [
-  T,
-  keyof DatasourceApis[T],
+	T,
+	keyof DatasourceApis[T],
 ];
 
 /// Utilities ///
@@ -283,29 +283,29 @@ export type ApiPath<T extends keyof DatasourceApis = keyof DatasourceApis> = [
  * @returns the function at the specified path
  */
 export function getApiFromPath<TInput, TOutput>(
-  apiManager: any,
-  path: ApiPath,
+	apiManager: any,
+	path: ApiPath,
 ): (input?: TInput) => Promise<TOutput> {
-  const [entity, method] = path;
-  // Typescript is doing heavy lifting to ensure correct api path
-  // so safe to call method directly
-  const result = apiManager[entity][method];
+	const [entity, method] = path;
+	// Typescript is doing heavy lifting to ensure correct api path
+	// so safe to call method directly
+	const result = apiManager[entity][method];
 
-  if (process.env.NODE_ENV === "development") {
-    // eslint-disable-next-line no-console
-    console.log(`[CREATE QUERY] Accessing API Path:`, {
-      entity,
-      method,
-      result,
-    });
-  }
+	if (process.env.NODE_ENV === "development") {
+		// eslint-disable-next-line no-console
+		console.log(`[CREATE QUERY] Accessing API Path:`, {
+			entity,
+			method,
+			result,
+		});
+	}
 
-  // Function reference loses 'this' context.
-  // Re-bind for d365 classes.
-  if (typeof result === "function") {
-    return result.bind(apiManager[entity]);
-  }
-  return result;
+	// Function reference loses 'this' context.
+	// Re-bind for d365 classes.
+	if (typeof result === "function") {
+		return result.bind(apiManager[entity]);
+	}
+	return result;
 }
 
 /**
@@ -315,14 +315,15 @@ export function getApiFromPath<TInput, TOutput>(
  * @returns
  */
 export function createApiPath<T extends keyof DatasourceApis>(
-  key: T,
-  method: keyof DatasourceApis[T],
+	key: T,
+	method: keyof DatasourceApis[T],
 ) {
-  // have to re-cast to general keyof DatasourceApi after
-  // using stricter type for type narrowing and intellisense
-  return [key, method] as ApiPath<keyof DatasourceApis>;
+	// have to re-cast to general keyof DatasourceApi after
+	// using stricter type for type narrowing and intellisense
+	console.log([key, method]);
+	return [key, method] as ApiPath<keyof DatasourceApis>;
 }
 
 export type Query<TInput, TOutput> = ReturnType<
-  typeof createQuery<TInput, TOutput>
+	typeof createQuery<TInput, TOutput>
 >;

package/src/api-manager/services/get-query-client.ts

@@ -1,40 +1,40 @@
 import {
-  isServer,
-  QueryClient,
-  defaultShouldDehydrateQuery,
-  defaultShouldDehydrateMutation,
+	isServer,
+	QueryClient,
+	defaultShouldDehydrateQuery,
+	defaultShouldDehydrateMutation,
 } from "@tanstack/react-query";
 
 function makeQueryClient() {
-  return new QueryClient({
-    defaultOptions: {
-      queries: {
-        staleTime: 60 * 1000,
-      },
-      dehydrate: {
-        serializeData: (data) => JSON.stringify(data),
-        shouldDehydrateMutation: (mutation) =>
-          defaultShouldDehydrateMutation(mutation),
-        // include pending queries in dehydration
-        shouldDehydrateQuery: (query) =>
-          defaultShouldDehydrateQuery(query) ||
-          query.state.status === "pending",
-      },
-      hydrate: {
-        deserializeData: (data) => (data && JSON.parse(data)) || data,
-      },
-    },
-  });
+	return new QueryClient({
+		defaultOptions: {
+			queries: {
+				staleTime: 60 * 1000,
+			},
+			dehydrate: {
+				serializeData: (data) => JSON.stringify(data),
+				shouldDehydrateMutation: (mutation) =>
+					defaultShouldDehydrateMutation(mutation),
+				// include pending queries in dehydration
+				shouldDehydrateQuery: (query) =>
+					defaultShouldDehydrateQuery(query) ||
+					query.state.status === "pending",
+			},
+			hydrate: {
+				deserializeData: (data) => (data && JSON.parse(data)) || data,
+			},
+		},
+	});
 }
 
 let browserQueryClient: QueryClient | undefined;
 
 export function getQueryClient() {
-  if (isServer) {
-    // Server: always make a new query client
-    return makeQueryClient();
-  } else {
-    if (!browserQueryClient) browserQueryClient = makeQueryClient();
-    return browserQueryClient;
-  }
+	if (isServer) {
+		// Server: always make a new query client
+		return makeQueryClient();
+	} else {
+		if (!browserQueryClient) browserQueryClient = makeQueryClient();
+		return browserQueryClient;
+	}
 }

package/src/api-manager/services/order/queries/get-order-details.ts

@@ -1,20 +1,20 @@
 import {
-  GetSalesOrderDetailsInput,
-  SalesOrder,
-} from "@/api-manager/schemas/order.schema";
+	GetSalesOrderDetailsInput,
+	SalesOrder,
+} from "@evenicanpm/storefront-core/src/api-manager/schemas/order.schema";
 import {
-  createQuery,
-  createApiPath,
-} from "@/api-manager/services/create-query";
+	createQuery,
+	createApiPath,
+} from "@evenicanpm/storefront-core/src/api-manager/services/create-query";
 
 const apiPath = createApiPath("order", "getSalesOrderDetails");
 const config = {
-  queryKey: "salesOrderDetails",
+	queryKey: "salesOrderDetails",
 };
 
 const getOrderDetails = createQuery<GetSalesOrderDetailsInput, SalesOrder>(
-  apiPath,
-  config,
+	apiPath,
+	config,
 );
 
 export default getOrderDetails;