@unchainedshop/api 4.0.0-rc.15 → 4.0.0-rc.17

package/src/resolvers/mutations/warehousing/createWarehousingProvider.ts

@@ -6,7 +6,7 @@ import { WarehousingDirector } from '@unchainedshop/core';
 
 export default async function createWarehousingProvider(
   root: never,
-  { warehousingProvider }: { warehousingProvider: WarehousingProvider },
+  { warehousingProvider }: { warehousingProvider: Pick<WarehousingProvider, 'type' | 'adapterKey'> },
   { modules, userId }: Context,
 ) {
   log('mutation createWarehousingProvider', { userId });

package/src/resolvers/mutations/worker/allocateWork.ts

@@ -3,7 +3,7 @@ import { log } from '@unchainedshop/logger';
 
 export default async function allocateWork(
   root: never,
-  { types, worker }: { types?: string[]; worker?: string },
+  { types, worker }: { types: string[]; worker: string },
   { modules, userId }: Context,
 ) {
   log(`mutation allocateWork ${(types || []).join(',')} ${worker}`, {

package/src/resolvers/mutations/worker/finishWork.ts

@@ -10,12 +10,12 @@ export default async function finishWork(
     finished?: Date;
     result?: any;
     started?: Date;
-    success?: boolean;
+    success: boolean;
     worker?: string;
   },
   { modules, userId }: Context,
 ) {
-  const { workId, error, success } = data;
+  const { workId, error, success, ...workData } = data;
 
   log(`mutation finishWork ${workId} ${success}`, {
     userId,
@@ -26,7 +26,7 @@ export default async function finishWork(
   const work = await modules.worker.finishWork(workId, {
     error,
     success,
-    ...data,
+    ...workData,
   });
 
   if (!work) throw new WorkNotFoundOrWrongStatus({ workId });

package/src/resolvers/queries/products/product.ts

@@ -11,5 +11,5 @@ export default async function product(
 
   if (!productId === !slug) throw new InvalidIdError({ productId, slug });
 
-  return modules.products.findProduct({ productId, slug });
+  return modules.products.findProduct({ productId, slug: slug! });
 }

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/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';
@@ -78,7 +77,6 @@ const types = {
   AssortmentProduct,
   Bookmark,
   BundleProduct,
-  Color,
   ConfigurableProduct,
   Country,
   Currency,

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-statistics-types.ts

@@ -1,3 +1,4 @@
+import { mongodb } from '@unchainedshop/mongodb';
 import { Context } from '../../../context.js';
 
 function buildDateMatch(dateField: string, dateRange?: { start?: string; end?: string }) {
@@ -16,9 +17,8 @@ async function aggregateOrders(
   dateRange?: { start?: string; end?: string },
   options?: { includeAmount?: boolean; includeCarts?: boolean },
 ) {
-  const match = buildDateMatch(dateField, dateRange);
-
-  const pipeline: any[] = [{ $match: match }];
+  const match: mongodb.BSON.Document = buildDateMatch(dateField, dateRange);
+  const pipeline: mongodb.BSON.Document[] = [{ $match: match }];
 
   if (options?.includeCarts) {
     match.status = null;

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-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 }) => {

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

@@ -59,7 +59,7 @@ export const SimpleProduct = {
     return warehousing?.sku;
   },
 
-  dimensions({ supply }): ProductSupply {
+  dimensions({ supply }): ProductSupply | null {
     if (!supply) return null;
     const { weightInGram, heightInMillimeters, lengthInMillimeters, widthInMillimeters } = supply;
     return {

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

@@ -14,11 +14,11 @@ import { actions } from '../../../roles/index.js';
 export const TokenizedProduct = {
   ...PlanProduct,
 
-  contractAddress({ tokenization }: Product): string {
-    return tokenization?.contractAddress;
+  contractAddress({ tokenization }: Product): string | null {
+    return tokenization?.contractAddress || null;
   },
 
-  contractConfiguration({ tokenization }: Product): ProductContractConfiguration {
+  contractConfiguration({ tokenization }: Product): ProductContractConfiguration | null {
     if (!tokenization) return null;
     return {
       supply: tokenization.supply,
@@ -27,8 +27,8 @@ export const TokenizedProduct = {
     };
   },
 
-  contractStandard({ tokenization }: Product): ProductContractStandard {
-    return tokenization?.contractStandard;
+  contractStandard({ tokenization }: Product): ProductContractStandard | null {
+    return tokenization?.contractStandard || null;
   },
 
   async simulatedStocks(
@@ -61,6 +61,6 @@ export const TokenizedProduct = {
   },
 };
 
-delete TokenizedProduct.salesUnit;
-delete TokenizedProduct.salesQuantityPerUnit;
-delete TokenizedProduct.defaultOrderQuantity;
+delete (TokenizedProduct as any).salesUnit;
+delete (TokenizedProduct as any).salesQuantityPerUnit;
+delete (TokenizedProduct as any).defaultOrderQuantity;

package/src/resolvers/type/product/product-variation-assignment-vector.ts

@@ -10,8 +10,8 @@ export type AssignmentVectorHelperType<T> = (
 
 export interface ProductVariationAssignmentVectorHelperTypes {
   _id: AssignmentVectorHelperType<string>;
-  option: AssignmentVectorHelperType<Promise<{ _id: string; productVariationOption: string }>>;
-  variation: AssignmentVectorHelperType<Promise<ProductVariation>>;
+  option: AssignmentVectorHelperType<Promise<{ _id: string; productVariationOption: string } | null>>;
+  variation: AssignmentVectorHelperType<Promise<ProductVariation | null>>;
 }
 
 export const ProductVariationAssignmentVector: ProductVariationAssignmentVectorHelperTypes = {

package/src/resolvers/type/product-search-result-types.ts

@@ -59,9 +59,9 @@ export const ProductSearchResult = {
     const relevantProductIds = await modules.products.findProductIds({
       productSelector: searchConfiguration.productSelector,
       productIds: totalProductIds,
-      includeDrafts: searchConfiguration.searchQuery.includeInactive,
+      includeDrafts: searchConfiguration.searchQuery?.includeInactive,
     });
-    return services.filters.loadFilters(searchConfiguration.searchQuery, {
+    return services.filters.loadFilters(searchConfiguration.searchQuery || {}, {
       productIds: relevantProductIds,
       forceLiveCollection: searchConfiguration.forceLiveCollection,
     });