@unchainedshop/api 1.1.3

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

@@ -0,0 +1,36 @@
+import { Context } from '@unchainedshop/types/api';
+import { OrderDiscount } from '@unchainedshop/types/orders.discounts';
+import { OrderPositionDiscount } from '@unchainedshop/types/orders.positions';
+import { OrderPrice } from '@unchainedshop/types/orders.pricing';
+import crypto from 'crypto';
+
+type HelperType<P, T> = (orderPositionDiscount: OrderPositionDiscount, params: P, context: Context) => T;
+
+interface OrderItemDiscountHelperTypes {
+  _id: HelperType<never, string>;
+  orderDiscount: HelperType<never, Promise<OrderDiscount>>;
+  total: HelperType<never, OrderPrice>;
+}
+
+export const OrderItemDiscount: OrderItemDiscountHelperTypes = {
+  _id: (obj) => {
+    return `${obj.item._id}:${obj.discountId}`;
+  },
+
+  orderDiscount: async (obj, _, { modules }) => {
+    return modules.orders.discounts.findOrderDiscount({
+      discountId: obj.discountId,
+    });
+  },
+
+  total(obj) {
+    return {
+      _id: crypto
+        .createHash('sha256')
+        .update([`${obj.item._id}:${obj.discountId}`, obj.amount, obj.currency].join(''))
+        .digest('hex'),
+      amount: obj.amount,
+      currency: obj.currency,
+    };
+  },
+};

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

@@ -0,0 +1,155 @@
+import { Context } from '@unchainedshop/types/api';
+import { DeliveryProvider } from '@unchainedshop/types/delivery';
+import { Order } from '@unchainedshop/types/orders';
+import { OrderPosition, OrderPositionDiscount } from '@unchainedshop/types/orders.positions';
+import { OrderPrice } from '@unchainedshop/types/orders.pricing';
+import { Product } from '@unchainedshop/types/products';
+import { Quotation } from '@unchainedshop/types/quotations';
+import { WarehousingProvider } from '@unchainedshop/types/warehousing';
+import crypto from 'crypto';
+
+type HelperType<P, T> = (orderPosition: OrderPosition, params: P, context: Context) => T;
+
+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 }, Promise<OrderPrice>>;
+  unitPrice: HelperType<never, Promise<OrderPrice>>;
+}
+
+const getPricingSheet = async (orderPosition: OrderPosition, context: Context) => {
+  const { modules } = context;
+
+  const order = await modules.orders.findOrder({
+    orderId: orderPosition.orderId,
+  });
+  const pricingSheet = modules.orders.positions.pricingSheet(orderPosition, order.currency, context);
+
+  return pricingSheet;
+};
+
+export const OrderItem: OrderItemHelperTypes = {
+  discounts: async (obj, _, context) => {
+    const pricingSheet = await getPricingSheet(obj, context);
+
+    if (pricingSheet.isValid()) {
+      // IMPORTANT: Do not send any parameter to obj.discounts!
+      return pricingSheet.discountPrices().map((discount) => ({
+        item: obj,
+        ...discount,
+      }));
+    }
+    return [];
+  },
+
+  dispatches: async (obj, _, { modules }) => {
+    const scheduling = obj.scheduling || [];
+    const order = await modules.orders.findOrder({ orderId: obj.orderId });
+    const { countryCode, userId } = order;
+
+    const orderDelivery = await modules.orders.deliveries.findDelivery({
+      orderDeliveryId: order.deliveryId,
+    });
+    const deliveryProvider = await modules.delivery.findProvider({
+      deliveryProviderId: orderDelivery.deliveryProviderId,
+    });
+    const product = await modules.products.findProduct({
+      productId: obj.productId,
+    });
+
+    return Promise.all(
+      scheduling.map(async (schedule) => {
+        const warehousingProvider = await modules.warehousing.findProvider({
+          warehousingProviderId: schedule.warehousingProviderId,
+        });
+
+        const context = {
+          warehousingProvider,
+          deliveryProvider,
+          product,
+          quantity: obj.quantity,
+          country: countryCode,
+          userId,
+          // referenceDate,
+        };
+        return {
+          ...context,
+          ...schedule,
+        };
+      }),
+    );
+  },
+
+  order: async (obj, _, { modules }) => {
+    return modules.orders.findOrder({ orderId: obj.orderId });
+  },
+
+  originalProduct: async (obj, _, { modules }) => {
+    return modules.products.findProduct({
+      productId: obj.originalProductId,
+    });
+  },
+
+  product: async (obj, _, { modules }) => {
+    return modules.products.findProduct({ productId: obj.productId });
+  },
+
+  quotation: async (obj, _, { modules }) => {
+    if (!obj.quotationId) return null;
+    return modules.quotations.findQuotation({ quotationId: obj.quotationId });
+  },
+
+  total: async (obj, { category }, context) => {
+    const pricingSheet = await getPricingSheet(obj, context);
+
+    if (pricingSheet.isValid()) {
+      const { amount, currency } = pricingSheet.total({
+        category,
+        useNetPrice: false,
+      });
+      return {
+        _id: crypto
+          .createHash('sha256')
+          .update([`${obj._id}-${category}`, amount, currency].join(''))
+          .digest('hex'),
+        amount,
+        currency,
+      };
+    }
+    return null;
+  },
+
+  unitPrice: async (obj, _, context) => {
+    const pricingSheet = await getPricingSheet(obj, context);
+
+    if (pricingSheet.isValid()) {
+      const price = pricingSheet.unitPrice({
+        useNetPrice: false,
+      });
+      return {
+        _id: crypto
+          .createHash('sha256')
+          .update([`${obj._id}-unit`, price.amount, pricingSheet.currency].join(''))
+          .digest('hex'),
+        currency: pricingSheet.currency,
+        ...price,
+      };
+    }
+    return null;
+  },
+};

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

