@unchainedshop/api 1.1.3

package/src/resolvers/mutations/orders/deliverOrder.ts

@@ -0,0 +1,43 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { OrderDeliveryStatus } from '@unchainedshop/types/orders.deliveries';
+import {
+  OrderNotFoundError,
+  OrderWrongDeliveryStatusError,
+  OrderWrongStatusError,
+  InvalidIdError,
+} from '../../../errors';
+
+export default async function deliverOrder(
+  root: Root,
+  { orderId }: { orderId: string },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  log('mutation deliverOrder', { orderId, userId });
+
+  if (!orderId) throw new InvalidIdError({ orderId });
+
+  const order = await modules.orders.findOrder({ orderId });
+  if (!order) throw new OrderNotFoundError({ orderId });
+
+  if (modules.orders.isCart(order)) {
+    throw new OrderWrongStatusError({ status: order.status });
+  }
+
+  const orderDelivery = await modules.orders.deliveries.findDelivery({
+    orderDeliveryId: order.deliveryId,
+  });
+
+  if (
+    modules.orders.deliveries.normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN &&
+    order.confirmed
+  ) {
+    throw new OrderWrongDeliveryStatusError({
+      status: orderDelivery.status,
+    });
+  }
+
+  await modules.orders.deliveries.markAsDelivered(orderDelivery);
+  return modules.orders.processOrder(order, {}, context);
+}

package/src/resolvers/mutations/orders/emptyCart.ts

@@ -0,0 +1,20 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { getOrderCart } from '../utils/getOrderCart';
+
+export default async function emptyCart(
+  root: Root,
+  { orderId }: { orderId?: string },
+  context: Context,
+) {
+  const { modules, userId, user } = context;
+
+  log('mutation emptyCart', { userId, orderId });
+
+  const cart = await getOrderCart({ orderId, user }, context);
+  if (!cart) return null;
+
+  await modules.orders.positions.removePositions({ orderId: cart._id }, context);
+
+  return cart;
+}

package/src/resolvers/mutations/orders/payOrder.ts

@@ -0,0 +1,37 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { OrderPaymentStatus } from '@unchainedshop/types/orders.payments';
+import {
+  OrderNotFoundError,
+  OrderWrongPaymentStatusError,
+  OrderWrongStatusError,
+  InvalidIdError,
+} from '../../../errors';
+
+export default async function payOrder(root: Root, { orderId }: { orderId: string }, context: Context) {
+  const { modules, userId } = context;
+
+  log('mutation payOrder', { orderId, userId });
+
+  if (!orderId) throw new InvalidIdError({ orderId });
+
+  const order = await modules.orders.findOrder({ orderId });
+  if (!order) throw new OrderNotFoundError({ orderId });
+
+  if (modules.orders.isCart(order)) {
+    throw new OrderWrongStatusError({ status: order.status });
+  }
+
+  const payment = await modules.orders.payments.findOrderPayment({
+    orderPaymentId: order.paymentId,
+  });
+
+  if (modules.orders.payments.normalizedStatus(payment) !== OrderPaymentStatus.OPEN) {
+    throw new OrderWrongPaymentStatusError({
+      status: payment.status,
+    });
+  }
+
+  await modules.orders.payments.markAsPaid(payment, null, userId);
+  return modules.orders.processOrder(order, {}, context);
+}

package/src/resolvers/mutations/orders/rejectOrder.ts

@@ -0,0 +1,29 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { OrderStatus } from '@unchainedshop/core-orders';
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError, OrderNotFoundError, OrderWrongStatusError } from '../../../errors';
+
+export default async function rejectOrder(
+  root: Root,
+  params: {
+    orderId: string;
+    orderContext?: any;
+    paymentContext?: any;
+    deliveryContext?: any;
+  },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { orderId, ...transactionContext } = params;
+
+  log('mutation rejectOrder', { orderId, userId });
+  if (!orderId) throw new InvalidIdError({ orderId });
+
+  const order = await modules.orders.findOrder({ orderId });
+  if (!order) throw new OrderNotFoundError({ orderId });
+
+  if (order.status !== OrderStatus.PENDING) {
+    throw new OrderWrongStatusError({ status: order.status });
+  }
+  return modules.orders.reject(order._id, transactionContext, context);
+}

package/src/resolvers/mutations/orders/removeCartDiscount.ts

