@evenicanpm/storefront-core 2.2.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

@@ -21,9 +21,16 @@ import { auth } from "@/auth/better-auth";
 export async function getContextFromCookie(): Promise<ICallerContext> {
 	const cookieStore = await cookies();
 	const d365Context = cookieStore.get("D365Context");
-	const session = await auth.api.getSession({ headers: await getHeaders() });
-	const accessToken =
-		(session?.session as { accessToken?: string })?.accessToken || "";
+	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;

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/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

@@ -27,11 +27,17 @@ const getGraphQLClient = async (withAuth = false) => {
 	}
 
 	if (withAuth) {
-		const session = await auth.api.getSession({ headers: await getHeaders() });
-		const accessToken = (session?.session as { accessToken?: string })
-			?.accessToken;
-		if (accessToken) {
-			headers.Authorization = `Bearer ${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

@@ -73,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) =>
@@ -97,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(

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

@@ -0,0 +1,18 @@
+import type { GetInvoicesDetailsInput } from "@evenicanpm/storefront-core/src/api-manager/schemas/invoice.schema";
+import {
+	createApiPath,
+	createQuery,
+} from "@evenicanpm/storefront-core/src/api-manager/services/create-query";
+import type { SalesInvoice } from "@msdyn365-commerce/retail-proxy/dist";
+
+const apiPath = createApiPath("invoice", "getInvoiceDetails");
+const config = {
+	queryKey: "invoices",
+};
+
+const getInvoices = createQuery<GetInvoicesDetailsInput, SalesInvoice>(
+	apiPath,
+	config,
+);
+
+export default getInvoices;

package/src/api-manager/services/invoice/queries/get-invoices.ts

@@ -0,0 +1,18 @@
+import {
+	createApiPath,
+	createQuery,
+} from "@evenicanpm/storefront-core/src/api-manager/services/create-query";
+import type { OrderInvoice } from "@msdyn365-commerce/retail-proxy/dist";
+import type { GetInvoicesInput } from "../../../schemas/invoice.schema";
+
+const apiPath = createApiPath("invoice", "getInvoices");
+const config = {
+	queryKey: "invoices",
+};
+
+const getInvoices = createQuery<GetInvoicesInput, OrderInvoice[]>(
+	apiPath,
+	config,
+);
+
+export default getInvoices;

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

@@ -9,7 +9,7 @@ import {
 
 const apiPath = createApiPath("order", "getSalesOrderDetails");
 const config = {
-	queryKey: "salesOrderDetails",
+	queryKey: "salesOrders",
 };
 
 const getOrderDetails = createQuery<GetSalesOrderDetailsInput, SalesOrder>(

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

@@ -1,6 +1,6 @@
 import type {
+	GetSalesOrdersInput,
 	SalesOrder,
-	SalesOrderInput,
 } from "@evenicanpm/storefront-core/src/api-manager/schemas/order.schema";
 import {
 	createApiPath,
@@ -9,9 +9,12 @@ import {
 
 const apiPath = createApiPath("order", "getSalesOrders");
 const config = {
-	queryKey: "salesOrderDetails",
+	queryKey: "SalesOrders",
 };
 
-const getOrders = createQuery<SalesOrderInput, SalesOrder[]>(apiPath, config);
+const getOrders = createQuery<GetSalesOrdersInput, SalesOrder[]>(
+	apiPath,
+	config,
+);
 
 export default getOrders;

package/src/api-manager/services/user/queries/get-customer-balance.ts

@@ -0,0 +1,20 @@
+import type {
+	CustomerBalances,
+	GetCustomerBalanceInput,
+} from "@evenicanpm/storefront-core/src/api-manager/schemas/user.schema";
+import {
+	createApiPath,
+	createQuery,
+} from "@evenicanpm/storefront-core/src/api-manager/services/create-query";
+
+const apiPath = createApiPath("user", "getCustomerBalance");
+
+const getCustomerBalance = createQuery<
+	GetCustomerBalanceInput,
+	CustomerBalances
+>(apiPath, {
+	queryKey: "customerBalance",
+	disableProperties: ["accountNumber"],
+});
+
+export default getCustomerBalance;