@@ -0,0 +1,37 @@
+import { Context } from '@unchainedshop/types/api';
+import { OrderPayment, OrderPaymentDiscount } from '@unchainedshop/types/orders.payments';
+import { PaymentProvider } from '@unchainedshop/types/payments';
+
+type HelperType<T> = (orderPayment: OrderPayment, _: never, context: Context) => T;
+
+interface OrderPaymentCardHelperTypes {
+  discounts: HelperType<Promise<Array<OrderPaymentDiscount>>>;
+  provider: HelperType<Promise<PaymentProvider>>;
+  status: HelperType<string>;
+}
+
+export const OrderPaymentCard: OrderPaymentCardHelperTypes = {
+  status: (obj, _, { modules }) => {
+    return modules.orders.payments.normalizedStatus(obj);
+  },
+
+  provider: async (obj, _, { modules }) => {
+    return modules.payment.paymentProviders.findProvider({
+      paymentProviderId: obj.paymentProviderId,
+    });
+  },
+
+  discounts: async (obj, _, context) => {
+    const { modules } = context;
+    const order = await modules.orders.findOrder({ orderId: obj.orderId });
+    const pricingSheet = modules.orders.payments.pricingSheet(obj, order.currency, context);
+    if (pricingSheet.isValid()) {
+      // IMPORTANT: Do not send any parameter to obj.discounts!
+      return pricingSheet.discountPrices().map((discount) => ({
+        item: obj,
+        ...discount,
+      }));
+    }
+    return [];
+  },
+};

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

@@ -0,0 +1,35 @@
+import { Context } from '@unchainedshop/types/api';
+import { OrderDiscount } from '@unchainedshop/types/orders.discounts';
+import { OrderPayment } from '@unchainedshop/types/orders.payments';
+import { OrderPrice } from '@unchainedshop/types/orders.pricing';
+import crypto from 'crypto';
+
+type HelperType<P, T> = (
+  orderDelivery: OrderPrice & { discountId: string; item: OrderPayment },
+  params: P,
+  context: Context,
+) => T;
+
+interface OrderPaymentDiscountHelperTypes {
+  _id: HelperType<never, string>;
+  orderDiscount: HelperType<never, Promise<OrderDiscount>>;
+  total: HelperType<never, OrderPrice>;
+}
+
+export const OrderPaymentDiscount: OrderPaymentDiscountHelperTypes = {
+  _id: (obj) => `${obj.item._id}:${obj.discountId}`,
+
+  orderDiscount: (obj, _, { modules }) =>
+    modules.orders.discounts.findOrderDiscount({
+      discountId: obj.discountId,
+    }),
+
+  total: (obj) => ({
+    _id: crypto
+      .createHash('sha256')
+      .update([`${obj.item._id}-${obj.discountId}`, obj.amount, obj.currency].join(''))
+      .digest('hex'),
+    amount: obj.amount,
+    currency: obj.currency,
+  }),
+};

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

