@unchainedshop/api 2.8.18 → 2.9.1

package/lib/schema/query.js

@@ -205,6 +205,11 @@ export default [
       """
       token(tokenId: ID!): Token
 
+      """
+      Get all tokens
+      """
+      tokens(limit: Int = 10, offset: Int = 0): [Token!]!
+
       """
       Returns total number of payment providers, optionally filtered by type
       """

package/lib/schema/query.js.map

@@ -1 +1 @@
-{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/schema/query.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAudb;CACF,CAAC"}
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/schema/query.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4db;CACF,CAAC"}

package/lib/schema/types/order/item.js

@@ -29,6 +29,7 @@ export default [
       discounts: [OrderItemDiscount!]
       dispatches: [Dispatch!]
       configuration: [ProductConfigurationParameter!]
+      tokens: [Token!]!
     }
   `,
 ];

package/lib/schema/types/order/item.js.map

@@ -1 +1 @@
-{"version":3,"file":"item.js","sourceRoot":"","sources":["../../../../src/schema/types/order/item.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+Bb;CACF,CAAC"}
+{"version":3,"file":"item.js","sourceRoot":"","sources":["../../../../src/schema/types/order/item.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCb;CACF,CAAC"}

package/lib/schema/types/product/tokenized-product.js

@@ -54,6 +54,8 @@ export default [
       contractAddress: String
       contractStandard: SmartContractStandard
       contractConfiguration: ContractConfiguration
+      tokens: [Token!]!
+      tokensCount: Int!
     }
   `,
 ];

package/lib/schema/types/product/tokenized-product.js.map

@@ -1 +1 @@
-{"version":3,"file":"tokenized-product.js","sourceRoot":"","sources":["../../../../src/schema/types/product/tokenized-product.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDb;CACF,CAAC"}
+{"version":3,"file":"tokenized-product.js","sourceRoot":"","sources":["../../../../src/schema/types/product/tokenized-product.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0Db;CACF,CAAC"}

package/lib/schema/types/warehousing.js

@@ -44,12 +44,19 @@ export default [
 
     type Token @cacheControl(maxAge: 0, scope: PRIVATE) {
       _id: ID!
-      user: User
-      walletAddress: String
       product: TokenizedProduct!
       status: TokenExportStatus!
       quantity: Int!
+      isInvalidateable: Boolean!
+      """
+      Get an access key that you can pass along the HTTP Header "x-token-accesskey" to access the token anonymously.
+      """
+      accessKey: String!
+      invalidatedDate: DateTime
+      user: User
+      expiryDate: DateTime
       contractAddress: String
+      walletAddress: String
       chainId: String
       chainTokenId: String
       ercMetadata(forceLocale: String): JSON

package/lib/schema/types/warehousing.js.map

@@ -1 +1 @@
-{"version":3,"file":"warehousing.js","sourceRoot":"","sources":["../../../src/schema/types/warehousing.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDb;CACF,CAAC"}
+{"version":3,"file":"warehousing.js","sourceRoot":"","sources":["../../../src/schema/types/warehousing.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8Db;CACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/api",
-  "version": "2.8.18",
+  "version": "2.9.1",
   "main": "lib/api-index.js",
   "exports": {
     ".": "./lib/api-index.js",
@@ -48,11 +48,11 @@
   },
   "dependencies": {
     "@metamask/eth-sig-util": "^7.0.2",
-    "@unchainedshop/core": "^2.8.18",
-    "@unchainedshop/events": "^2.8.18",
-    "@unchainedshop/logger": "^2.8.18",
-    "@unchainedshop/roles": "^2.8.18",
-    "@unchainedshop/utils": "^2.8.18",
+    "@unchainedshop/core": "^2.9.1",
+    "@unchainedshop/events": "^2.9.1",
+    "@unchainedshop/logger": "^2.9.1",
+    "@unchainedshop/roles": "^2.9.1",
+    "@unchainedshop/utils": "^2.9.1",
     "accounting": "0.4.1",
     "dataloader": "^2.2.2",
     "graphql-scalars": "^1.23.0",
@@ -65,10 +65,10 @@
     "@types/graphql-upload": "^16.0.7",
     "@types/locale": "^0.1.4",
     "@types/node": "^20.12.12",
-    "@unchainedshop/types": "^2.8.18",
+    "@unchainedshop/types": "^2.9.1",
     "express": "^4.19.2",
     "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
+    "ts-jest": "^29.1.3",
     "typescript": "^5.4.5"
   }
 }

package/src/errors.ts

@@ -208,6 +208,8 @@ export const TokenWrongStatusError = createError(
   'The current status of the token does not allow this operation',
 );
 
+export const TokenNotFoundError = createError('TokenNotFoundError', 'Token not found');
+
 export const CyclicAssortmentLinkNotSupportedError = createError(
   'CyclicAssortmentLinkNotSupported',
   'Cyclic assortment link detected, make sure child assortment is not assigned as a parent on the assortment graph',

package/src/resolvers/mutations/index.ts

@@ -91,6 +91,7 @@ import createWarehousingProvider from './warehousing/createWarehousingProvider.j
 import updateWarehousingProvider from './warehousing/updateWarehousingProvider.js';
 import removeWarehousingProvider from './warehousing/removeWarehousingProvider.js';
 import exportToken from './warehousing/exportToken.js';
+import invalidateToken from './warehousing/invalidateToken.js';
 import setPassword from './accounts/setPassword.js';
 import setRoles from './users/setRoles.js';
 import setUsername from './accounts/setUsername.js';
@@ -286,6 +287,7 @@ export default {
   updateWarehousingProvider: acl(actions.manageWarehousingProviders)(updateWarehousingProvider),
   removeWarehousingProvider: acl(actions.manageWarehousingProviders)(removeWarehousingProvider),
   exportToken: acl(actions.updateToken)(exportToken),
+  invalidateToken: acl(actions.updateToken)(invalidateToken),
   createFilter: acl(actions.manageFilters)(createFilter),
   updateFilter: acl(actions.manageFilters)(updateFilter),
   removeFilter: acl(actions.manageFilters)(removeFilter),

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

@@ -0,0 +1,42 @@
+import { Context, Root } from '@unchainedshop/types/api.js';
+import { log } from '@unchainedshop/logger';
+import {
+  InvalidIdError,
+  TokenNotFoundError,
+  ProductNotFoundError,
+  TokenWrongStatusError,
+} from '../../../errors.js';
+
+export default async function invalidateToken(
+  root: Root,
+  { tokenId }: { tokenId: string },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  log(`mutation invalidateToken ${tokenId}`, {
+    userId,
+  });
+
+  if (!tokenId) throw new InvalidIdError({ tokenId });
+
+  const token = await modules.warehousing.findToken({ tokenId });
+  if (!token) throw new TokenNotFoundError({ tokenId });
+
+  const product = await modules.products.findProduct({ productId: token.productId });
+  if (!product) throw new ProductNotFoundError({ productId: token.productId });
+
+  const isInvalidateable = await modules.warehousing.isInvalidateable(
+    token.chainTokenId,
+    {
+      token,
+      product,
+      referenceDate: new Date(),
+    },
+    context,
+  );
+
+  if (!isInvalidateable) throw new TokenWrongStatusError({ tokenId });
+
+  await modules.warehousing.invalidateToken(tokenId);
+  return modules.warehousing.findToken({ tokenId });
+}

package/src/resolvers/queries/index.ts

@@ -62,6 +62,7 @@ import warehousingProvider from './warehousing/warehousingProvider.js';
 import warehousingProviders from './warehousing/warehousingProviders.js';
 import warehousingProvidersCount from './warehousing/warehousingProvidersCount.js';
 import token from './warehousing/token.js';
+import tokens from './warehousing/tokens.js';
 import work from './worker/work.js';
 import workQueue from './worker/workQueue.js';
 import workQueueCount from './worker/workQueueCount.js';
@@ -101,6 +102,7 @@ export default {
   warehousingProvider: acl(actions.viewWarehousingProvider)(warehousingProvider),
   warehousingInterfaces: acl(actions.viewWarehousingInterfaces)(warehousingInterfaces),
   token: acl(actions.viewToken)(token),
+  tokens: acl(actions.viewTokens)(tokens),
   translatedProductTexts: acl(actions.viewTranslations)(translatedProductTexts),
   translatedProductMediaTexts: acl(actions.viewTranslations)(translatedProductMediaTexts),
   translatedProductVariationTexts: acl(actions.viewTranslations)(translatedProductVariationTexts),
@@ -131,7 +133,6 @@ export default {
   enrollment: acl(actions.viewEnrollment)(enrollment),
   enrollments: acl(actions.viewEnrollments)(enrollments),
   enrollmentsCount: acl(actions.viewEnrollments)(enrollmentsCount),
-
   work: acl(actions.manageWorker)(work),
   event: acl(actions.viewEvent)(event),
   events: acl(actions.viewEvents)(events),

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

@@ -0,0 +1,18 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api.js';
+
+export default async function tokens(
+  root: Root,
+  {
+    limit = 10,
+    offset = 0,
+  }: {
+    limit: number;
+    offset: number;
+  },
+  { modules, userId }: Context,
+) {
+  log(`query tokens`, { userId });
+
+  return modules.warehousing.findTokens({}, { limit, skip: offset });
+}

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

@@ -6,31 +6,7 @@ import { OrderPosition, OrderPositionDiscount } from '@unchainedshop/types/order
 import { OrderPrice } from '@unchainedshop/types/orders.pricing.js';
 import { Product } from '@unchainedshop/types/products.js';
 import { Quotation } from '@unchainedshop/types/quotations.js';
-import { WarehousingProvider } from '@unchainedshop/types/warehousing.js';
-
-type HelperType<P, T> = (orderPosition: OrderPosition, params: P, context: Context) => T;
-
-export interface OrderItemHelperTypes {
-  discounts: HelperType<never, Promise<Array<OrderPositionDiscount>>>;
-  dispatches: HelperType<
-    never,
-    Promise<
-      Array<{
-        _id: string;
-        deliveryProvider: DeliveryProvider;
-        warehousingProvider: WarehousingProvider;
-        shipping: Date;
-        earliestDelivery: Date;
-      }>
-    >
-  >;
-  order: HelperType<never, Promise<Order>>;
-  originalProduct: HelperType<never, Promise<Product>>;
-  product: HelperType<never, Promise<Product>>;
-  quotation: HelperType<never, Promise<Quotation>>;
-  total: HelperType<{ category: string; useNetPrice: boolean }, Promise<OrderPrice>>;
-  unitPrice: HelperType<{ useNetPrice: boolean }, Promise<OrderPrice>>;
-}
+import { TokenSurrogate, WarehousingProvider } from '@unchainedshop/types/warehousing.js';
 
 const getPricingSheet = async (orderPosition: OrderPosition, context: Context) => {
   const { modules } = context;
@@ -43,23 +19,39 @@ const getPricingSheet = async (orderPosition: OrderPosition, context: Context) =
   return pricingSheet;
 };
 
-export const OrderItem: OrderItemHelperTypes = {
-  discounts: async (obj, _, context) => {
-    const pricingSheet = await getPricingSheet(obj, context);
+export const OrderItem = {
+  async discounts(
+    orderPosition: OrderPosition,
+    _,
+    context: Context,
+  ): Promise<Array<OrderPositionDiscount>> {
+    const pricingSheet = await getPricingSheet(orderPosition, context);
 
     if (pricingSheet.isValid()) {
       // IMPORTANT: Do not send any parameter to obj.discounts!
       return pricingSheet.discountPrices().map((discount) => ({
-        item: obj,
+        item: orderPosition,
         ...discount,
       }));
     }
     return [];
   },
 
-  dispatches: async (obj, _, { modules, loaders }) => {
-    const scheduling = obj.scheduling || [];
-    const order = await modules.orders.findOrder({ orderId: obj.orderId });
+  async dispatches(
+    orderPosition: OrderPosition,
+    _,
+    { modules, loaders }: Context,
+  ): Promise<
+    Array<{
+      _id: string;
+      deliveryProvider: DeliveryProvider;
+      warehousingProvider: WarehousingProvider;
+      shipping: Date;
+      earliestDelivery: Date;
+    }>
+  > {
+    const scheduling = orderPosition.scheduling || [];
+    const order = await modules.orders.findOrder({ orderId: orderPosition.orderId });
     const { countryCode, userId } = order;
 
     const orderDelivery = await modules.orders.deliveries.findDelivery({
@@ -69,7 +61,7 @@ export const OrderItem: OrderItemHelperTypes = {
       deliveryProviderId: orderDelivery.deliveryProviderId,
     });
     const product = await loaders.productLoader.load({
-      productId: obj.productId,
+      productId: orderPosition.productId,
     });
 
     return Promise.all(
@@ -82,7 +74,7 @@ export const OrderItem: OrderItemHelperTypes = {
           warehousingProvider,
           deliveryProvider,
           product,
-          quantity: obj.quantity,
+          quantity: orderPosition.quantity,
           country: countryCode,
           userId,
           // referenceDate,
@@ -95,38 +87,42 @@ export const OrderItem: OrderItemHelperTypes = {
     );
   },
 
-  order: async (obj, _, { modules }) => {
-    return modules.orders.findOrder({ orderId: obj.orderId });
+  async order(orderPosition: OrderPosition, _, { modules }: Context): Promise<Order> {
+    return modules.orders.findOrder({ orderId: orderPosition.orderId });
   },
 
-  originalProduct: async (obj, _, { loaders }) => {
+  async originalProduct(orderPosition: OrderPosition, _, { loaders }: Context): Promise<Product> {
     const product = await loaders.productLoader.load({
-      productId: obj.originalProductId,
+      productId: orderPosition.originalProductId,
     });
     return product;
   },
 
-  product: async (obj, _, { loaders }) => {
+  async product(orderPosition: OrderPosition, _, { loaders }: Context): Promise<Product> {
     const product = await loaders.productLoader.load({
-      productId: obj.productId,
+      productId: orderPosition.productId,
     });
     return product;
   },
 
-  quotation: async (obj, _, { modules }) => {
-    if (!obj.quotationId) return null;
-    return modules.quotations.findQuotation({ quotationId: obj.quotationId });
+  async quotation(orderPosition: OrderPosition, _, { modules }: Context): Promise<Quotation> {
+    if (!orderPosition.quotationId) return null;
+    return modules.quotations.findQuotation({ quotationId: orderPosition.quotationId });
   },
 
-  total: async (obj, params, context) => {
-    const pricingSheet = await getPricingSheet(obj, context);
+  async total(
+    orderPosition: OrderPosition,
+    params: { category: string; useNetPrice: boolean },
+    context: Context,
+  ): Promise<OrderPrice> {
+    const pricingSheet = await getPricingSheet(orderPosition, context);
 
     if (pricingSheet.isValid()) {
       const price = pricingSheet.total(params);
       return {
         _id: crypto
           .createHash('sha256')
-          .update([obj._id, JSON.stringify(params), JSON.stringify(price)].join(''))
+          .update([orderPosition._id, JSON.stringify(params), JSON.stringify(price)].join(''))
           .digest('hex'),
         ...price,
       };
@@ -134,19 +130,33 @@ export const OrderItem: OrderItemHelperTypes = {
     return null;
   },
 
-  unitPrice: async (obj, params, context) => {
-    const pricingSheet = await getPricingSheet(obj, context);
+  async unitPrice(
+    orderPosition: OrderPosition,
+    params: { useNetPrice: boolean },
+    context: Context,
+  ): Promise<OrderPrice> {
+    const pricingSheet = await getPricingSheet(orderPosition, context);
 
     if (pricingSheet.isValid()) {
       const price = pricingSheet.unitPrice(params);
       return {
         _id: crypto
           .createHash('sha256')
-          .update([`${obj._id}-unit`, price.amount, pricingSheet.currency].join(''))
+          .update([`${orderPosition._id}-unit`, price.amount, pricingSheet.currency].join(''))
           .digest('hex'),
         ...price,
       };
     }
     return null;
   },
+
+  async tokens(
+    orderPosition: OrderPosition,
+    params: never,
+    { modules }: Context,
+  ): Promise<Array<TokenSurrogate>> {
+    return modules.warehousing.findTokens({
+      orderPositionId: orderPosition._id,
+    });
+  },
 };

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

@@ -10,85 +10,87 @@ import { OrderDiscount } from '@unchainedshop/types/orders.discounts.js';
 import { OrderPayment } from '@unchainedshop/types/orders.payments.js';
 import { OrderPosition } from '@unchainedshop/types/orders.positions.js';
 import { OrderPrice } from '@unchainedshop/types/orders.pricing.js';
-import { PaymentProvider } from '@unchainedshop/types/payments.js';
 import { User } from '@unchainedshop/types/user.js';
 
-type HelperType<P, T> = (order: OrderType, params: P, context: Context) => T;
-
-export interface OrderHelperTypes {
-  supportedDeliveryProviders: HelperType<never, Promise<Array<DeliveryProvider>>>;
-  supportedPaymentProviders: HelperType<never, Promise<Array<PaymentProvider>>>;
-  currency: HelperType<never, Promise<Currency>>;
-  country: HelperType<never, Promise<Country>>;
-  discounts: HelperType<never, Promise<Array<OrderDiscount>>>;
-  delivery: HelperType<never, Promise<OrderDelivery>>;
-  enrollment: HelperType<never, Promise<Enrollment>>;
-  payment: HelperType<never, Promise<OrderPayment>>;
-  items: HelperType<never, Promise<Array<OrderPosition>>>;
-  status: HelperType<never, string>;
-  total: HelperType<{ category: string; useNetPrice: boolean }, Promise<OrderPrice>>;
-  user: HelperType<never, Promise<User>>;
-}
-
-export const Order: OrderHelperTypes = {
-  supportedDeliveryProviders: async (obj, _, context) =>
-    context.modules.delivery.findSupported(
+export const Order = {
+  async supportedDeliveryProviders(
+    order: OrderType,
+    _,
+    context: Context,
+  ): Promise<Array<DeliveryProvider>> {
+    return context.modules.delivery.findSupported(
       {
-        order: obj,
+        order,
       },
       context,
-    ),
+    );
+  },
 
-  supportedPaymentProviders: async (obj, _, context) =>
-    context.modules.payment.paymentProviders.findSupported(
+  async supportedPaymentProviders(order: OrderType, _, context: Context) {
+    return context.modules.payment.paymentProviders.findSupported(
       {
-        order: obj,
+        order,
       },
       context,
-    ),
+    );
+  },
 
-  currency: async (obj, _, { modules }) => modules.currencies.findCurrency({ isoCode: obj.currency }),
-  country: async (obj, _, { modules }) => modules.countries.findCountry({ isoCode: obj.countryCode }),
+  async currency(order: OrderType, _, { modules }: Context): Promise<Currency> {
+    return modules.currencies.findCurrency({ isoCode: order.currency });
+  },
 
-  discounts: async (obj, _, { modules }) =>
-    modules.orders.discounts.findOrderDiscounts({ orderId: obj._id }),
+  async country(order: OrderType, _, { modules }: Context): Promise<Country> {
+    return modules.countries.findCountry({ isoCode: order.countryCode });
+  },
 
-  delivery: async (obj, _, { modules }) =>
-    modules.orders.deliveries.findDelivery({
-      orderDeliveryId: obj.deliveryId,
-    }),
+  async discounts(order: OrderType, _, { modules }: Context): Promise<Array<OrderDiscount>> {
+    return modules.orders.discounts.findOrderDiscounts({ orderId: order._id });
+  },
 
-  enrollment: async (obj, _, { modules }) =>
-    modules.enrollments.findEnrollment({
-      orderId: obj._id,
-    }),
+  async delivery(order: OrderType, _, { modules }: Context): Promise<OrderDelivery> {
+    return modules.orders.deliveries.findDelivery({
+      orderDeliveryId: order.deliveryId,
+    });
+  },
+
+  async enrollment(order: OrderType, _, { modules }: Context): Promise<Enrollment> {
+    return modules.enrollments.findEnrollment({
+      orderId: order._id,
+    });
+  },
 
-  items: async (obj, _, { modules }) =>
-    modules.orders.positions.findOrderPositions({
-      orderId: obj._id,
-    }),
+  async items(order: OrderType, _, { modules }: Context): Promise<Array<OrderPosition>> {
+    return modules.orders.positions.findOrderPositions({
+      orderId: order._id,
+    });
+  },
 
-  payment: async (obj, _, { modules }) =>
-    modules.orders.payments.findOrderPayment({
-      orderPaymentId: obj.paymentId,
-    }),
+  async payment(order: OrderType, _, { modules }: Context): Promise<OrderPayment> {
+    return modules.orders.payments.findOrderPayment({
+      orderPaymentId: order.paymentId,
+    });
+  },
 
-  status: (obj) => {
-    if (obj.status === null) {
+  status(order: OrderType): string {
+    if (order.status === null) {
       return 'OPEN';
     }
-    return obj.status;
+    return order.status;
   },
 
-  total: async (obj, params, { modules }) => {
-    const pricingSheet = modules.orders.pricingSheet(obj);
+  async total(
+    order: OrderType,
+    params: { category: string; useNetPrice: boolean },
+    { modules }: Context,
+  ): Promise<OrderPrice> {
+    const pricingSheet = modules.orders.pricingSheet(order);
 
     if (pricingSheet.isValid()) {
       const price = pricingSheet.total(params);
       return {
         _id: crypto
           .createHash('sha256')
-          .update([obj._id, JSON.stringify(params), JSON.stringify(price)].join(''))
+          .update([order._id, JSON.stringify(params), JSON.stringify(price)].join(''))
           .digest('hex'),
         ...price,
       };
@@ -96,5 +98,7 @@ export const Order: OrderHelperTypes = {
     return null;
   },
 
-  user: async (obj, _, { modules }) => modules.users.findUserById(obj.userId),
+  async user(order: OrderType, _, { modules }: Context): Promise<User> {
+    return modules.users.findUserById(order.userId);
+  },
 };

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

@@ -1,10 +1,10 @@
-import { BundleProductHelperTypes } from '@unchainedshop/types/products.js';
+import { ProductBundleItem } from '@unchainedshop/types/products.js';
 import { Product } from './product-types.js';
 
-export const BundleProduct: BundleProductHelperTypes = {
+export const BundleProduct = {
   ...Product,
 
-  bundleItems(product) {
+  bundleItems(product): Array<ProductBundleItem> {
     return product.bundleItems ? product.bundleItems : [];
   },
 };