@unchainedshop/api 1.1.3

package/src/resolvers/mutations/products/removeProductVariationOption.ts

@@ -0,0 +1,32 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { InvalidIdError, ProductVariationNotFoundError } from '../../../errors';
+
+export default async function removeProductVariationOption(
+  root: Root,
+  params: { productVariationId: string; productVariationOptionValue: string },
+  { modules, userId }: Context,
+) {
+  const { productVariationId, productVariationOptionValue } = params;
+
+  log(`mutation removeProductVariationOption ${productVariationId} ${productVariationOptionValue}`, {
+    userId,
+  });
+
+  if (!productVariationId) throw new InvalidIdError({ productVariationId });
+
+  const productVariation = await modules.products.variations.findProductVariation({
+    productVariationId,
+  });
+  if (!productVariation) throw new ProductVariationNotFoundError({ productVariationId });
+
+  await modules.products.variations.removeVariationOption(
+    productVariationId,
+    productVariationOptionValue,
+    userId,
+  );
+
+  return modules.products.variations.findProductVariation({
+    productVariationId,
+  });
+}

package/src/resolvers/mutations/products/reorderProductMedia.ts

@@ -0,0 +1,14 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function reorderProductMedia(
+  root: Root,
+  params: { sortKeys: Array<{ productMediaId: string; sortKey: number }> },
+  { modules, userId }: Context,
+) {
+  const { sortKeys = [] } = params;
+
+  log('mutation reorderProductMedia', { userId });
+
+  return modules.products.media.updateManualOrder({ sortKeys }, userId);
+}

package/src/resolvers/mutations/products/unpublishProduct.ts

@@ -0,0 +1,22 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { ProductNotFoundError, ProductWrongStatusError, InvalidIdError } from '../../../errors';
+
+export default async function unpublishProduct(
+  root: Root,
+  { productId }: { productId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation unpublishProduct ${productId}`, { userId });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  if (!(await modules.products.unpublish(product, userId))) {
+    throw new ProductWrongStatusError({ status: product.status });
+  }
+
+  return modules.products.findProduct({ productId });
+}

package/src/resolvers/mutations/products/updateProduct.ts

@@ -0,0 +1,21 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { Product } from '@unchainedshop/types/products';
+import { ProductNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function updateProduct(
+  root: Root,
+  { product, productId }: { product: Product; productId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation updateProduct ${productId}`, { userId });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  if (!(await modules.products.productExists({ productId })))
+    throw new ProductNotFoundError({ productId });
+
+  await modules.products.update(productId, product, userId);
+
+  return modules.products.findProduct({ productId });
+}

package/src/resolvers/mutations/products/updateProductCommerce.ts