@@ -0,0 +1,37 @@
+import { Context } from '@unchainedshop/types/api';
+import { OrderPayment, OrderPaymentDiscount } from '@unchainedshop/types/orders.payments';
+import { PaymentProvider } from '@unchainedshop/types/payments';
+
+type HelperType<P, T> = (orderPayment: OrderPayment, params: P, context: Context) => T;
+
+interface OrderPaymentGenericHelperTypes {
+  discounts: HelperType<never, Promise<Array<OrderPaymentDiscount>>>;
+  provider: HelperType<never, Promise<PaymentProvider>>;
+  status: HelperType<never, string>;
+}
+
+export const OrderPaymentGeneric: OrderPaymentGenericHelperTypes = {
+  status: (obj, _, { modules }) => {
+    return modules.orders.payments.normalizedStatus(obj);
+  },
+
+  provider: async (obj, _, { modules }) => {
+    return modules.payment.paymentProviders.findProvider({
+      paymentProviderId: obj.paymentProviderId,
+    });
+  },
+
+  discounts: async (obj, _, context) => {
+    const { modules } = context;
+    const order = await modules.orders.findOrder({ orderId: obj.orderId });
+    const pricingSheet = modules.orders.payments.pricingSheet(obj, order.currency, context);
+    if (pricingSheet.isValid()) {
+      // IMPORTANT: Do not send any parameter to obj.discounts!
+      return pricingSheet.discountPrices().map((discount) => ({
+        item: obj,
+        ...discount,
+      }));
+    }
+    return [];
+  },
+};

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

@@ -0,0 +1,37 @@
+import { Context } from '@unchainedshop/types/api';
+import { OrderPayment, OrderPaymentDiscount } from '@unchainedshop/types/orders.payments';
+import { PaymentProvider } from '@unchainedshop/types/payments';
+
+type HelperType<T> = (orderPayment: OrderPayment, _: never, context: Context) => T;
+
+interface OrderPaymentInvoiceHelperTypes {
+  discounts: HelperType<Promise<Array<OrderPaymentDiscount>>>;
+  provider: HelperType<Promise<PaymentProvider>>;
+  status: HelperType<string>;
+}
+
+export const OrderPaymentInvoice: OrderPaymentInvoiceHelperTypes = {
+  status: (obj, _, { modules }) => {
+    return modules.orders.payments.normalizedStatus(obj);
+  },
+
+  provider: async (obj, _, { modules }) => {
+    return modules.payment.paymentProviders.findProvider({
+      paymentProviderId: obj.paymentProviderId,
+    });
+  },
+
+  discounts: async (obj, _, context) => {
+    const { modules } = context;
+    const order = await modules.orders.findOrder({ orderId: obj.orderId });
+    const pricingSheet = modules.orders.payments.pricingSheet(obj, order.currency, context);
+    if (pricingSheet.isValid()) {
+      // IMPORTANT: Do not send any parameter to obj.discounts!
+      return pricingSheet.discountPrices().map((discount) => ({
+        item: obj,
+        ...discount,
+      }));
+    }
+    return [];
+  },
+};

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

@@ -0,0 +1,24 @@
+import { Context } from '@unchainedshop/types/api';
+import { OrderPayment as OrderPaymentType } from '@unchainedshop/types/orders.payments';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { objectInvert } from '@unchainedshop/utils';
+
+const OrderPaymentMap = {
+  OrderPaymentGeneric: PaymentProviderType.GENERIC,
+  OrderPaymentCard: PaymentProviderType.CARD,
+  OrderPaymentInvoice: PaymentProviderType.INVOICE,
+};
+
+export const OrderPayment = {
+  __resolveType: async (obj: OrderPaymentType, { modules }: Context) => {
+    const provider = await modules.payment.paymentProviders.findProvider({
+      paymentProviderId: obj.paymentProviderId,
+    });
+
+    const invertedProductTypes = objectInvert(OrderPaymentMap);
+    if (provider) {
+      return invertedProductTypes[provider.type];
+    }
+    return invertedProductTypes[PaymentProviderType.INVOICE];
+  },
+};

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

