@evenicanpm/storefront-core 2.1.0 → 2.3.0

package/src/api-manager/datasources/d365/d365-user.datasource.ts

@@ -26,11 +26,15 @@ import {
 	updateProductListLinesAsync,
 	readAsync as wishlistReadAsync,
 } from "@msdyn365-commerce/retail-proxy/dist/DataActions/ProductListsDataActions.g";
+import { getCustomerBalanceAsync } from "@msdyn365-commerce/retail-proxy/dist/DataActions/StoreOperationsDataActions.g";
+import { SpanStatusCode, trace } from "@opentelemetry/api";
 import jwt from "jsonwebtoken";
 import { uniq } from "lodash";
 import type {
 	CopyCartToWishlistInput,
+	CustomerBalances,
 	ExtendedWishlist,
+	GetCustomerBalanceInput,
 	User,
 	UserCounts,
 	Wishlist,
@@ -51,6 +55,8 @@ function decodeIdTokenClaims(token: string): IdTokenClaims {
 	return decoded as IdTokenClaims;
 }
 
+const tracer = trace.getTracer("d365-user-datasource");
+
 class D365UserDatasource extends D365DatasourceBase implements UserApi {
 	private getRetailContext(context: ICallerContext): IContext {
 		return context as unknown as IContext;
@@ -93,34 +99,102 @@ class D365UserDatasource extends D365DatasourceBase implements UserApi {
 	}
 
 	async getUser(): Promise<User | null> {
-		const context = this.context;
-		if (!context.requestContext.user.isAuthenticated) return null;
-		let customer: Customer;
-		try {
-			customer = await readAsync(this.getRetailContext(context), "");
-		} catch {
-			const token = decodeIdTokenClaims(context.requestContext.user.token);
-			customer = await createCustomerAsync(this.getRetailContext(context), {
-				AccountNumber: "",
-				Email: Array.isArray(token.emails) ? token.emails[0] : token.email,
-				FirstName: token.given_name,
-				LastName: token.family_name || ".",
-			});
-		}
-		const mappedAddresses = (customer.Addresses ?? []).map((a) => ({
-			...a,
-			Id: a.RecordId?.toString() ?? "",
-		}));
-		return {
-			...customer,
-			Addresses: mappedAddresses,
-		} as User;
+		return tracer.startActiveSpan("d365.getUser", async (span) => {
+			try {
+				const context = this.context;
+				if (!context.requestContext.user.isAuthenticated) {
+					span.setAttributes({ "d365.user.authenticated": false });
+					span.setStatus({ code: SpanStatusCode.OK });
+					return null;
+				}
+
+				let customer: Customer;
+				try {
+					customer = await readAsync(this.getRetailContext(context), "");
+				} catch {
+					const token = decodeIdTokenClaims(context.requestContext.user.token);
+					customer = await createCustomerAsync(this.getRetailContext(context), {
+						AccountNumber: "",
+						Email: Array.isArray(token.emails) ? token.emails[0] : token.email,
+						FirstName: token.given_name,
+						LastName: token.family_name || ".",
+					});
+				}
+
+				const mappedAddresses = (customer.Addresses ?? []).map((a) => ({
+					...a,
+					Id: a.RecordId?.toString() ?? "",
+				}));
+
+				span.setAttributes({
+					"d365.user.authenticated": true,
+					"d365.user.account_number": customer.AccountNumber ?? "",
+					"d365.user.email": customer.Email ?? "",
+					"d365.user.first_name": customer.FirstName ?? "",
+					"d365.user.last_name": customer.LastName ?? "",
+					"d365.user.customer_type": customer.CustomerTypeValue ?? "",
+					"d365.user.record_id": customer.RecordId?.toString() ?? "",
+					"d365.user.address_count": mappedAddresses.length,
+				});
+				span.setStatus({ code: SpanStatusCode.OK });
+
+				return {
+					...customer,
+					Addresses: mappedAddresses,
+				} as User;
+			} catch (error) {
+				const message =
+					error instanceof Error ? error.message : JSON.stringify(error);
+				span.setStatus({ code: SpanStatusCode.ERROR, message });
+				span.recordException(
+					error instanceof Error ? error : new Error(message),
+				);
+				throw new Error(`getUser failed: ${message}`);
+			} finally {
+				span.end();
+			}
+		});
 	}
 
 	async getUserCounts(): Promise<UserCounts> {
 		throw new Error("Method not implemented.");
 	}
 
+	async getCustomerBalance(
+		input: GetCustomerBalanceInput,
+	): Promise<CustomerBalances> {
+		return tracer.startActiveSpan("d365.getCustomerBalance", async (span) => {
+			try {
+				const context = this.context;
+				const balances = await getCustomerBalanceAsync(
+					this.getRetailContext(context),
+					input.accountNumber,
+					input.invoiceAccountNumber,
+				);
+				span.setAttributes({
+					"d365.balance.account_number": input.accountNumber,
+					"d365.balance.credit_limit": balances.CreditLimit,
+					"d365.balance.invoice_account_balance":
+						balances.InvoiceAccountBalance,
+					"d365.balance.invoice_account_credit_limit":
+						balances.InvoiceAccountCreditLimit,
+				});
+				span.setStatus({ code: SpanStatusCode.OK });
+				return balances;
+			} catch (error) {
+				const message =
+					error instanceof Error ? error.message : JSON.stringify(error);
+				span.setStatus({ code: SpanStatusCode.ERROR, message });
+				span.recordException(
+					error instanceof Error ? error : new Error(message),
+				);
+				throw new Error(`getCustomerBalance failed: ${message}`);
+			} finally {
+				span.end();
+			}
+		});
+	}
+
 	async getWishlists(): Promise<Wishlist[]> {
 		const context = this.context;
 		const productListType = ProductListType.WishList;

package/src/api-manager/datasources/d365/d365.datasource.ts

@@ -18,6 +18,7 @@ import {
 } from "@evenicanpm/storefront-core/src/api-manager/types/Datasource";
 import type { ICallerContext } from "@msdyn365-commerce/retail-proxy";
 import { D365ProductDatasource } from ".";
+import D365InvoiceDatasource from "./d365-invoice.datasource";
 
 export class D365Datasource extends Datasource implements PrimaryDatasource {
 	user: UserApi;
@@ -28,6 +29,7 @@ export class D365Datasource extends Datasource implements PrimaryDatasource {
 	organization: OrganizationApi;
 	session: SessionApi;
 	cart: D365CartDatasource;
+	invoice: D365InvoiceDatasource;
 	constructor(name: string, context: ICallerContext) {
 		super(name);
 		this.cart = new D365CartDatasource(context);
@@ -38,6 +40,7 @@ export class D365Datasource extends Datasource implements PrimaryDatasource {
 		this.organization = new D365OrganizationDatasource(context);
 		this.session = new D365SessionDatasource(context);
 		this.user = new D365UserDatasource(context);
+		this.invoice = new D365InvoiceDatasource(context);
 	}
 	// Datasources
 }

package/src/api-manager/datasources/d365/utils/get-context-cookie.ts

@@ -1,8 +1,8 @@
 "use server";
 import type { ICallerContext } from "@msdyn365-commerce/retail-proxy";
-import { cookies } from "next/headers";
+import { cookies, headers as getHeaders } from "next/headers";
 import { getLocale } from "next-intl/server";
-import { manuallyRetrieveSessionCookie } from "@/auth/next-auth-cookie-manager";
+import { auth } from "@/auth/better-auth";
 
 /**
  * Retrieves the D365 context from the "D365Context" cookie, enriches it with the current session token,
@@ -21,14 +21,23 @@ import { manuallyRetrieveSessionCookie } from "@/auth/next-auth-cookie-manager";
 export async function getContextFromCookie(): Promise<ICallerContext> {
 	const cookieStore = await cookies();
 	const d365Context = cookieStore.get("D365Context");
-	const token = await manuallyRetrieveSessionCookie();
+	let accessToken = "";
+	try {
+		const tokens = await auth.api.getAccessToken({
+			headers: await getHeaders(),
+			body: { providerId: "entra-external-id" },
+		});
+		accessToken = tokens?.idToken || tokens?.accessToken || "";
+	} catch {
+		// User may not be authenticated — continue with empty token
+	}
 	const locale = await getLocale();
 	if (d365Context) {
 		const context = JSON.parse(d365Context.value) as ICallerContext;
 		context.requestContext.operationId = crypto.randomUUID();
 		context.requestContext.user = {
-			isAuthenticated: !!token?.accessToken,
-			token: token?.accessToken ?? "",
+			isAuthenticated: !!accessToken,
+			token: accessToken,
 		};
 		context.requestContext.locale = locale;
 		return context;

package/src/api-manager/datasources/e4/e4.datasource.ts

@@ -19,6 +19,15 @@ const E4Datasource: PrimaryDatasource = {
 	product,
 	organization,
 	categories,
+	// To be implemented in future iteration
+	invoice: {
+		getInvoices: async () => {
+			throw new Error("Method not implemented.");
+		},
+		getInvoiceDetails: async () => {
+			throw new Error("Method not implemented.");
+		},
+	},
 };
 
 export default E4Datasource;

package/src/api-manager/datasources/e4/middleware.ts

@@ -0,0 +1,35 @@
+import createGraphQLClient from "@evenicanpm/storefront-core/src/lib/create-graphql-client";
+import type { NextRequest, NextResponse } from "next/server";
+import { parse, splitCookiesString } from "set-cookie-parser";
+
+const setE4SessionCookies = async (
+	response: NextResponse,
+	request: NextRequest,
+) => {
+	const cookiesAlreadySet = request.cookies.get("storefront");
+	if (cookiesAlreadySet) return response;
+
+	const e4Api = await createGraphQLClient();
+
+	const session = await e4Api.e4ReadSessionCustomer();
+
+	const cookieString = session?.headers?.get("set-cookie");
+	if (!cookieString) return response;
+	const splitCookies = parse(
+		splitCookiesString(decodeURIComponent(cookieString)),
+	);
+
+	splitCookies.forEach((cookie) => {
+		response.cookies.set({
+			name: cookie.name,
+			value: cookie.value,
+			httpOnly: true,
+			expires: cookie.expires,
+			secure: true,
+		});
+	});
+
+	return response;
+};
+
+export default setE4SessionCookies;

package/src/api-manager/datasources/e4/order/e4-order.datasource.ts

@@ -5,17 +5,19 @@ import {
 import getGraphqlClient from "@evenicanpm/storefront-core/src/api-manager/lib/get-graphql-client";
 import type {
 	GetSalesOrderDetailsInput,
+	GetSalesOrdersInput,
 	SalesOrder,
-	SalesOrderInput,
 } from "@evenicanpm/storefront-core/src/api-manager/schemas/order.schema";
 import type { OrderApi } from "@evenicanpm/storefront-core/src/api-manager/types/Datasource";
 import { merge } from "object-mapper";
 
 const order: OrderApi = {
-	async getSalesOrders(input: SalesOrderInput): Promise<SalesOrder[]> {
+	async getSalesOrders(input: GetSalesOrdersInput): Promise<SalesOrder[]> {
 		const e4Api = await getGraphqlClient(true);
 
-		const { data, errors } = await e4Api.e4OrderListSM({ id: input?.id });
+		const { data, errors } = await e4Api.e4OrderListSM({
+			id: input?.orderSearchCriteria?.CustomerAccountNumber ?? "",
+		});
 
 		if (errors) {
 			throw new Error("Error getting orders");
@@ -30,9 +32,10 @@ const order: OrderApi = {
 		input: GetSalesOrderDetailsInput,
 	): Promise<SalesOrder> {
 		const e4Api = await getGraphqlClient(true);
+		if (!input?.transactionId) throw new Error("transactionId is required");
 
 		const { data, errors } = await e4Api.e4OrderReadMD({
-			id: input?.transactionId,
+			id: input.transactionId,
 		});
 
 		if (errors) {

package/src/api-manager/datasources/e4/user/e4-user.datasource.ts

@@ -138,6 +138,10 @@ const user: UserApi = {
 	async copyCartToWishlist(_input: CopyCartToWishlistInput): Promise<Wishlist> {
 		throw new Error("copyCartToWishlist not implemented");
 	},
+
+	async getCustomerBalance(_input) {
+		throw new Error("getCustomerBalance not implemented");
+	},
 };
 
 export default user;

package/src/api-manager/index.ts

@@ -1,23 +1,74 @@
 import { D365Datasource } from "@evenicanpm/storefront-core/src/api-manager/datasources/d365/index";
 import { getContextFromCookie } from "@evenicanpm/storefront-core/src/api-manager/datasources/d365/utils/get-context-cookie";
 import E4Datasource from "@evenicanpm/storefront-core/src/api-manager/datasources/e4/e4.datasource";
-import type { Datasource } from "@evenicanpm/storefront-core/src/api-manager/types/Datasource";
+import type {
+	Datasource,
+	DatasourceApis,
+	SecondaryDatasource,
+} from "@evenicanpm/storefront-core/src/api-manager/types/Datasource";
+
+const OVERRIDES_FILE = "./overrides.datasource.ts";
 
 /**
  * Returns the active commerce datasource based on the API_MANAGER_PRIMARY
  * environment variable. Defaults to "e4" when the variable is not set.
  *
+ * Supports project-level function overrides via
+ * src/extensions/api-manager-overrides/overrides.datasource.ts
+ *
  * Supported values: "e4" | "d365"
  */
 async function createApiManager(): Promise<Datasource> {
 	const primary = process.env.API_MANAGER_PRIMARY ?? "e4";
 
+	let datasource: Datasource;
 	if (primary === "d365") {
 		const context = await getContextFromCookie();
-		return new D365Datasource("d365", context);
+		datasource = new D365Datasource("d365", context);
+	} else {
+		datasource = E4Datasource;
+	}
+
+	const storefrontOverrides: { [key: string]: any } = {};
+
+	// @ts-expect-error
+	function importAll(r) {
+		r.keys().forEach((key: string) => {
+			storefrontOverrides[key] = r(key);
+		});
+	}
+
+	// Arguments must be literals not variables.
+	importAll(
+		// @ts-expect-error
+		require.context(
+			"@storefront/extensions/api-manager-overrides",
+			true,
+			/overrides\.datasource\.ts/,
+		),
+	);
+
+	const projectOverrides: SecondaryDatasource | undefined =
+		storefrontOverrides[OVERRIDES_FILE]?.default;
+
+	if (projectOverrides) {
+		for (const entityName of Object.keys(projectOverrides) as Array<
+			keyof DatasourceApis
+		>) {
+			const entityOverrides = projectOverrides[entityName];
+			if (!entityOverrides) continue;
+
+			if (datasource[entityName]) {
+				// Merge override methods into the existing entity
+				Object.assign(datasource[entityName] as object, entityOverrides);
+			} else {
+				// Non-core entity added entirely from overrides
+				(datasource as any)[entityName] = entityOverrides;
+			}
+		}
 	}
 
-	return E4Datasource;
+	return datasource;
 }
 
 export default createApiManager;

package/src/api-manager/lib/get-graphql-client.ts

@@ -2,9 +2,8 @@
 
 import { getSdk } from "@evenicanpm/storefront-core/src/api-manager/datasources/e4/graphqlRequestSdk";
 import { GraphQLClient } from "graphql-request";
-import { cookies } from "next/headers";
-import { getServerSession } from "next-auth/next";
-import authOptions from "@/auth/auth-options";
+import { cookies, headers as getHeaders } from "next/headers";
+import { auth } from "@/auth/better-auth";
 
 /**
  * Initializes and returns a cached GraphQL client
@@ -28,9 +27,17 @@ const getGraphQLClient = async (withAuth = false) => {
 	}
 
 	if (withAuth) {
-		const session = await getServerSession(authOptions());
-		if (session?.accessToken) {
-			headers.Authorization = `Bearer ${session.accessToken}`;
+		try {
+			const tokens = await auth.api.getAccessToken({
+				headers: await getHeaders(),
+				body: { providerId: "entra-external-id" },
+			});
+			const accessToken = tokens?.idToken || tokens?.accessToken;
+			if (accessToken) {
+				headers.Authorization = `Bearer ${accessToken}`;
+			}
+		} catch {
+			// User may not be authenticated — continue without auth header
 		}
 	}
 

package/src/api-manager/schemas/cart.schema.ts

@@ -54,9 +54,10 @@ export const getCardAcceptPointInput = z.object({
 export const checkoutInput = z.object({
 	id: z.string(),
 	receiptEmail: z.string(),
-	tokenizedPaymentCard: tokenizedPaymentCardSchema,
+	tokenizedPaymentCard: tokenizedPaymentCardSchema.optional(),
 	currency: z.string(),
 	amount: z.number(),
+	paymentMethod: z.enum(["card", "on-account"]).default("card"),
 });
 
 export const updateCartLineDeliveryModeInput = z.object({
@@ -82,6 +83,13 @@ const InventorySearchCartLinesCriteriaInput = z.object({
 	allDimensionsSelected: z.boolean(),
 });
 
+export const updateInvoiceLineInput = z.object({
+	cartId: z.string(),
+	cartLineId: z.string(),
+	price: z.number(),
+	version: z.number().optional(),
+});
+
 // Typescript Types
 // export type Cart = z.infer<typeof cartSchema>;
 // export type CartLine = z.infer<typeof cartLineSchema>;
@@ -108,3 +116,4 @@ export type CheckoutInput = z.infer<typeof checkoutInput>;
 export type InventorySearchCartLinesCriteriaInput = z.infer<
 	typeof InventorySearchCartLinesCriteriaInput
 >;
+export type UpdateInvoiceLineInput = z.infer<typeof updateInvoiceLineInput>;

package/src/api-manager/schemas/invoice.schema.ts

@@ -0,0 +1,55 @@
+export interface InvoiceSearchCriteria {
+	InvoiceIds?: string[];
+	CustomerId?: string;
+	BusinessPartnerId?: string;
+	InvoiceTypeValues?: number[];
+	InvoicePaidStatusValues?: number[];
+}
+
+export interface GetInvoicesInput {
+	InvoiceSearchCriteria: InvoiceSearchCriteria;
+}
+
+export interface InvoiceDetailsSearchCriteria {
+	InvoiceId?: string;
+}
+
+export interface GetInvoicesDetailsInput {
+	InvoiceSearchCriteria: InvoiceDetailsSearchCriteria;
+}
+
+export interface SalesInvoiceLine {
+	ItemId?: string;
+	Description?: string;
+	Quantity?: number;
+	Price?: number;
+	NetAmount?: number;
+	LineDiscount?: number;
+}
+
+export interface Invoice {
+	Id?: string;
+	CustomerName?: string;
+	CustomerAccountNumber?: string;
+	TotalAmount?: number;
+	InvoiceDate?: Date;
+	InvoiceDueDate?: Date;
+	InvoicePaidStatusValue?: number;
+	AmountPaid?: number;
+	AmountBalance?: number;
+	CurrencyCode?: string;
+}
+
+export interface InvoiceDetails {
+	Id?: string;
+	AmountBalance?: number;
+	AmountPaid?: number;
+	DueDate?: Date;
+	SalesInvoiceLine?: SalesInvoiceLine[];
+	OrderedByCustomerName?: string;
+	Name?: string;
+	InvoiceDate?: Date;
+	InvoiceSubtotal?: number;
+	TotalTaxAmount?: number;
+	Amount?: number;
+}

package/src/api-manager/schemas/order.schema.ts

@@ -1,13 +1,17 @@
 import {
+	orderSearchCriteriaSchema,
+	pagingInfoSchema,
 	salesLineSchema,
 	salesOrderSchema,
 	searchLocationSchema,
 	simpleProductSchema,
+	sortColumnSchema,
 } from "@evenicanpm/storefront-core/src/api-manager/schemas/d365.schema";
 import z from "zod";
 
 const getSalesOrderDetailsInput = z.object({
-	transactionId: z.string(),
+	transactionId: z.string().optional(),
+	salesId: z.string().optional(),
 	searchLocation: searchLocationSchema.optional(),
 });
 
@@ -22,9 +26,17 @@ const extendedSalesOrderSchema = salesOrderSchema
 	.omit({ SalesLines: true })
 	.extend({ SalesLines: extendedSalesLineSchema.array().optional() });
 
+const getSalesOrdersInput = z.object({
+	orderSearchCriteria: orderSearchCriteriaSchema,
+	sort: sortColumnSchema.optional(),
+	paging: pagingInfoSchema.optional(),
+});
+
 export type GetSalesOrderDetailsInput = z.infer<
 	typeof getSalesOrderDetailsInput
 >;
+export type GetSalesOrdersInput = z.infer<typeof getSalesOrdersInput>;
+
 export type SalesOrderInput = z.infer<typeof salesOrderInput>;
 export type SalesOrder = z.infer<typeof extendedSalesOrderSchema>;
 export type SalesLine = z.infer<typeof extendedSalesLineSchema>;

package/src/api-manager/schemas/user.schema.ts

@@ -1,4 +1,5 @@
 import {
+	type customerBalancesSchema,
 	customerSchema,
 	productListLineSchema,
 	productListSchema,
@@ -17,6 +18,13 @@ export const extendedCustomerSchema = customerSchema.extend({
 
 export type User = z.infer<typeof extendedCustomerSchema>;
 export type UserCounts = z.infer<typeof userCountsSchema>;
+export type CustomerBalances = z.infer<typeof customerBalancesSchema>;
+
+export const getCustomerBalanceInput = z.object({
+	accountNumber: z.string(),
+	invoiceAccountNumber: z.string().optional(),
+});
+export type GetCustomerBalanceInput = z.infer<typeof getCustomerBalanceInput>;
 
 // Wishlist
 

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

@@ -7,14 +7,9 @@ import {
 	useQuery,
 	useSuspenseQuery,
 } from "@tanstack/react-query";
-import { Mutex } from "async-mutex";
-import jwt from "jsonwebtoken";
-import { getSession } from "next-auth/react";
-import { manuallyRetrieveSessionCookie } from "@/auth/next-auth-cookie-manager";
 import signOut from "@/auth/signout";
 
 const QUERY_ROUTE = "/api";
-const mutex = new Mutex();
 
 export type ApiPath<T extends keyof DatasourceApis = keyof DatasourceApis> = [
 	T,
@@ -27,22 +22,6 @@ export type Query<TInput, TOutput> = ReturnType<
 
 // --- Shared helpers (no closure dependencies) ---
 
-const checkTokenExpiry = async (): Promise<boolean> => {
-	let token: string | undefined;
-	if (isServer) {
-		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 currentTime = Math.floor(Date.now() / 1000);
-	return (
-		!!decoded && typeof decoded.exp === "number" && decoded.exp < currentTime
-	);
-};
-
 const doFetch = async <TInput>(
 	input: TInput | undefined,
 	apiManagerPath: ApiPath,
@@ -60,27 +39,6 @@ const doFetch = async <TInput>(
 	return result.json();
 };
 
-// Acquires a mutex before fetching so concurrent requests don't each trigger
-// a token refresh simultaneously (double-check pattern after acquiring lock).
-const withTokenRefresh = async <TInput>(
-	input: TInput | undefined,
-	apiManagerPath: ApiPath,
-) => {
-	const release = await mutex.acquire();
-	try {
-		const headers = new Headers();
-		if (await checkTokenExpiry()) {
-			headers.append("should-refresh-token", "true");
-		}
-		return await doFetch(input, apiManagerPath, headers);
-	} catch (error) {
-		console.error("Error fetching data:", error);
-		throw new Error("Failed to fetch data");
-	} finally {
-		release();
-	}
-};
-
 // --- Factory ---
 
 export const createQuery = <TInput, TOutput>(
@@ -103,10 +61,7 @@ export const createQuery = <TInput, TOutput>(
 					return getApiFromPath(apiManager, apiManagerPath)(input);
 				}
 			: async () => {
-					const isExpired = await checkTokenExpiry();
-					return isExpired
-						? withTokenRefresh(input, apiManagerPath)
-						: doFetch(input, apiManagerPath);
+					return await doFetch(input, apiManagerPath);
 				},
 		enabled: config?.disableProperties
 			? config.disableProperties.every((prop) => !!input?.[prop])
@@ -118,7 +73,10 @@ export const createQuery = <TInput, TOutput>(
 			input?: TInput,
 			options?: { enabled: boolean },
 		): UseQueryResult<TOutput> =>
-			useQuery({ ...getQueryOptions(input), enabled: options?.enabled }),
+			useQuery({
+				...getQueryOptions(input),
+				...(options?.enabled !== undefined && { enabled: options.enabled }),
+			}),
 		useSuspenseData: (input?: TInput): UseSuspenseQueryResult<TOutput> =>
 			useSuspenseQuery(getQueryOptions(input)),
 		fetchData: (queryClient: QueryClient, input?: TInput) =>
@@ -142,15 +100,6 @@ export function getApiFromPath<TInput, TOutput>(
 	const [entity, method] = path;
 	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,
-		});
-	}
-
 	// Function reference loses 'this' context — re-bind for d365 classes.
 	if (typeof result === "function") {
 		return (result as (input?: TInput) => Promise<TOutput>).bind(