@@ -0,0 +1,21 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { ProductCommerce } from '@unchainedshop/types/products';
+import { ProductNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function updateProductCommerce(
+  root: Root,
+  { commerce, productId }: { commerce: ProductCommerce; productId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation updateProductCommerce ${productId}`, { userId });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  if (!(await modules.products.productExists({ productId })))
+    throw new ProductNotFoundError({ productId });
+
+  await modules.products.update(productId, { commerce }, userId);
+
+  return modules.products.findProduct({ productId });
+}

package/src/resolvers/mutations/products/updateProductMediaTexts.ts

@@ -0,0 +1,21 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { ProductMediaText } from '@unchainedshop/types/products.media';
+import { ProductMediaNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function updateProductMediaTexts(
+  root: Root,
+  { productMediaId, texts }: { productMediaId: string; texts: Array<ProductMediaText> },
+  { modules, userId }: Context,
+) {
+  log(`mutation updateProductMediaTexts ${productMediaId}`, { userId });
+
+  if (!productMediaId) throw new InvalidIdError({ productMediaId });
+
+  const productMedia = await modules.products.media.findProductMedia({
+    productMediaId,
+  });
+  if (!productMedia) throw new ProductMediaNotFoundError({ productMediaId });
+
+  return modules.products.media.texts.updateMediaTexts(productMediaId, texts, userId);
+}

package/src/resolvers/mutations/products/updateProductPlan.ts

@@ -0,0 +1,28 @@
+import { log } from '@unchainedshop/logger';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { Context, Root } from '@unchainedshop/types/api';
+import { ProductPlan } from '@unchainedshop/types/products';
+import { ProductNotFoundError, InvalidIdError, ProductWrongStatusError } from '../../../errors';
+
+export default async function updateProductPlan(
+  root: Root,
+  { plan, productId }: { plan: ProductPlan; productId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation updateProductPlan ${productId}`, { userId });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  if (product?.type !== ProductTypes.PlanProduct)
+    throw new ProductWrongStatusError({
+      received: product?.type,
+      required: ProductTypes.PlanProduct,
+    });
+
+  await modules.products.update(productId, { plan }, userId);
+
+  return modules.products.findProduct({ productId });
+}

package/src/resolvers/mutations/products/updateProductReview.ts

@@ -0,0 +1,21 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { ProductReview } from '@unchainedshop/types/products.reviews';
+import { ProductReviewNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function updateProductReview(
+  root: Root,
+  params: { productReviewId: string; productReview: ProductReview },
+  { modules, userId }: Context,
+) {
+  const { productReviewId, productReview } = params;
+
+  log('mutation updateProductReview', { userId, productReviewId });
+
+  if (!productReviewId) throw new InvalidIdError({ productReviewId });
+
+  if (!(await modules.products.reviews.reviewExists({ productReviewId })))
+    throw new ProductReviewNotFoundError({ productReviewId });
+
+  return modules.products.reviews.update(productReviewId, productReview, userId);
+}

package/src/resolvers/mutations/products/updateProductSupply.ts

@@ -0,0 +1,30 @@
+import { log } from '@unchainedshop/logger';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { Context, Root } from '@unchainedshop/types/api';
+
+import { ProductSupply } from '@unchainedshop/types/products';
+import { ProductNotFoundError, InvalidIdError, ProductWrongTypeError } from '../../../errors';
+
+export default async function updateProductSupply(
+  root: Root,
+  { supply, productId }: { supply: ProductSupply; productId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation updateProductSupply ${productId}`, { userId });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  if (product?.type !== ProductTypes.SimpleProduct)
+    throw new ProductWrongTypeError({
+      productId,
+      received: product?.type,
+      required: ProductTypes.SimpleProduct,
+    });
+
+  await modules.products.update(productId, { supply }, userId);
+
+  return modules.products.findProduct({ productId });
+}

package/src/resolvers/mutations/products/updateProductTexts.ts

@@ -0,0 +1,20 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { ProductNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function updateProductTexts(
+  root: Root,
+  { texts, productId },
+  { modules, userId }: Context,
+) {
+  log(`mutation updateProductTexts ${productId}`, { userId });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  const productTexts = await modules.products.texts.updateTexts(productId, texts, userId);
+
+  return productTexts;
+}

package/src/resolvers/mutations/products/updateProductVariationTexts.ts

@@ -0,0 +1,32 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { ProductVariationText } from '@unchainedshop/types/products.variations';
+import { ProductVariationNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function F(
+  root: Root,
+  params: {
+    productVariationId: string;
+    productVariationOptionValue?: string;
+    texts: Array<ProductVariationText>;
+  },
+  { modules, userId }: Context,
+) {
+  const { productVariationId, productVariationOptionValue, texts } = params;
+
+  log(`mutation updateProductVariationTexts ${productVariationId}`, { userId });
+
+  if (!productVariationId) throw new InvalidIdError({ productVariationId });
+
+  const productVariation = await modules.products.variations.findProductVariation({
+    productVariationId,
+  });
+  if (!productVariation) throw new ProductVariationNotFoundError({ productVariationId });
+
+  return modules.products.variations.texts.updateVariationTexts(
+    productVariationId,
+    texts,
+    productVariationOptionValue,
+    userId,
+  );
+}

package/src/resolvers/mutations/products/updateProductWarehousing.ts

@@ -0,0 +1,30 @@
+import { log } from '@unchainedshop/logger';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { Context, Root } from '@unchainedshop/types/api';
+
+import { ProductWarehousing } from '@unchainedshop/types/products';
+import { ProductNotFoundError, InvalidIdError, ProductWrongTypeError } from '../../../errors';
+
+export default async function updateProductWarehousing(
+  root: Root,
+  { warehousing, productId }: { warehousing: ProductWarehousing; productId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation updateProductWarehousing ${productId}`, { userId });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  if (product?.type !== ProductTypes.SimpleProduct)
+    throw new ProductWrongTypeError({
+      productId,
+      received: product.type,
+      required: ProductTypes.SimpleProduct,
+    });
+
+  await modules.products.update(productId, { warehousing }, userId);
+
+  return modules.products.findProduct({ productId });
+}

package/src/resolvers/mutations/quotations/makeQuotationProposal.ts

@@ -0,0 +1,26 @@
+import { log } from '@unchainedshop/logger';
+import { QuotationStatus } from '@unchainedshop/core-quotations';
+import { Context, Root } from '@unchainedshop/types/api';
+import { QuotationNotFoundError, QuotationWrongStatusError, InvalidIdError } from '../../../errors';
+
+export default async function makeQuotationProposal(
+  root: Root,
+  params: { quotationId: string; quotationContext?: any },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { quotationId, ...transactionContext } = params;
+
+  log('mutation makeQuotationProposal', { quotationId, userId });
+
+  if (!quotationId) throw new InvalidIdError({ quotationId });
+
+  const quotation = await modules.quotations.findQuotation({ quotationId });
+  if (!quotation) throw new QuotationNotFoundError({ quotationId });
+
+  if (quotation.status !== QuotationStatus.PROCESSING) {
+    throw new QuotationWrongStatusError({ status: quotation.status });
+  }
+
+  return modules.quotations.proposeQuotation(quotation, transactionContext, context);
+}

package/src/resolvers/mutations/quotations/rejectQuotation.ts

@@ -0,0 +1,26 @@
+import { log } from '@unchainedshop/logger';
+import { QuotationStatus } from '@unchainedshop/core-quotations';
+import { Context, Root } from '@unchainedshop/types/api';
+import { QuotationNotFoundError, QuotationWrongStatusError, InvalidIdError } from '../../../errors';
+
+export default async function rejectQuotation(
+  root: Root,
+  params: { quotationId: string; quotationContext?: any },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { quotationId, ...transactionContext } = params;
+
+  log('mutation rejectQuotation', { quotationId, userId });
+
+  if (!quotationId) throw new InvalidIdError({ quotationId });
+
+  const quotation = await modules.quotations.findQuotation({ quotationId });
+  if (!quotation) throw new QuotationNotFoundError({ quotationId });
+
+  if (quotation.status === QuotationStatus.FULLFILLED) {
+    throw new QuotationWrongStatusError({ status: quotation.status });
+  }
+
+  return modules.quotations.rejectQuotation(quotation, transactionContext, context);
+}

package/src/resolvers/mutations/quotations/requestQuotation.ts

@@ -0,0 +1,32 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { Configuration } from '@unchainedshop/types/common';
+import { ProductNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function requestQuotation(
+  root: Root,
+  params: { productId: string; configuration: Configuration },
+  context: Context,
+) {
+  const { countryContext, modules, userId } = context;
+  const { productId, configuration } = params;
+
+  log(`mutation requestQuotation ${productId} ${configuration ? JSON.stringify(configuration) : ''}`, {
+    userId,
+  });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  if (!(await modules.products.productExists({ productId })))
+    throw new ProductNotFoundError({ productId });
+
+  return modules.quotations.create(
+    {
+      userId,
+      productId,
+      countryCode: countryContext,
+      configuration,
+    },
+    context,
+  );
+}

package/src/resolvers/mutations/quotations/verifyQuotation.ts

@@ -0,0 +1,26 @@
+import { log } from '@unchainedshop/logger';
+import { QuotationStatus } from '@unchainedshop/core-quotations';
+import { Context, Root } from '@unchainedshop/types/api';
+import { QuotationNotFoundError, QuotationWrongStatusError, InvalidIdError } from '../../../errors';
+
+export default async function verifyQuotation(
+  root: Root,
+  params: { quotationId: string; quotationContext?: any },
+  context: Context,
+) {
+  const { modules, userId } = context;
+  const { quotationId, ...transactionContext } = params;
+
+  log('mutation verifyQuotation', { quotationId, userId });
+
+  if (!quotationId) throw new InvalidIdError({ quotationId });
+
+  const quotation = await modules.quotations.findQuotation({ quotationId });
+  if (!quotation) throw new QuotationNotFoundError({ quotationId });
+
+  if (quotation.status !== QuotationStatus.REQUESTED) {
+    throw new QuotationWrongStatusError({ status: quotation.status });
+  }
+
+  return modules.quotations.verifyQuotation(quotation, transactionContext, context);
+}

package/src/resolvers/mutations/users/heartbeat.ts

@@ -0,0 +1,27 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { UserNotFoundError } from '../../../errors';
+
+export default async function heartbeat(
+  root: Root,
+  _: any,
+  { countryContext, localeContext, modules, remoteAddress, remotePort, userAgent, userId }: Context,
+) {
+  log(`mutation heartbeat ${remoteAddress}`, { userId });
+
+  if (!userId) throw new UserNotFoundError({ userId });
+
+  if (!(await modules.users.userExists({ userId }))) {
+    throw new UserNotFoundError({ userId });
+  }
+
+  const user = await modules.users.updateHeartbeat(userId, {
+    countryContext,
+    locale: localeContext.normalized,
+    remoteAddress,
+    remotePort,
+    userAgent,
+  });
+
+  return user;
+}

package/src/resolvers/mutations/users/prepareUserAvatarUpload.ts

@@ -0,0 +1,26 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+
+export default async function prepareUserAvatarUpload(
+  root: Root,
+  params: { mediaName: string; userId: string },
+  context: Context,
+) {
+  const { services, userId } = context;
+  const normalizedUserId = params.userId || userId;
+
+  log(`mutation prepareUserAvatarUpload ${normalizedUserId}`, {
+    mediaName: params.mediaName,
+    userId,
+  });
+
+  return services.files.createSignedURL(
+    {
+      directoryName: 'user-avatars',
+      fileName: params.mediaName,
+      meta: { userId: normalizedUserId },
+      userId,
+    },
+    context,
+  );
+}

package/src/resolvers/mutations/users/setRoles.ts

@@ -0,0 +1,19 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError, UserNotFoundError } from '../../../errors';
+
+export default async function updateUserProfile(
+  root: Root,
+  params: { roles: Array<string>; userId: string },
+  { modules, userId }: Context,
+) {
+  const foreignUserId = params.userId;
+
+  log(`mutation setRoles ${foreignUserId}`, { userId });
+
+  if (!foreignUserId) throw new InvalidIdError({ foreignUserId });
+  if (!(await modules.users.userExists({ userId: foreignUserId })))
+    throw new UserNotFoundError({ userId: foreignUserId });
+
+  return modules.users.updateRoles(foreignUserId, params.roles, userId);
+}

package/src/resolvers/mutations/users/setUserTags.ts

@@ -0,0 +1,19 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError, UserNotFoundError } from '../../../errors';
+
+export default async function updateUserProfile(
+  root: Root,
+  params: { tags: Array<string>; userId: string },
+  { modules, userId }: Context,
+) {
+  const normalizedUserId = params.userId;
+
+  log(`mutation setUserTags ${normalizedUserId}`, { userId });
+
+  if (!normalizedUserId) throw new InvalidIdError({ normalizedUserId });
+  if (!(await modules.users.userExists({ userId: normalizedUserId })))
+    throw new UserNotFoundError({ userId: normalizedUserId });
+
+  return modules.users.updateTags(normalizedUserId, params.tags, userId);
+}

package/src/resolvers/mutations/users/updateUserAvatar.ts

@@ -0,0 +1,40 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { UserNotFoundError } from '../../../errors';
+
+export default async function updateUserAvatar(
+  root: Root,
+  params: { avatar: any; userId: string },
+  context: Context,
+) {
+  const { modules, services, userId } = context;
+  const normalizedUserId = params.userId || userId;
+
+  log(`mutation updateUserAvatar ${normalizedUserId}`, { userId });
+
+  if (!(await modules.users.userExists({ userId: normalizedUserId })))
+    throw new UserNotFoundError({ userId: normalizedUserId });
+
+  const user = await modules.users.findUserById(normalizedUserId);
+
+  const file = await services.files.uploadFileFromStream(
+    {
+      directoryName: 'user-avatars',
+      rawFile: params.avatar,
+      meta: { userId: normalizedUserId },
+      userId,
+    },
+    context,
+  );
+
+  if (user?.avatarId) {
+    await services.files.removeFiles(
+      {
+        fileIds: [user.avatarId as string],
+      },
+      context,
+    );
+  }
+
+  return modules.users.updateAvatar(normalizedUserId, file._id, userId);
+}

package/src/resolvers/mutations/users/updateUserProfile.ts

@@ -0,0 +1,20 @@
+import { log } from '@unchainedshop/logger';
+import { UserProfile } from '@unchainedshop/types/user';
+import { Context, Root } from '@unchainedshop/types/api';
+import { UserNotFoundError } from '../../../errors';
+
+export default async function updateUserProfile(
+  root: Root,
+  params: { profile: UserProfile; meta?: any; userId: string },
+  { modules, userId }: Context,
+) {
+  const { userId: paramUserId, ...profile } = params;
+  const normalizedUserId = paramUserId || userId;
+
+  log(`mutation updateUserProfile ${normalizedUserId}`, { userId });
+
+  if (!(await modules.users.userExists({ userId: normalizedUserId })))
+    throw UserNotFoundError({ id: normalizedUserId });
+
+  return modules.users.updateProfile(normalizedUserId, profile, userId);
+}

package/src/resolvers/mutations/utils/getOrderCart.ts

@@ -0,0 +1,21 @@
+import { Context } from '@unchainedshop/types/api';
+import { User } from '@unchainedshop/types/user';
+import { OrderNotFoundError, OrderWrongStatusError } from '../../../errors';
+
+export const getOrderCart = async (params: { orderId?: string; user: User }, context: Context) => {
+  const { countryContext, modules, services } = context;
+  const { orderId, user } = params;
+
+  if (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 });
+    return order;
+  }
+
+  const cart = await modules.orders.cart({ countryContext }, user);
+  if (cart) return cart;
+
+  return services.orders.createUserCart({ user }, context);
+};

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