@@ -0,0 +1,109 @@
+import { Context } from '@unchainedshop/types/api';
+import { Country } from '@unchainedshop/types/countries';
+import { Currency } from '@unchainedshop/types/currencies';
+import { DeliveryProvider } from '@unchainedshop/types/delivery';
+import { Enrollment } from '@unchainedshop/types/enrollments';
+import { File } from '@unchainedshop/types/files';
+import { Order as OrderType, OrderDocumentType } from '@unchainedshop/types/orders';
+import { OrderDelivery } from '@unchainedshop/types/orders.deliveries';
+import { OrderDiscount } from '@unchainedshop/types/orders.discounts';
+import { OrderPayment } from '@unchainedshop/types/orders.payments';
+import { OrderPosition } from '@unchainedshop/types/orders.positions';
+import { OrderPrice } from '@unchainedshop/types/orders.pricing';
+import { PaymentProvider } from '@unchainedshop/types/payments';
+import { User } from '@unchainedshop/types/user';
+import crypto from 'crypto';
+
+type HelperType<P, T> = (order: OrderType, params: P, context: Context) => T;
+
+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>>;
+  documents: HelperType<{ type: OrderDocumentType }, Promise<Array<File>>>;
+  enrollment: HelperType<never, Promise<Enrollment>>;
+  payment: HelperType<never, Promise<OrderPayment>>;
+  items: HelperType<never, Promise<Array<OrderPosition>>>;
+  status: HelperType<never, string>;
+  total: HelperType<{ category: string }, Promise<OrderPrice>>;
+  user: HelperType<never, Promise<User>>;
+}
+
+export const Order: OrderHelperTypes = {
+  supportedDeliveryProviders: async (obj, _, context) =>
+    context.modules.delivery.findSupported(
+      {
+        order: obj,
+      },
+      context,
+    ),
+
+  supportedPaymentProviders: async (obj, _, context) =>
+    context.modules.payment.paymentProviders.findSupported(
+      {
+        order: obj,
+      },
+      context,
+    ),
+
+  currency: async (obj, _, { modules }) => modules.currencies.findCurrency({ isoCode: obj.currency }),
+  country: async (obj, _, { modules }) => modules.countries.findCountry({ isoCode: obj.countryCode }),
+
+  discounts: async (obj, _, { modules }) =>
+    modules.orders.discounts.findOrderDiscounts({ orderId: obj._id }),
+
+  documents: async (obj, { type }, { modules }) =>
+    modules.files.findFilesByMetaData(
+      { meta: { orderId: obj._id, type } },
+      { sort: { 'meta.data': -1 } },
+    ),
+
+  delivery: async (obj, _, { modules }) =>
+    modules.orders.deliveries.findDelivery({
+      orderDeliveryId: obj.deliveryId,
+    }),
+
+  enrollment: async (obj, _, { modules }) =>
+    modules.enrollments.findEnrollment({
+      orderId: obj._id,
+    }),
+
+  items: async (obj, _, { modules }) =>
+    modules.orders.positions.findOrderPositions({
+      orderId: obj._id,
+    }),
+
+  payment: async (obj, _, { modules }) =>
+    modules.orders.payments.findOrderPayment({
+      orderPaymentId: obj.paymentId,
+    }),
+
+  status: (obj) => {
+    if (obj.status === null) {
+      return 'OPEN';
+    }
+    return obj.status;
+  },
+
+  total: async (obj, params: { category: string }, { modules }) => {
+    const pricingSheet = modules.orders.pricingSheet(obj);
+
+    if (pricingSheet.isValid()) {
+      const price = pricingSheet.total({ category: params.category, useNetPrice: false });
+
+      return {
+        _id: crypto
+          .createHash('sha256')
+          .update([obj._id, price.amount, price.currency].join(''))
+          .digest('hex'),
+        ...price,
+      };
+    }
+    return null;
+  },
+
+  user: async (obj, _, { modules }) => modules.users.findUserById(obj.userId),
+};

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

