@unchainedshop/api 4.0.0-rc.9 → 4.0.1

package/src/resolvers/queries/shopInfo.ts

@@ -1,3 +1,4 @@
+import { readFile } from 'fs/promises';
 import { Context } from '../../context.js';
 import { log } from '@unchainedshop/logger';
 
@@ -10,22 +11,70 @@ export default function shopInfo(
   adminUiConfig?: Record<string, any>;
   vapidPublicKey?: string;
 } {
-  const { adminUiConfig } = context;
+  const { adminUiConfig, modules } = context;
   log('query shopInfo', { userId: context.userId });
 
   return {
     version: context.version,
     adminUiConfig: {
-      customProperties: adminUiConfig?.customProperties ?? [],
-      singleSignOnURL: adminUiConfig?.singleSignOnURL,
+      customProperties: async () => {
+        try {
+          if (!process.env.UNCHAINED_ADMIN_UI_CUSTOM_PROPERTIES)
+            return adminUiConfig?.customProperties ?? [];
+          const raw = await readFile(process.env.UNCHAINED_ADMIN_UI_CUSTOM_PROPERTIES, 'utf-8');
+          const parsed = JSON.parse(raw);
+          return parsed;
+        } catch {
+          return adminUiConfig?.customProperties ?? [];
+        }
+      },
+      singleSignOnURL:
+        process.env.UNCHAINED_ADMIN_UI_SINGLE_SIGN_ON_URL || adminUiConfig?.singleSignOnURL,
       externalLinks: () => {
         try {
+          if (!process.env.EXTERNAL_LINKS) return [];
           const parsed = JSON.parse(process.env.EXTERNAL_LINKS);
           return parsed;
         } catch {
           return [];
         }
       },
+      productTags: async () => {
+        const existingProductTags = await modules.products.existingTags();
+        const envTags = (process.env.UNCHAINED_ADMIN_UI_DEFAULT_PRODUCT_TAGS || '')
+          .split(',')
+          .map((t) => t.trim())
+          .filter(Boolean);
+        const normalizedDefaultTags = envTags?.length
+          ? envTags
+          : (adminUiConfig?.defaultProductTags || []).filter(Boolean);
+        const normalizedTags = Array.from(new Set(normalizedDefaultTags.concat(existingProductTags)));
+        return normalizedTags;
+      },
+      assortmentTags: async () => {
+        const existingAssortmentTags = await modules.assortments.existingTags();
+        const envTags = (process.env.UNCHAINED_ADMIN_UI_DEFAULT_ASSORTMENT_TAGS || '')
+          .split(',')
+          .map((t) => t.trim())
+          .filter(Boolean);
+        const normalizedDefaultTags = envTags?.length
+          ? envTags
+          : (adminUiConfig?.defaultAssortmentTags || []).filter(Boolean);
+        const normalizedTags = Array.from(new Set(normalizedDefaultTags.concat(existingAssortmentTags)));
+        return normalizedTags;
+      },
+      userTags: async () => {
+        const existingUserTags = await modules.users.existingTags();
+        const envTags = (process.env.UNCHAINED_ADMIN_UI_DEFAULT_USER_TAGS || '')
+          .split(',')
+          .map((t) => t.trim())
+          .filter(Boolean);
+        const normalizedDefaultTags = envTags?.length
+          ? envTags
+          : (adminUiConfig?.defaultUserTags || []).filter(Boolean);
+        const normalizedTags = Array.from(new Set(normalizedDefaultTags.concat(existingUserTags)));
+        return normalizedTags;
+      },
     },
     vapidPublicKey: process.env?.PUSH_NOTIFICATION_PUBLIC_KEY,
   };

package/src/resolvers/queries/users/user.ts

@@ -6,7 +6,7 @@ export default async function user(
   params: { userId?: string },
   { modules, userId }: Context,
 ) {
-  log(`query user ${params.userId}`, { Id: userId });
+  log(`query user ${params.userId}`, { self: userId });
 
-  return modules.users.findUserById(params.userId || userId);
+  return modules.users.findUserById(params.userId || userId!);
 }

package/src/resolvers/queries/warehousing/tokens.ts

@@ -4,7 +4,7 @@ import { Context } from '../../../context.js';
 export default async function tokens(
   root: never,
   {
-    queryString = null,
+    queryString,
     limit = 10,
     offset = 0,
   }: {

package/src/resolvers/queries/warehousing/warehousingInterfaces.ts

@@ -9,10 +9,12 @@ export default async function warehousingInterfaces(
   { userId }: Context,
 ) {
   log(`query warehousingInterfaces ${type}`, { userId });
+  const allAdapters = await WarehousingDirector.getAdapters();
+  const filteredAdapters = type
+    ? allAdapters.filter((Adapter) => Adapter.typeSupported(type as WarehousingProviderType))
+    : allAdapters;
 
-  return WarehousingDirector.getAdapters({
-    adapterFilter: (Adapter) => Adapter.typeSupported(type),
-  }).map((Adapter) => ({
+  return filteredAdapters.map((Adapter) => ({
     _id: Adapter.key,
     label: Adapter.label,
     version: Adapter.version,

package/src/resolvers/type/country-types.ts

@@ -7,8 +7,8 @@ export type HelperType<P, T> = (country: CountryType, params: P, context: Contex
 export interface CountryHelperTypes {
   flagEmoji: HelperType<never, string>;
   isBase: HelperType<never, boolean>;
-  name: HelperType<{ forceLocale?: string }, string>;
-  defaultCurrency: HelperType<never, Promise<Currency>>;
+  name: HelperType<{ forceLocale?: string }, string | undefined>;
+  defaultCurrency: HelperType<never, Promise<Currency | null>>;
 }
 
 export const Country: CountryHelperTypes = {

package/src/resolvers/type/delivery-provider-types.ts

@@ -48,7 +48,7 @@ export const DeliveryProvider = {
       provider: deliveryProvider,
       order,
       providerContext,
-      user,
+      user: user!,
     };
 
     const calculated = await DeliveryPricingDirector.rebuildCalculation(pricingContext, requestContext);

package/src/resolvers/type/enrollment/enrollment-delivery-types.ts

@@ -3,6 +3,7 @@ import { Enrollment } from '@unchainedshop/core-enrollments';
 
 export const EnrollmentDelivery = {
   provider: async ({ deliveryProviderId }: Enrollment['delivery'], _: never, { loaders }: Context) => {
+    if (!deliveryProviderId) return null;
     return loaders.deliveryProviderLoader.load({
       deliveryProviderId,
     });

package/src/resolvers/type/enrollment/enrollment-payment-types.ts

@@ -2,9 +2,10 @@ import { Context } from '../../../context.js';
 import { Enrollment } from '@unchainedshop/core-enrollments';
 
 export const EnrollmentPayment = {
-  provider: async ({ paymentProviderId }: Enrollment['payment'], _: never, { loaders }: Context) => {
+  provider: async (payment: Enrollment['payment'], _: never, { loaders }: Context) => {
+    if (!payment?.paymentProviderId) return null;
     return loaders.paymentProviderLoader.load({
-      paymentProviderId,
+      paymentProviderId: payment.paymentProviderId,
     });
   },
 };

package/src/resolvers/type/enrollment/enrollment-period-types.ts

@@ -3,6 +3,7 @@ import { EnrollmentPeriod as EnrollmentPeriodType } from '@unchainedshop/core-en
 
 export const EnrollmentPeriod = {
   async order(period: EnrollmentPeriodType, _: never, { loaders }: Context) {
+    if (!period.orderId) return null;
     return loaders.orderLoader.load({ orderId: period.orderId });
   },
 };

package/src/resolvers/type/enrollment/enrollment-types.ts

@@ -15,9 +15,9 @@ export const Enrollment = {
   },
 
   country: async (obj: EnrollmentType, _: never, { loaders }: Context) =>
-    loaders.currencyLoader.load({ isoCode: obj.countryCode }),
+    obj.countryCode ? loaders.currencyLoader.load({ isoCode: obj.countryCode }) : null,
   currency: async (obj: EnrollmentType, _: never, { loaders }: Context) =>
-    loaders.currencyLoader.load({ isoCode: obj.currencyCode }),
+    obj.currencyCode ? loaders.currencyLoader.load({ isoCode: obj.currencyCode }) : null,
   user: async (obj: EnrollmentType, _: never, { loaders }: Context) =>
     loaders.userLoader.load({ userId: obj.userId }),
 };

package/src/resolvers/type/index.ts

@@ -6,7 +6,6 @@ import { AssortmentPathLink } from './assortment/assortment-path-link-types.js';
 import { AssortmentProduct } from './assortment/assortment-product-types.js';
 import { Bookmark } from './bookmark-types.js';
 import { BundleProduct } from './product/product-bundle-types.js';
-import { Color } from './color-types.js';
 import { ConfigurableProduct } from './product/product-configurable-types.js';
 import { Country } from './country-types.js';
 import { Currency } from './currency-types.js';
@@ -67,6 +66,7 @@ import { Token } from './token-types.js';
 import { Web3Address } from './web3-address.js';
 import { LoginMethodResponse } from './login-method-response-types.js';
 import { ProductSearchResult } from './product-search-result-types.js';
+import { OrderStatistics } from './order/order-statistics-types.js';
 
 const types = {
   Assortment,
@@ -77,7 +77,6 @@ const types = {
   AssortmentProduct,
   Bookmark,
   BundleProduct,
-  Color,
   ConfigurableProduct,
   Country,
   Currency,
@@ -138,6 +137,7 @@ const types = {
   Media,
   Web3Address,
   LoginMethodResponse,
+  OrderStatistics,
 };
 
 export default types;

package/src/resolvers/type/media-types.ts

@@ -2,8 +2,11 @@ import { File as FileType, getFileAdapter } from '@unchainedshop/core-files';
 import { Context } from '../../context.js';
 import { checkAction } from '../../acl.js';
 import { actions } from '../../roles/index.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:api');
 export interface MediaHelperTypes {
-  url: (language: FileType, params: Record<string, any>, context: Context) => Promise<string>;
+  url: (language: FileType, params: Record<string, any>, context: Context) => Promise<string | null>;
 }
 
 export const Media: MediaHelperTypes = {
@@ -14,9 +17,10 @@ export const Media: MediaHelperTypes = {
       if (!file) return null;
       const fileUploadAdapter = getFileAdapter();
       const url = await fileUploadAdapter.createDownloadURL(file, params?.expires);
+      if (!url) throw new Error('Could not create download URL');
       return modules.files.normalizeUrl(url, params);
     } catch (e) {
-      console.error(e);
+      logger.error(e);
       return null;
     }
   },

package/src/resolvers/type/order/order-item-types.ts

@@ -38,13 +38,14 @@ export const OrderItem = {
     _: never,
     { modules, loaders }: Context,
   ): Promise<
-    {
-      _id: string;
-      deliveryProvider: DeliveryProvider;
-      warehousingProvider: WarehousingProvider;
-      shipping: Date;
-      earliestDelivery: Date;
-    }[]
+    | {
+        _id: string;
+        deliveryProvider: DeliveryProvider;
+        warehousingProvider: WarehousingProvider;
+        shipping: Date;
+        earliestDelivery: Date;
+      }[]
+    | null
   > {
     const scheduling = orderPosition.scheduling || [];
     const order = await loaders.orderLoader.load({
@@ -52,9 +53,13 @@ export const OrderItem = {
     });
     const { countryCode, userId } = order;
 
-    const orderDelivery = await modules.orders.deliveries.findDelivery({
-      orderDeliveryId: order.deliveryId,
-    });
+    const orderDelivery =
+      order.deliveryId &&
+      (await modules.orders.deliveries.findDelivery({
+        orderDeliveryId: order.deliveryId,
+      }));
+
+    if (!orderDelivery) return null;
 
     const deliveryProvider = await loaders.deliveryProviderLoader.load({
       deliveryProviderId: orderDelivery.deliveryProviderId,
@@ -63,6 +68,8 @@ export const OrderItem = {
       productId: orderPosition.productId,
     });
 
+    if (!deliveryProvider || !product) return null;
+
     return Promise.all(
       scheduling.map(async (schedule) => {
         // TODO: use warehousing provider loader
@@ -107,7 +114,7 @@ export const OrderItem = {
     return product;
   },
 
-  async quotation(orderPosition: OrderPosition, _, { modules }: Context): Promise<Quotation> {
+  async quotation(orderPosition: OrderPosition, _, { modules }: Context): Promise<Quotation | null> {
     if (!orderPosition.quotationId) return null;
     // TODO: use quotation loader
     return modules.quotations.findQuotation({ quotationId: orderPosition.quotationId });
@@ -117,7 +124,7 @@ export const OrderItem = {
     orderPosition: OrderPosition,
     params: { category: string; useNetPrice: boolean },
     context: Context,
-  ): Promise<Price> {
+  ): Promise<Price | null> {
     const pricing = await getPricingSheet(orderPosition, context);
 
     if (pricing.isValid()) {
@@ -130,7 +137,7 @@ export const OrderItem = {
     orderPosition: OrderPosition,
     params: { useNetPrice: boolean },
     context: Context,
-  ): Promise<Price> {
+  ): Promise<Price | null> {
     const pricing = await getPricingSheet(orderPosition, context);
 
     if (pricing.isValid()) {

package/src/resolvers/type/order/order-payment-types.ts

@@ -5,7 +5,6 @@ import { objectInvert } from '@unchainedshop/utils';
 
 const OrderPaymentMap = {
   OrderPaymentGeneric: PaymentProviderType.GENERIC,
-  OrderPaymentCard: PaymentProviderType.CARD,
   OrderPaymentInvoice: PaymentProviderType.INVOICE,
 };
 

package/src/resolvers/type/order/order-statistics-types.ts

@@ -0,0 +1,99 @@
+import { mongodb } from '@unchainedshop/mongodb';
+import { Context } from '../../../context.js';
+
+function buildDateMatch(dateField: string, dateRange?: { start?: string; end?: string }) {
+  if (!dateRange?.start && !dateRange?.end) return { [dateField]: { $exists: true } };
+
+  const rangeMatch: Record<string, any> = {};
+  if (dateRange?.start) rangeMatch.$gte = new Date(dateRange.start);
+  if (dateRange?.end) rangeMatch.$lte = new Date(dateRange.end);
+
+  return { [dateField]: rangeMatch };
+}
+
+async function aggregateOrders(
+  modules: Context['modules'],
+  dateField: string,
+  dateRange?: { start?: string; end?: string },
+  options?: { includeAmount?: boolean; includeCarts?: boolean },
+) {
+  const match: mongodb.BSON.Document = buildDateMatch(dateField, dateRange);
+  const pipeline: mongodb.BSON.Document[] = [{ $match: match }];
+
+  if (options?.includeCarts) {
+    match.status = null;
+    match.orderNumber = null;
+  }
+
+  if (options?.includeAmount) {
+    pipeline.push({
+      $addFields: {
+        orderTotal: {
+          $reduce: {
+            input: { $ifNull: ['$calculation', []] },
+            initialValue: 0,
+            in: { $add: ['$$value', { $ifNull: ['$$this.amount', 0] }] },
+          },
+        },
+      },
+    });
+
+    pipeline.push({
+      $group: {
+        _id: {
+          date: { $dateToString: { format: '%Y-%m-%d', date: `$${dateField}` } },
+          currency: '$currencyCode',
+        },
+        totalAmount: { $sum: '$orderTotal' },
+        count: { $sum: 1 },
+      },
+    });
+
+    pipeline.push({
+      $project: {
+        _id: 0,
+        date: '$_id.date',
+        total: { amount: '$totalAmount', currencyCode: '$_id.currency' },
+        count: 1,
+      },
+    });
+
+    pipeline.push({ $sort: { date: 1 } });
+    return modules.orders.aggregateOrders({ pipeline });
+  }
+  // Just count total orders
+  pipeline.push({ $count: 'count' });
+  const result = await modules.orders.aggregateOrders({ pipeline });
+  return result[0]?.count ?? 0;
+}
+export const OrderStatistics = {
+  newCount: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'created', dateRange, { includeCarts: true }),
+
+  checkoutCount: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'ordered', dateRange),
+
+  rejectCount: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'rejected', dateRange),
+
+  confirmCount: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'confirmed', dateRange),
+
+  fulfillCount: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'fullfilled', dateRange),
+
+  newRecords: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'created', dateRange, { includeAmount: true, includeCarts: true }),
+
+  checkoutRecords: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'ordered', dateRange, { includeAmount: true }),
+
+  rejectRecords: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'rejected', dateRange, { includeAmount: true }),
+
+  confirmRecords: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'confirmed', dateRange, { includeAmount: true }),
+
+  fulfilledRecords: async ({ dateRange }, _p, { modules }: Context) =>
+    aggregateOrders(modules, 'fullfilled', dateRange, { includeAmount: true }),
+};

package/src/resolvers/type/order/order-types.ts

@@ -39,16 +39,23 @@ export const Order = {
     return modules.orders.discounts.findOrderDiscounts({ orderId: order._id });
   },
 
-  async delivery(order: OrderType, _, { modules }: Context): Promise<OrderDelivery> {
-    return modules.orders.deliveries.findDelivery({
-      orderDeliveryId: order.deliveryId,
-    });
+  async delivery(order: OrderType, _, { modules }: Context): Promise<OrderDelivery | null> {
+    const orderDelivery =
+      order.deliveryId &&
+      modules.orders.deliveries.findDelivery({
+        orderDeliveryId: order.deliveryId,
+      });
+
+    if (!orderDelivery) return null;
+    return orderDelivery;
   },
 
-  async enrollment(order: OrderType, _, { modules }: Context): Promise<Enrollment> {
-    return modules.enrollments.findEnrollment({
+  async enrollment(order: OrderType, _, { modules }: Context): Promise<Enrollment | null> {
+    const enrollment = await modules.enrollments.findEnrollment({
       orderId: order._id,
     });
+    if (!enrollment) return null;
+    return enrollment;
   },
 
   async items(order: OrderType, _, { modules }: Context): Promise<OrderPosition[]> {
@@ -57,10 +64,14 @@ export const Order = {
     });
   },
 
-  async payment(order: OrderType, _, { modules }: Context): Promise<OrderPayment> {
-    return modules.orders.payments.findOrderPayment({
-      orderPaymentId: order.paymentId,
-    });
+  async payment(order: OrderType, _, { modules }: Context): Promise<OrderPayment | null> {
+    const payment =
+      order.paymentId &&
+      (await modules.orders.payments.findOrderPayment({
+        orderPaymentId: order.paymentId,
+      }));
+    if (!payment) return null;
+    return payment;
   },
 
   status(order: OrderType): string {
@@ -70,7 +81,7 @@ export const Order = {
     return order.status;
   },
 
-  total(order: OrderType, params: { category: string; useNetPrice: boolean }): Price {
+  total(order: OrderType, params: { category: string; useNetPrice: boolean }): Price | null {
     const pricing = OrderPricingSheet({
       calculation: order.calculation,
       currencyCode: order.currencyCode,

package/src/resolvers/type/payment/payment-provider-types.ts

@@ -1,6 +1,6 @@
 import { Context } from '../../../context.js';
 import { PaymentProvider as PaymentProviderType } from '@unchainedshop/core-payment';
-import { PaymentDirector, PaymentPricingDirector } from '@unchainedshop/core';
+import { PaymentDirector, PaymentPricingContext, PaymentPricingDirector } from '@unchainedshop/core';
 
 export const PaymentProvider = {
   interface(provider: PaymentProviderType) {
@@ -32,7 +32,7 @@ export const PaymentProvider = {
 
     const order = await loaders.orderLoader.load({ orderId });
     const currencyCode = forcedCurrencyCode || order?.currencyCode || requestContext.currencyCode;
-    const pricingContext = {
+    const pricingContext: PaymentPricingContext = {
       countryCode,
       currencyCode,
       provider: paymentProvider,

package/src/resolvers/type/price-types.ts

@@ -1,5 +1,3 @@
-import accounting from 'accounting';
-
 export interface PriceType {
   isTaxable?: boolean;
   isNetPrice?: boolean;
@@ -21,7 +19,11 @@ export const Price = {
   },
   amount(obj: PriceType) {
     if (obj.amount) {
-      return accounting.toFixed(obj.amount, 0);
+      return Number(obj.amount).toLocaleString(undefined, {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 0,
+        useGrouping: false,
+      });
     }
     return 0;
   },

package/src/resolvers/type/product/product-bundle-types.ts

@@ -1,8 +1,8 @@
 import { ProductBundleItem } from '@unchainedshop/core-products';
-import { Product } from './product-types.js';
+import { PlanProduct } from './product-plan-types.js';
 
 export const BundleProduct = {
-  ...Product,
+  ...PlanProduct,
 
   bundleItems(product): ProductBundleItem[] {
     return product.bundleItems ? product.bundleItems : [];

package/src/resolvers/type/product/product-configurable-types.ts

@@ -4,6 +4,7 @@ import {
   ProductConfiguration,
   ProductPriceRange,
   ProductVariation,
+  ProductPrice,
 } from '@unchainedshop/core-products';
 import { Context } from '../../../context.js';
 import { Product } from './product-types.js';
@@ -56,14 +57,14 @@ export const ConfigurableProduct = {
       vectors: ProductConfiguration[];
     },
     requestContext: Context,
-  ): Promise<ProductPriceRange> {
+  ): Promise<ProductPriceRange | null> {
     const { countryCode, modules } = requestContext;
     return modules.products.prices.catalogPriceRange(product, {
       quantity,
       vectors,
       includeInactive,
       countryCode,
-      currencyCode,
+      currencyCode: currencyCode || requestContext.currencyCode,
     });
   },
 
@@ -101,7 +102,7 @@ export const ConfigurableProduct = {
       useNetPrice: boolean;
     },
     requestContext: Context,
-  ): Promise<ProductPriceRange> {
+  ): Promise<ProductPriceRange | null> {
     const { countryCode, modules, services } = requestContext;
 
     const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
@@ -117,8 +118,9 @@ export const ConfigurableProduct = {
             product: proxyProduct,
             user: requestContext.user,
             countryCode,
+            discounts: [],
             currencyCode,
-            quantity,
+            quantity: quantity || 1,
           };
 
           const pricing = await services.products.simulateProductPricing(pricingContext);
@@ -133,7 +135,7 @@ export const ConfigurableProduct = {
           };
         }),
       )
-    ).filter(Boolean);
+    ).filter(Boolean) as ProductPrice[];
 
     if (!filteredPrices.length) return null;
 

package/src/resolvers/type/product/product-discount.ts

@@ -16,7 +16,7 @@ export const ProductDiscount = {
 
   total(productDiscount: ProductDiscountType) {
     const { total } = productDiscount;
-    if (productDiscount.total) {
+    if (total) {
       return {
         amount: total.amount,
         currencyCode: total.currencyCode,

package/src/resolvers/type/product/product-plan-types.ts

@@ -13,7 +13,7 @@ export const PlanProduct = {
     product: ProductType,
     { quantity, currencyCode: forcedCurrencyCode }: { quantity?: number; currencyCode?: string },
     requestContext: Context,
-  ): Promise<ProductPrice> {
+  ): Promise<ProductPrice | null> {
     const { modules, countryCode } = requestContext;
     const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
     return modules.products.prices.price(product, {
@@ -37,7 +37,7 @@ export const PlanProduct = {
       configuration?: ProductConfiguration[];
     },
     requestContext: Context,
-  ): Promise<ProductPrice> {
+  ): Promise<ProductPrice | null> {
     const { countryCode, user, services } = requestContext;
     const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
 
@@ -46,7 +46,8 @@ export const PlanProduct = {
       user,
       countryCode,
       currencyCode,
-      quantity,
+      quantity: quantity || 1,
+      discounts: [],
       configuration,
     };
 
@@ -58,7 +59,8 @@ export const PlanProduct = {
       ...unitPrice,
       isNetPrice: useNetPrice,
       isTaxable: pricing.taxSum() > 0,
-      currencyCode: pricing.currencyCode,
+      currencyCode: pricing.currencyCode || requestContext.currencyCode,
+      countryCode: requestContext.countryCode,
     };
   },
 
@@ -78,13 +80,13 @@ export const PlanProduct = {
     return modules.products.prices.catalogPricesLeveled(product, { currencyCode, countryCode });
   },
 
-  salesUnit({ commerce }: ProductType): string {
-    return commerce?.salesUnit;
+  salesUnit({ commerce }: ProductType): string | null {
+    return commerce?.salesUnit || null;
   },
-  salesQuantityPerUnit({ commerce }: ProductType): string {
-    return commerce?.salesQuantityPerUnit;
+  salesQuantityPerUnit({ commerce }: ProductType): string | null {
+    return commerce?.salesQuantityPerUnit || null;
   },
-  defaultOrderQuantity({ commerce }: ProductType): number {
-    return commerce?.defaultOrderQuantity;
+  defaultOrderQuantity({ commerce }: ProductType): number | null {
+    return commerce?.defaultOrderQuantity || null;
   },
 };

package/src/resolvers/type/product/product-review-types.ts

@@ -28,7 +28,7 @@ export const ProductReview: ProductReviewHelperTypes = {
   },
 
   ownVotes: async (obj, _, { modules, userId }) => {
-    return modules.products.reviews.votes.ownVotes(obj, { userId });
+    return modules.products.reviews.votes.ownVotes(obj, { userId: userId! });
   },
 
   voteCount: (obj, { type }, { modules }) => {