@@ -0,0 +1,24 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { WarehousingProvider } from '@unchainedshop/types/warehousing';
+import { ProviderConfigurationInvalid } from '../../../errors';
+
+export default async function createWarehousingProvider(
+  root: Root,
+  params: { warehousingProvider: WarehousingProvider },
+  { modules, userId }: Context,
+) {
+  log('mutation createWarehousingProvider', { userId });
+
+  const warehousingProviderId = await modules.warehousing.create(
+    {
+      ...params.warehousingProvider,
+      authorId: userId,
+    },
+    userId,
+  );
+
+  if (!warehousingProviderId) throw new ProviderConfigurationInvalid(params.warehousingProvider);
+
+  return modules.warehousing.findProvider({ warehousingProviderId });
+}

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

@@ -0,0 +1,22 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError, WarehousingProviderNotFoundError } from '../../../errors';
+
+export default async function removeWarehousingProvider(
+  root: Root,
+  { warehousingProviderId }: { warehousingProviderId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation removeWarehousingProvider ${warehousingProviderId}`, {
+    userId,
+  });
+
+  if (!warehousingProviderId) throw new InvalidIdError({ warehousingProviderId });
+
+  const provider = await modules.warehousing.findProvider({
+    warehousingProviderId,
+  });
+  if (!provider) throw new WarehousingProviderNotFoundError({ warehousingProviderId });
+
+  return modules.warehousing.delete(warehousingProviderId, userId);
+}