@@ -0,0 +1,23 @@
+import { PaymentCredentialsHelperTypes } from '@unchainedshop/types/payments';
+
+export const PaymentCredentials: PaymentCredentialsHelperTypes = {
+  async user(obj, _, { modules }) {
+    return modules.users.findUserById(obj.userId);
+  },
+
+  async paymentProvider(obj, _, { modules }) {
+    return modules.payment.paymentProviders.findProvider({
+      paymentProviderId: obj.paymentProviderId,
+    });
+  },
+
+  async isValid(obj, _, context) {
+    const { modules, userId } = context;
+
+    return modules.payment.paymentProviders.validate(
+      obj.paymentProviderId,
+      { userId, token: obj },
+      context,
+    );
+  },
+};

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

@@ -0,0 +1,37 @@
+import { Context } from '@unchainedshop/types/api';
+import { PaymentError, PaymentProvider as PaymentProviderType } from '@unchainedshop/types/payments';
+
+export interface PaymentProviderHelperTypes {
+  interface: (
+    provider: PaymentProviderType,
+    _: never,
+    context: Context,
+  ) => {
+    _id: string;
+    label: string;
+    version: string;
+  };
+  isActive: (provider: PaymentProviderType, _: never, context: Context) => Promise<boolean>;
+  configurationError: (
+    provider: PaymentProviderType,
+    _: never,
+    context: Context,
+  ) => Promise<PaymentError>;
+}
+export const PaymentProvider: PaymentProviderHelperTypes = {
+  interface(obj, _, { modules }) {
+    const Interface = modules.payment.paymentProviders.findInterface(obj);
+    if (!Interface) return null;
+    return Interface;
+  },
+
+  configurationError(obj, _, requestContext) {
+    const { modules } = requestContext;
+    return modules.payment.paymentProviders.configurationError(obj, requestContext);
+  },
+
+  isActive(obj, _, requestContext) {
+    const { modules } = requestContext;
+    return modules.payment.paymentProviders.isActive(obj, requestContext);
+  },
+};

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

@@ -0,0 +1,29 @@
+import accounting from 'accounting';
+
+type PriceType = {
+  _id?: string;
+  isTaxable?: boolean;
+  isNetPrice?: boolean;
+  countryCode?: string;
+  currencyCode?: string;
+  currency?: string;
+  amount: number;
+};
+
+export const Price = {
+  isTaxable({ isTaxable }: PriceType) {
+    return isTaxable || false;
+  },
+  isNetPrice({ isNetPrice }: PriceType) {
+    return isNetPrice || false;
+  },
+  currency(obj: PriceType) {
+    return obj?.currencyCode || obj?.currency;
+  },
+  amount(obj: PriceType) {
+    if (obj.amount) {
+      return accounting.toFixed(obj.amount, 0);
+    }
+    return 0;
+  },
+};

package/src/resolvers/type/product/product-assortment-path-types.ts

@@ -0,0 +1,9 @@
+import { ProductAssortmentPathHelperTypes } from '@unchainedshop/types/products';
+
+export const ProductAssortmentPath: ProductAssortmentPathHelperTypes = {
+  assortmentProduct: async ({ _id }, _, { modules }) => {
+    return modules.assortments.products.findProduct({
+      assortmentProductId: _id,
+    });
+  },
+};

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

@@ -0,0 +1,9 @@
+import { ProductBundleItemHelperTypes } from '@unchainedshop/types/products';
+
+export const ProductBundleItem: ProductBundleItemHelperTypes = {
+  product: async (productItem, _, { modules }) => {
+    return modules.products.findProduct({
+      productId: productItem.productId,
+    });
+  },
+};

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

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

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

@@ -0,0 +1,16 @@
+import { ProductCatalogPriceHelperTypes } from '@unchainedshop/types/products';
+
+export const ProductCatalogPrice: ProductCatalogPriceHelperTypes = {
+  isTaxable: ({ isTaxable }) => {
+    return isTaxable || false;
+  },
+  isNetPrice: ({ isNetPrice }) => {
+    return isNetPrice || false;
+  },
+  country: async ({ countryCode }, _, { modules }) => {
+    return modules.countries.findCountry({ isoCode: countryCode });
+  },
+  currency: async ({ currencyCode }, _, { modules }) => {
+    return modules.currencies.findCurrency({ isoCode: currencyCode });
+  },
+};