@@ -0,0 +1,30 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+
+import { OrderDiscountNotFoundError, OrderWrongStatusError, InvalidIdError } from '../../../errors';
+
+export default async function removeCartDiscount(
+  root: Root,
+  { discountId }: { discountId: string },
+  context: Context,
+) {
+  const { modules, userId } = context;
+
+  log(`mutation removeCartDiscount ${discountId}`, { userId });
+
+  if (!discountId) throw new InvalidIdError({ discountId });
+
+  const orderDiscount = await modules.orders.discounts.findOrderDiscount({
+    discountId,
+  });
+  if (!orderDiscount) throw new OrderDiscountNotFoundError({ orderDiscount });
+
+  const order = await modules.orders.findOrder({
+    orderId: orderDiscount.orderId,
+  });
+  if (!modules.orders.isCart(order)) {
+    throw new OrderWrongStatusError({ status: order.status });
+  }
+
+  return modules.orders.discounts.delete(discountId, context);
+}

package/src/resolvers/mutations/orders/removeCartItem.ts

@@ -0,0 +1,28 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { OrderItemNotFoundError, OrderWrongStatusError, InvalidIdError } from '../../../errors';
+
+export default async function removeCartItem(
+  root: Root,
+  { itemId }: { itemId: string },
+  context: Context,
+) {
+  const { modules, userId } = context;
+
+  log(`mutation removeCartItem ${itemId}`, { userId });
+
+  if (!itemId) throw new InvalidIdError({ itemId });
+
+  const orderItem = await modules.orders.positions.findOrderPosition({
+    itemId,
+  });
+  if (!orderItem) throw new OrderItemNotFoundError({ orderItem });
+
+  const order = await modules.orders.findOrder({ orderId: orderItem.orderId });
+
+  if (!modules.orders.isCart(order)) {
+    throw new OrderWrongStatusError({ status: order.status });
+  }
+
+  return modules.orders.positions.delete(itemId, context);
+}

package/src/resolvers/mutations/orders/removeOrder.ts

@@ -0,0 +1,24 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { OrderNotFoundError, OrderWrongStatusError, InvalidIdError } from '../../../errors';
+
+export default async function removeOrder(
+  root: Root,
+  { orderId }: { orderId: string },
+  { modules, userId }: Context,
+) {
+  log('mutation removeOrder', { userId, orderId });
+
+  if (!orderId) throw new InvalidIdError({ orderId });
+
+  const order = await modules.orders.findOrder({ orderId });
+  if (!order) throw new OrderNotFoundError({ orderId });
+
+  if (!modules.orders.isCart(order)) {
+    throw new OrderWrongStatusError({ status: order.status });
+  }
+
+  await modules.orders.delete(orderId, userId);
+
+  return order;
+}

package/src/resolvers/mutations/orders/setOrderDeliveryProvider.ts

