@unchainedshop/api 1.1.3

package/src/resolvers/mutations/assortments/addAssortmentLink.ts

@@ -0,0 +1,45 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentLink } from '@unchainedshop/types/assortments';
+import { log } from '@unchainedshop/logger';
+import { AssortmentNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function addAssortmentLink(
+  root: Root,
+  { parentAssortmentId, childAssortmentId, ...assortmentLink }: AssortmentLink,
+  { modules, userId }: Context,
+) {
+  log(`mutation addAssortmentLink ${parentAssortmentId} -> ${childAssortmentId}`, { userId });
+  if (!parentAssortmentId) throw new InvalidIdError({ parentAssortmentId });
+  if (!childAssortmentId) throw new InvalidIdError({ childAssortmentId });
+
+  if (
+    !(await modules.assortments.assortmentExists({
+      assortmentId: parentAssortmentId,
+    }))
+  )
+    throw new AssortmentNotFoundError({
+      assortmentId: parentAssortmentId,
+    });
+
+  if (
+    !(await modules.assortments.assortmentExists({
+      assortmentId: childAssortmentId,
+    }))
+  )
+    throw new AssortmentNotFoundError({
+      assortmentId: childAssortmentId,
+    });
+
+  return modules.assortments.links.create(
+    {
+      parentAssortmentId,
+      childAssortmentId,
+      authorId: userId,
+      ...assortmentLink,
+    },
+    {
+      skipInvalidation: false,
+    },
+    userId,
+  );
+}

package/src/resolvers/mutations/assortments/addAssortmentMedia.ts

@@ -0,0 +1,30 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function addAssortmentMedia(root: Root, { media, assortmentId }, context: Context) {
+  const { modules, services, userId } = context;
+  log(`mutation addAssortmentMedia ${assortmentId}`, { userId });
+
+  if (!assortmentId) throw new InvalidIdError({ assortmentId });
+
+  if (!(await modules.assortments.assortmentExists({ assortmentId })))
+    throw new AssortmentNotFoundError({ assortmentId });
+
+  const file = await services.files.uploadFileFromStream(
+    {
+      directoryName: 'assortment-media',
+      rawFile: media,
+      meta: { authorId: userId },
+      userId,
+    },
+    context,
+  );
+
+  const assortmentMedia = await modules.assortments.media.create(
+    { assortmentId, mediaId: file._id },
+    userId,
+  );
+
+  return assortmentMedia;
+}

package/src/resolvers/mutations/assortments/addAssortmentProduct.ts

@@ -0,0 +1,36 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentProduct } from '@unchainedshop/types/assortments';
+import { AssortmentNotFoundError, ProductNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function addAssortmentProduct(
+  root: Root,
+  { assortmentId, productId, ...assortmentProduct }: AssortmentProduct,
+  { modules, userId }: Context,
+) {
+  log(`mutation addAssortmentProduct ${assortmentId} -> ${productId}`, {
+    userId,
+  });
+
+  if (!assortmentId) throw new InvalidIdError({ assortmentId });
+  if (!productId) throw new InvalidIdError({ productId });
+
+  if (!(await modules.assortments.assortmentExists({ assortmentId })))
+    throw new AssortmentNotFoundError({
+      assortmentId,
+    });
+
+  if (!(await modules.products.productExists({ productId })))
+    throw new ProductNotFoundError({ productId });
+
+  return modules.assortments.products.create(
+    {
+      assortmentId,
+      productId,
+      authorId: userId,
+      ...assortmentProduct,
+    },
+    { skipInvalidation: false },
+    userId,
+  );
+}

package/src/resolvers/mutations/assortments/createAssortment.ts

@@ -0,0 +1,22 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { Assortment } from '@unchainedshop/types/assortments';
+
+export default async function createAssortment(
+  root: Root,
+  { assortment }: { assortment: Assortment & { title: string; locale?: string } },
+  { modules, userId, localeContext }: Context,
+) {
+  log('mutation createAssortment', { userId });
+
+  const assortmentId = await modules.assortments.create(
+    {
+      ...assortment,
+      locale: localeContext.language,
+      authorId: userId,
+    },
+    userId,
+  );
+
+  return modules.assortments.findAssortment({ assortmentId });
+}

package/src/resolvers/mutations/assortments/prepareAssortmentMediaUpload.ts

@@ -0,0 +1,23 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+
+export default async function prepareAssortmentMediaUpload(
+  root: Root,
+  { mediaName, assortmentId }: { mediaName: string; assortmentId: string },
+  context: Context,
+) {
+  const { services, userId } = context;
+  log('mutation prepareAssortmentMediaUpload', { mediaName, userId });
+
+  const preparedFile = await services.files.createSignedURL(
+    {
+      directoryName: 'assortment-media',
+      fileName: mediaName,
+      meta: { assortmentId },
+      userId,
+    },
+    context,
+  );
+
+  return preparedFile;
+}

package/src/resolvers/mutations/assortments/removeAssortment.ts

@@ -0,0 +1,20 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function removeAssortment(
+  root: Root,
+  { assortmentId }: { assortmentId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation removeAssortment ${assortmentId}`, { userId });
+
+  if (!assortmentId) throw new InvalidIdError({ assortmentId });
+
+  const assortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  await modules.assortments.delete(assortmentId, { skipInvalidation: false }, userId);
+
+  return assortment;
+}

package/src/resolvers/mutations/assortments/removeAssortmentFilter.ts

@@ -0,0 +1,24 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentFilterNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function removeAssortmentFilter(
+  root: Root,
+  { assortmentFilterId }: { assortmentFilterId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation removeAssortmentFilter ${assortmentFilterId}`, {
+    userId,
+  });
+  if (!assortmentFilterId) throw new InvalidIdError({ assortmentFilterId });
+
+  const assortmentFilter = await modules.assortments.filters.findFilter({
+    assortmentFilterId,
+  });
+
+  if (!assortmentFilter) throw new AssortmentFilterNotFoundError({ assortmentFilterId });
+
+  await modules.assortments.filters.delete(assortmentFilterId, userId);
+
+  return assortmentFilter;
+}

package/src/resolvers/mutations/assortments/removeAssortmentLink.ts

@@ -0,0 +1,22 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentLinkNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function removeAssortmentLink(
+  root: Root,
+  { assortmentLinkId }: { assortmentLinkId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation removeAssortmentLink ${assortmentLinkId}`, { userId });
+  if (!assortmentLinkId) throw new InvalidIdError({ assortmentLinkId });
+
+  const assortmentLink = await modules.assortments.links.findLink({
+    assortmentLinkId,
+  });
+
+  if (!assortmentLink) throw new AssortmentLinkNotFoundError({ assortmentLinkId });
+
+  await modules.assortments.links.delete(assortmentLinkId, { skipInvalidation: false }, userId);
+
+  return assortmentLink;
+}

package/src/resolvers/mutations/assortments/removeAssortmentMedia.ts

@@ -0,0 +1,25 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentMediaNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function removeAssortmentMedia(
+  root: Root,
+  { assortmentMediaId }: { assortmentMediaId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation removeAssortmentMedia ${assortmentMediaId}`, {
+    userId,
+  });
+
+  if (!assortmentMediaId) throw new InvalidIdError({ assortmentMediaId });
+
+  const assortmentMedia = await modules.assortments.media.findAssortmentMedia({
+    assortmentMediaId,
+  });
+  if (!assortmentMedia) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
+
+  await modules.files.delete(assortmentMedia.mediaId, userId);
+  await modules.assortments.media.delete(assortmentMediaId, userId);
+
+  return assortmentMedia;
+}

package/src/resolvers/mutations/assortments/removeAssortmentProduct.ts

@@ -0,0 +1,24 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentProductNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function removeAssortmentProduct(
+  root: Root,
+  { assortmentProductId }: { assortmentProductId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation removeAssortmentProduct ${assortmentProductId}`, {
+    userId,
+  });
+
+  if (!assortmentProductId) throw new InvalidIdError({ assortmentProductId });
+
+  const assortmentProduct = await modules.assortments.products.findProduct({
+    assortmentProductId,
+  });
+  if (!assortmentProduct) throw new AssortmentProductNotFoundError({ assortmentProductId });
+
+  await modules.assortments.products.delete(assortmentProductId, { skipInvalidation: false }, userId);
+
+  return assortmentProduct;
+}

package/src/resolvers/mutations/assortments/reorderAssortmentFilters.ts

@@ -0,0 +1,17 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function reorderAssortmentFilters(
+  root: Root,
+  params: { sortKeys: Array<{ assortmentFilterId: string; sortKey: number }> },
+  { modules, userId }: Context,
+) {
+  log('mutation reorderAssortmentFilters', { userId });
+
+  return modules.assortments.filters.updateManualOrder(
+    {
+      sortKeys: params.sortKeys,
+    },
+    userId,
+  );
+}

package/src/resolvers/mutations/assortments/reorderAssortmentLinks.ts

@@ -0,0 +1,17 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function reorderAssortmentLinks(
+  root: Root,
+  params: { sortKeys: Array<{ assortmentLinkId: string; sortKey: number }> },
+  { modules, userId }: Context,
+) {
+  log('mutation reorderAssortmentLinks', { userId });
+  return modules.assortments.links.updateManualOrder(
+    {
+      sortKeys: params.sortKeys,
+    },
+    { skipInvalidation: false },
+    userId,
+  );
+}

package/src/resolvers/mutations/assortments/reorderAssortmentMedia.ts

@@ -0,0 +1,16 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function reorderAssortmentMedia(
+  root: Root,
+  params: { sortKeys: Array<{ assortmentMediaId: string; sortKey: number }> },
+  { modules, userId }: Context,
+) {
+  log('mutation reorderAssortmentMedia', { userId });
+  return modules.assortments.media.updateManualOrder(
+    {
+      sortKeys: params.sortKeys,
+    },
+    userId,
+  );
+}

package/src/resolvers/mutations/assortments/reorderAssortmentProducts.ts

@@ -0,0 +1,17 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function reorderAssortmentProducts(
+  root: Root,
+  params: { sortKeys: Array<{ assortmentProductId: string; sortKey: number }> },
+  { modules, userId }: Context,
+) {
+  log('mutation reorderAssortmentProducts', { userId });
+  return modules.assortments.products.updateManualOrder(
+    {
+      sortKeys: params.sortKeys,
+    },
+    { skipInvalidation: false },
+    userId,
+  );
+}

package/src/resolvers/mutations/assortments/setBaseAssortment.ts

@@ -0,0 +1,20 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function setBaseAssortment(
+  root: Root,
+  { assortmentId }: { assortmentId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation setBaseAssortment ${assortmentId}`, { userId });
+
+  if (!assortmentId) throw new InvalidIdError({ assortmentId });
+
+  if (!(await modules.assortments.assortmentExists({ assortmentId })))
+    throw new AssortmentNotFoundError({ assortmentId });
+
+  await modules.assortments.setBase(assortmentId, userId);
+
+  return modules.assortments.findAssortment({ assortmentId });
+}

package/src/resolvers/mutations/assortments/updateAssortment.ts

@@ -0,0 +1,23 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { Assortment } from '@unchainedshop/types/assortments';
+import { AssortmentNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function updateAssortment(
+  root: Root,
+  params: { assortment: Assortment; assortmentId: string },
+  { modules, userId }: Context,
+) {
+  const { assortment, assortmentId } = params;
+
+  log(`mutation updateAssortment ${assortmentId}`, { userId });
+
+  if (!assortmentId) throw new InvalidIdError({ assortmentId });
+
+  if (!(await modules.assortments.assortmentExists({ assortmentId })))
+    throw new AssortmentNotFoundError({ assortmentId });
+
+  await modules.assortments.update(assortmentId, assortment, userId);
+
+  return modules.assortments.findAssortment({ assortmentId });
+}

package/src/resolvers/mutations/assortments/updateAssortmentMediaTexts.ts

@@ -0,0 +1,24 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentMediaText } from '@unchainedshop/types/assortments.media';
+import { log } from '@unchainedshop/logger';
+import { AssortmentMediaNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function updateAssortmentMediaTexts(
+  root: Root,
+  { texts, assortmentMediaId }: { texts: Array<AssortmentMediaText>; assortmentMediaId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation updateAssortmentMediaTexts ${assortmentMediaId}`, {
+    userId,
+  });
+
+  if (!assortmentMediaId) throw new InvalidIdError({ assortmentMediaId });
+
+  const assortmentMedia = await modules.assortments.media.findAssortmentMedia({
+    assortmentMediaId,
+  });
+
+  if (!assortmentMedia) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
+
+  return modules.assortments.media.texts.updateMediaTexts(assortmentMediaId, texts, userId);
+}

package/src/resolvers/mutations/assortments/updateAssortmentTexts.ts

@@ -0,0 +1,19 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { AssortmentText } from '@unchainedshop/types/assortments';
+import { InvalidIdError, AssortmentNotFoundError } from '../../../errors';
+
+export default async function updateAssortmentTexts(
+  root: Root,
+  { texts, assortmentId }: { texts: Array<AssortmentText>; assortmentId: string },
+  { modules, userId }: Context,
+) {
+  log(`mutation updateAssortmentTexts ${assortmentId}`, { userId });
+
+  if (!assortmentId) throw new InvalidIdError({ assortmentId });
+
+  if (!(await modules.assortments.assortmentExists({ assortmentId })))
+    throw new AssortmentNotFoundError({ assortmentId });
+
+  return modules.assortments.texts.updateTexts(assortmentId, texts, userId);
+}

package/src/resolvers/mutations/bookmarks/bookmark.ts

@@ -0,0 +1,43 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { InvalidIdError, ProductNotFoundError, BookmarkNotFoundError } from '../../../errors';
+
+export default async function bookmark(
+  root: Root,
+  { productId, bookmarked }: { productId: string; bookmarked: string },
+  { userId, modules }: Context,
+) {
+  log('mutation bookmark', { productId, userId });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  if (!(await modules.products.productExists({ productId })))
+    throw new ProductNotFoundError({ productId });
+
+  const foundBookmark = await modules.bookmarks.findByUserIdAndProductId({
+    productId,
+    userId,
+  });
+
+  if (bookmarked) {
+    if (foundBookmark) return foundBookmark;
+
+    const bookmarkId = await modules.bookmarks.create(
+      {
+        productId,
+        userId,
+      },
+      userId,
+    );
+
+    return modules.bookmarks.findById(bookmarkId);
+  }
+
+  if (!foundBookmark) {
+    throw new BookmarkNotFoundError({ productId, userId });
+  }
+
+  await modules.bookmarks.delete(foundBookmark._id, userId);
+
+  return foundBookmark;
+}

package/src/resolvers/mutations/bookmarks/createBookmark.ts

@@ -0,0 +1,34 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { BookmarkAlreadyExistsError, InvalidIdError, ProductNotFoundError } from '../../../errors';
+
+export default async function createBookmark(
+  root: Root,
+  { productId, userId }: { productId: string; userId: string },
+  { modules, userId: currenctUserId }: Context,
+) {
+  log(`mutation createBookmark for ${userId}`, {
+    productId,
+    userId: currenctUserId,
+  });
+  if (!productId) throw new InvalidIdError({ productId });
+  if (!(await modules.products.productExists({ productId })))
+    throw new ProductNotFoundError({ productId });
+
+  const bookmark = await modules.bookmarks.findByUserIdAndProductId({
+    productId,
+    userId,
+  });
+
+  if (bookmark) throw new BookmarkAlreadyExistsError({ bookmarkId: bookmark._id });
+
+  const bookmarkId = await modules.bookmarks.create(
+    {
+      userId,
+      productId,
+    },
+    currenctUserId,
+  );
+
+  return modules.bookmarks.findById(bookmarkId);
+}

package/src/resolvers/mutations/bookmarks/removeBookmark.ts

@@ -0,0 +1,18 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { BookmarkNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function removeBookmark(
+  root: Root,
+  { bookmarkId }: { bookmarkId: string },
+  { userId, modules }: Context,
+) {
+  log('mutation removeBookmark', { bookmarkId, userId });
+  if (!bookmarkId) throw new InvalidIdError({ bookmarkId });
+  const bookmark = await modules.bookmarks.findById(bookmarkId);
+  if (!bookmark) {
+    throw new BookmarkNotFoundError({ bookmarkId });
+  }
+  await modules.bookmarks.delete(bookmarkId);
+  return bookmark;
+}

package/src/resolvers/mutations/countries/createCountry.ts

@@ -0,0 +1,21 @@
+import { log } from '@unchainedshop/logger';
+import { Country } from '@unchainedshop/types/countries';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function createCountry(
+  root: Root,
+  { country }: { country: Country },
+  { userId, modules }: Context,
+) {
+  log('mutation createCountry', { userId });
+
+  const countryId = await modules.countries.create(
+    {
+      ...country,
+      authorId: userId,
+    },
+    userId,
+  );
+
+  return modules.countries.findCountry({ countryId });
+}

package/src/resolvers/mutations/countries/removeCountry.ts

@@ -0,0 +1,20 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { CountryNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function removeCountry(
+  root: Root,
+  { countryId }: { countryId: string },
+  { userId, modules }: Context,
+) {
+  log(`mutation removeCountry ${countryId}`, { userId });
+
+  if (!countryId) throw new InvalidIdError({ countryId });
+
+  if (!(await modules.countries.countryExists({ countryId })))
+    throw new CountryNotFoundError({ countryId });
+
+  await modules.countries.delete(countryId, userId);
+
+  return modules.countries.findCountry({ countryId });
+}

package/src/resolvers/mutations/countries/updateCountry.ts

@@ -0,0 +1,21 @@
+import { log } from '@unchainedshop/logger';
+import { Country } from '@unchainedshop/types/countries';
+import { Context, Root } from '@unchainedshop/types/api';
+import { CountryNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function updateCountry(
+  root: Root,
+  { country, countryId }: { country: Country; countryId: string },
+  { userId, modules }: Context,
+) {
+  log(`mutation updateCountry ${countryId}`, { userId });
+
+  if (!countryId) throw new InvalidIdError({ countryId });
+
+  if (!(await modules.countries.countryExists({ countryId })))
+    throw new CountryNotFoundError({ countryId });
+
+  await modules.countries.update(countryId, country, userId);
+
+  return modules.countries.findCountry({ countryId });
+}

package/src/resolvers/mutations/currencies/createCurrency.ts

@@ -0,0 +1,20 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { Currency } from '@unchainedshop/types/currencies';
+
+export default async function createCurrency(
+  root: Root,
+  { currency }: { currency: Currency },
+  { userId, modules }: Context,
+) {
+  log('mutation createCurrency', { userId });
+  const currencyId = await modules.currencies.create(
+    {
+      ...currency,
+      authorId: userId,
+    },
+    userId,
+  );
+
+  return modules.currencies.findCurrency({ currencyId });
+}

package/src/resolvers/mutations/currencies/removeCurrency.ts

@@ -0,0 +1,20 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { CurrencyNotFoundError, InvalidIdError } from '../../../errors';
+
+export default async function removeCurrency(
+  root: Root,
+  { currencyId }: { currencyId: string },
+  { userId, modules }: Context,
+) {
+  log(`mutation removeCurrency ${currencyId}`, { userId });
+
+  if (!currencyId) throw new InvalidIdError({ currencyId });
+
+  if (!(await modules.currencies.currencyExists({ currencyId })))
+    throw new CurrencyNotFoundError({ currencyId });
+
+  await modules.currencies.delete(currencyId, userId);
+
+  return modules.currencies.findCurrency({ currencyId });
+}