@@ -0,0 +1,26 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { OrderNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function setOrderDeliveryProvider(
+  root: Root,
+  params: { orderId: string; deliveryProviderId: string },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { orderId, deliveryProviderId } = params;
+
+  log(`mutation setOrderDeliveryProvider ${deliveryProviderId}`, {
+    orderId,
+    userId,
+  });
+
+  if (!orderId) throw new InvalidIdError({ orderId });
+  if (!deliveryProviderId) throw new InvalidIdError({ deliveryProviderId });
+
+  if (!(await modules.orders.orderExists({ orderId }))) throw new OrderNotFoundError({ orderId });
+
+  const order = await modules.orders.setDeliveryProvider(orderId, deliveryProviderId, context);
+
+  return order;
+}

package/src/resolvers/mutations/orders/setOrderPaymentProvider.ts

@@ -0,0 +1,25 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { OrderNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function setOrderPaymentProvider(
+  root: Root,
+  params: { orderId: string; paymentProviderId: string },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { orderId, paymentProviderId } = params;
+
+  log(`mutation setOrderPaymentProvider ${paymentProviderId}`, {
+    orderId,
+    userId,
+  });
+
+  if (!orderId) throw new InvalidIdError({ orderId });
+  if (!paymentProviderId) throw new InvalidIdError({ paymentProviderId });
+
+  const order = await modules.orders.findOrder({ orderId });
+  if (!order) throw new OrderNotFoundError({ orderId });
+
+  return modules.orders.setPaymentProvider(orderId, paymentProviderId, context);
+}

package/src/resolvers/mutations/orders/signPaymentProviderForCheckout.ts

@@ -0,0 +1,55 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+
+import {
+  InvalidIdError,
+  OrderPaymentConfigurationError,
+  OrderPaymentNotFoundError,
+  OrderPaymentTypeError,
+} from '../../../errors';
+
+export default async function signPaymentProviderForCheckout(
+  root: Root,
+  params: { orderPaymentId: string; transactionContext: any },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { orderPaymentId, transactionContext } = params;
+
+  log(`mutation signPaymentProviderForCheckout ${orderPaymentId}`, {
+    userId,
+  });
+
+  if (!orderPaymentId) throw new InvalidIdError({ orderPaymentId });
+
+  const orderPayment = await modules.orders.payments.findOrderPayment({
+    orderPaymentId,
+  });
+  if (!orderPayment) throw new OrderPaymentNotFoundError({ orderPaymentId });
+
+  const provider = await modules.payment.paymentProviders.findProvider({
+    paymentProviderId: orderPayment.paymentProviderId,
+  });
+  const providerType = provider?.type;
+
+  if (providerType !== PaymentProviderType.GENERIC)
+    throw new OrderPaymentTypeError({
+      orderPaymentId,
+      received: providerType,
+      required: PaymentProviderType.GENERIC,
+    });
+
+  try {
+    return modules.payment.paymentProviders.sign(
+      provider._id,
+      {
+        orderPayment,
+        transactionContext,
+      },
+      context,
+    );
+  } catch (error) {
+    throw new OrderPaymentConfigurationError(error);
+  }
+}

package/src/resolvers/mutations/orders/updateCart.ts

@@ -0,0 +1,46 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { Address, Contact } from '@unchainedshop/types/common';
+import { getOrderCart } from '../utils/getOrderCart';
+
+interface UpdateCartParams {
+  orderId?: string;
+  billingAddress?: Address;
+  contact?: Contact;
+  paymentProviderId?: string;
+  deliveryProviderId?: string;
+  meta?: any;
+}
+
+export default async function updateCart(root: Root, params: UpdateCartParams, context: Context) {
+  const { orderId, billingAddress, contact, paymentProviderId, deliveryProviderId, meta } = params;
+
+  const { modules, userId, user } = context;
+
+  log('mutation updateCart', { userId });
+
+  let order = await getOrderCart({ orderId, user }, context);
+
+  if (meta) {
+    await modules.orders.updateContext(order._id, meta, context);
+    order = await modules.orders.findOrder({ orderId: order._id });
+  }
+
+  if (billingAddress) {
+    order = await modules.orders.updateBillingAddress(order._id, billingAddress, context);
+  }
+
+  if (contact) {
+    order = await modules.orders.updateContact(order._id, contact, context);
+  }
+
+  if (paymentProviderId) {
+    order = await modules.orders.setPaymentProvider(order._id, paymentProviderId, context);
+  }
+
+  if (deliveryProviderId) {
+    order = await modules.orders.setDeliveryProvider(order._id, deliveryProviderId, context);
+  }
+
+  return order;
+}

package/src/resolvers/mutations/orders/updateCartItem.ts

@@ -0,0 +1,53 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { Configuration } from '@unchainedshop/types/common';
+import {
+  OrderQuantityTooLowError,
+  OrderItemNotFoundError,
+  OrderWrongStatusError,
+  ProductNotFoundError,
+  InvalidIdError,
+} from '../../../errors';
+
+export default async function updateCartItem(
+  root: Root,
+  params: {
+    itemId: string;
+    quantity?: number;
+    configuration?: Configuration;
+  },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { itemId, configuration = null, quantity = null } = params;
+
+  log(`mutation updateCartItem ${itemId} ${quantity} ${JSON.stringify(configuration)}`, { userId });
+
+  if (!itemId) throw new InvalidIdError({ itemId });
+
+  const item = await modules.orders.positions.findOrderPosition({ itemId });
+  if (!item) throw new OrderItemNotFoundError({ itemId });
+
+  const order = await modules.orders.findOrder({ orderId: item.orderId });
+  if (!modules.orders.isCart(order)) {
+    throw new OrderWrongStatusError({ status: order.status });
+  }
+
+  const productId = item.originalProductId || item.productId;
+  const product = await modules.products.findProduct({
+    productId,
+  });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  if (quantity !== null && quantity < 1) throw new OrderQuantityTooLowError({ quantity });
+
+  return modules.orders.positions.updateProductItem(
+    { quantity, configuration },
+    {
+      order,
+      product,
+      orderPosition: item,
+    },
+    context,
+  );
+}

package/src/resolvers/mutations/orders/updateOrderDeliveryPickUp.ts

@@ -0,0 +1,48 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError, OrderDeliveryNotFoundError, OrderDeliveryTypeError } from '../../../errors';
+
+export default async function updateOrderDeliveryPickUp(
+  root: Root,
+  params: { orderDeliveryId: string; orderPickUpLocationId: string; meta: any },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { orderDeliveryId, orderPickUpLocationId, meta } = params;
+  log(`mutation updateOrderDeliveryPickUp ${orderDeliveryId} with location ${orderPickUpLocationId}`, {
+    userId,
+  });
+
+  if (!orderDeliveryId) throw new InvalidIdError({ orderDeliveryId });
+
+  const orderDelivery = await modules.orders.deliveries.findDelivery({
+    orderDeliveryId,
+  });
+  if (!orderDelivery) throw new OrderDeliveryNotFoundError({ orderDeliveryId });
+
+  const provider = await modules.delivery.findProvider({
+    deliveryProviderId: orderDelivery.deliveryProviderId,
+  });
+  const deliveryProviderType = provider?.type;
+
+  if (deliveryProviderType !== DeliveryProviderType.PICKUP)
+    throw new OrderDeliveryTypeError({
+      orderDeliveryId,
+      received: deliveryProviderType,
+      required: DeliveryProviderType.PICKUP,
+    });
+
+  await modules.orders.deliveries.updateContext(
+    orderDeliveryId,
+    {
+      orderPickUpLocationId,
+      meta,
+    },
+    context,
+  );
+
+  return modules.orders.deliveries.findDelivery({
+    orderDeliveryId,
+  });
+}

package/src/resolvers/mutations/orders/updateOrderDeliveryShipping.ts

@@ -0,0 +1,40 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { OrderDeliveryNotFoundError, InvalidIdError, OrderDeliveryTypeError } from '../../../errors';
+
+export default async function updateOrderDeliveryShipping(
+  root: Root,
+  params: { orderDeliveryId: string; address: any; meta: any },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { orderDeliveryId, address, meta } = params;
+
+  log(`mutation updateOrderDeliveryShipping ${orderDeliveryId}`, { userId });
+
+  if (!orderDeliveryId) throw new InvalidIdError({ orderDeliveryId });
+
+  const orderDelivery = await modules.orders.deliveries.findDelivery({
+    orderDeliveryId,
+  });
+  if (!orderDelivery) throw new OrderDeliveryNotFoundError({ orderDeliveryId });
+
+  const provider = await modules.delivery.findProvider({
+    deliveryProviderId: orderDelivery.deliveryProviderId,
+  });
+  const deliveryProviderType = provider?.type;
+
+  if (deliveryProviderType !== DeliveryProviderType.SHIPPING)
+    throw new OrderDeliveryTypeError({
+      orderDeliveryId,
+      received: deliveryProviderType,
+      required: DeliveryProviderType.SHIPPING,
+    });
+
+  await modules.orders.deliveries.updateContext(orderDeliveryId, { address, meta }, context);
+
+  return modules.orders.deliveries.findDelivery({
+    orderDeliveryId,
+  });
+}

package/src/resolvers/mutations/orders/updateOrderPaymentCard.ts

@@ -0,0 +1,39 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { OrderPaymentNotFoundError, InvalidIdError, OrderPaymentTypeError } from '../../../errors';
+
+export default async function updateOrderPaymentCard(
+  root: Root,
+  { orderPaymentId, meta }: { orderPaymentId: string; meta?: any },
+  context: Context,
+) {
+  const { modules, userId } = context;
+
+  log(`mutation updateOrderPaymentCard ${orderPaymentId} ${JSON.stringify(meta)}`, { userId });
+
+  if (!orderPaymentId) throw new InvalidIdError({ orderPaymentId });
+
+  const orderPayment = await modules.orders.payments.findOrderPayment({
+    orderPaymentId,
+  });
+  if (!orderPayment) throw new OrderPaymentNotFoundError({ data: { orderPaymentId } });
+
+  const provider = await modules.payment.paymentProviders.findProvider({
+    paymentProviderId: orderPayment.paymentProviderId,
+  });
+  const providerType = provider?.type;
+
+  if (providerType !== PaymentProviderType.CARD)
+    throw new OrderPaymentTypeError({
+      orderPaymentId,
+      received: providerType,
+      required: PaymentProviderType.CARD,
+    });
+
+  await modules.orders.payments.updateContext(orderPayment._id, { meta }, context);
+
+  return modules.orders.payments.findOrderPayment({
+    orderPaymentId,
+  });
+}

package/src/resolvers/mutations/orders/updateOrderPaymentGeneric.ts

@@ -0,0 +1,40 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { OrderPaymentNotFoundError, InvalidIdError, OrderPaymentTypeError } from '../../../errors';
+
+export default async function updateOrderPaymentGeneric(
+  root: Root,
+  { orderPaymentId, meta }: { orderPaymentId: string; meta?: any },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  log(`mutation updateOrderPaymentGeneric ${orderPaymentId} ${JSON.stringify(meta)}`, {
+    userId,
+  });
+
+  if (!orderPaymentId) throw new InvalidIdError({ orderPaymentId });
+
+  const orderPayment = await modules.orders.payments.findOrderPayment({
+    orderPaymentId,
+  });
+  if (!orderPayment) throw new OrderPaymentNotFoundError({ data: { orderPaymentId } });
+
+  const provider = await modules.payment.paymentProviders.findProvider({
+    paymentProviderId: orderPayment.paymentProviderId,
+  });
+  const providerType = provider?.type;
+
+  if (providerType !== PaymentProviderType.GENERIC)
+    throw new OrderPaymentTypeError({
+      orderPaymentId,
+      received: providerType,
+      required: PaymentProviderType.GENERIC,
+    });
+
+  await modules.orders.payments.updateContext(orderPayment._id, { meta }, context);
+
+  return modules.orders.payments.findOrderPayment({
+    orderPaymentId,
+  });
+}

package/src/resolvers/mutations/orders/updateOrderPaymentInvoice.ts

@@ -0,0 +1,40 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { OrderPaymentNotFoundError, InvalidIdError, OrderPaymentTypeError } from '../../../errors';
+
+export default async function updateOrderPaymentInvoice(
+  root: Root,
+  { orderPaymentId, meta }: { orderPaymentId: string; meta?: any },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  log(`mutation updateOrderPaymentInvoice ${orderPaymentId} ${JSON.stringify(meta)}`, {
+    userId,
+  });
+
+  if (!orderPaymentId) throw new InvalidIdError({ orderPaymentId });
+
+  const orderPayment = await modules.orders.payments.findOrderPayment({
+    orderPaymentId,
+  });
+  if (!orderPayment) throw new OrderPaymentNotFoundError({ data: { orderPaymentId } });
+
+  const provider = await modules.payment.paymentProviders.findProvider({
+    paymentProviderId: orderPayment.paymentProviderId,
+  });
+  const providerType = provider?.type;
+
+  if (providerType !== PaymentProviderType.INVOICE)
+    throw new OrderPaymentTypeError({
+      orderPaymentId,
+      received: providerType,
+      required: PaymentProviderType.INVOICE,
+    });
+
+  await modules.orders.payments.updateContext(orderPayment._id, { meta }, context);
+
+  return modules.orders.payments.findOrderPayment({
+    orderPaymentId,
+  });
+}

package/src/resolvers/mutations/pageView.js

@@ -0,0 +1,13 @@
+import { log } from '@unchainedshop/logger';
+import { emit } from '@unchainedshop/events';
+
+export default (root, { path, referrer }, { userId }) => {
+  log(`mutation pageView ${path} ${referrer}`, { userId });
+
+  emit('PAGE_VIEW', {
+    path,
+    referrer,
+  });
+
+  return path;
+};

package/src/resolvers/mutations/payment/createPaymentProvider.ts

@@ -0,0 +1,24 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { PaymentProvider } from '@unchainedshop/types/payments';
+import { log } from '@unchainedshop/logger';
+import { ProviderConfigurationInvalid } from '../../../errors';
+
+export default async (
+  root: Root,
+  { paymentProvider }: { paymentProvider: PaymentProvider },
+  { modules, userId }: Context,
+) => {
+  log('mutation createPaymentProvider', { userId });
+
+  const provider = await modules.payment.paymentProviders.create(
+    {
+      ...paymentProvider,
+      authorId: userId,
+    },
+    userId,
+  );
+
+  if (!provider) throw new ProviderConfigurationInvalid(paymentProvider);
+
+  return provider;
+};