@unchainedshop/core-assortments 1.1.3

package/src/module/configureAssortmentProductsModule.ts

@@ -0,0 +1,234 @@
+import { AssortmentProduct, AssortmentsModule } from '@unchainedshop/types/assortments';
+import { Collection } from '@unchainedshop/types/common';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { generateDbFilterById, generateDbObjectId } from '@unchainedshop/utils';
+
+const ASSORTMENT_PRODUCT_EVENTS = [
+  'ASSORTMENT_ADD_PRODUCT',
+  'ASSORTMENT_REMOVE_PRODUCT',
+  'ASSORTMENT_REORDER_PRODUCTS',
+];
+
+export const configureAssortmentProductsModule = ({
+  AssortmentProducts,
+  invalidateCache,
+}: {
+  AssortmentProducts: Collection<AssortmentProduct>;
+  invalidateCache: AssortmentsModule['invalidateCache'];
+}): AssortmentsModule['products'] => {
+  registerEvents(ASSORTMENT_PRODUCT_EVENTS);
+
+  return {
+    // Queries
+    findAssortmentIds: async ({ productId, tags }) => {
+      const selector = { productId };
+      if (tags) {
+        selector.tags = { $in: tags };
+      }
+      return AssortmentProducts.find(selector, { projection: { assortmentId: true } })
+        .map(({ assortmentId }) => assortmentId)
+        .toArray();
+    },
+
+    findProductIds: async ({ assortmentId, tags }) => {
+      const selector = { assortmentId };
+      if (tags) {
+        selector.tags = { $in: tags };
+      }
+      return AssortmentProducts.find(selector, { projection: { productId: true } })
+        .map(({ productId }) => productId)
+        .toArray();
+    },
+
+    findProduct: async ({ assortmentProductId }) => {
+      return AssortmentProducts.findOne(generateDbFilterById(assortmentProductId), {});
+    },
+
+    findProducts: async ({ assortmentId }, options) => {
+      const products = AssortmentProducts.find({ assortmentId }, options);
+      return products.toArray();
+    },
+
+    findProductSiblings: async ({ assortmentIds, productId }) => {
+      const selector = {
+        $and: [
+          {
+            productId: { $ne: productId },
+          },
+          {
+            assortmentId: { $in: assortmentIds },
+          },
+        ],
+      };
+
+      return AssortmentProducts.find(selector, {
+        projection: { productId: 1 },
+      })
+        .map((product) => product.productId)
+        .toArray();
+    },
+
+    // Mutations
+    create: async (doc: AssortmentProduct, options, userId) => {
+      const { _id, assortmentId, productId, sortKey, ...rest } = doc;
+
+      const selector = {
+        ...(doc._id ? generateDbFilterById(doc._id) : {}),
+        productId,
+        assortmentId,
+      };
+      const $set: any = {
+        updated: new Date(),
+        updatedBy: userId,
+        ...rest,
+      };
+      const $setOnInsert: any = {
+        _id: _id || generateDbObjectId(),
+        productId,
+        assortmentId,
+        created: new Date(),
+        createdBy: userId,
+      };
+
+      if (!sortKey) {
+        // Get next sort key
+        const lastAssortmentProduct = (await AssortmentProducts.findOne(
+          { assortmentId },
+          { sort: { sortKey: -1 } },
+        )) || { sortKey: 0 };
+        $setOnInsert.sortKey = lastAssortmentProduct.sortKey + 1;
+      } else {
+        $set.sortKey = sortKey;
+      }
+
+      await AssortmentProducts.updateOne(
+        selector,
+        {
+          $set,
+          $setOnInsert,
+        },
+        { upsert: true },
+      );
+
+      const assortmentProduct = await AssortmentProducts.findOne(selector, {});
+
+      emit('ASSORTMENT_ADD_PRODUCT', { assortmentProduct });
+
+      if (!options.skipInvalidation) {
+        await invalidateCache(
+          { assortmentIds: [assortmentProduct.assortmentId] },
+          { skipUpstreamTraversal: false },
+        );
+      }
+
+      return assortmentProduct;
+    },
+
+    delete: async (assortmentProductId, options) => {
+      const selector = generateDbFilterById(assortmentProductId);
+
+      const assortmentProduct = await AssortmentProducts.findOne(selector, {
+        projection: { _id: 1, assortmentId: 1 },
+      });
+
+      if (!assortmentProduct) return [];
+
+      await AssortmentProducts.deleteOne(selector);
+
+      emit('ASSORTMENT_REMOVE_PRODUCT', {
+        assortmentProductId: assortmentProduct._id,
+      });
+
+      if (!options.skipInvalidation) {
+        await invalidateCache(
+          { assortmentIds: [assortmentProduct.assortmentId] },
+          {
+            skipUpstreamTraversal: false,
+          },
+        );
+      }
+
+      return [assortmentProduct];
+    },
+
+    deleteMany: async (selector, options) => {
+      const assortmentProducts = await AssortmentProducts.find(selector, {
+        projection: { _id: 1, assortmentId: 1 },
+      }).toArray();
+
+      await AssortmentProducts.deleteMany(selector);
+      assortmentProducts.forEach((assortmentProduct) => {
+        emit('ASSORTMENT_REMOVE_PRODUCT', {
+          assortmentProductId: assortmentProduct._id,
+        });
+      });
+
+      if (!options.skipInvalidation && assortmentProducts.length) {
+        await invalidateCache(
+          { assortmentIds: assortmentProducts.map((product) => product.assortmentId) },
+          {
+            skipUpstreamTraversal: false,
+          },
+        );
+      }
+
+      return assortmentProducts;
+    },
+
+    // This action is specifically used for the bulk migration scripts in the platform package
+    update: async (assortmentProductId, doc, options, userId) => {
+      const selector = generateDbFilterById(assortmentProductId);
+      const modifier = {
+        $set: {
+          ...doc,
+          updated: new Date(),
+          updatedBy: userId,
+        },
+      };
+      await AssortmentProducts.updateOne(selector, modifier);
+
+      const assortmentProduct = await AssortmentProducts.findOne(selector, {});
+      if (!options.skipInvalidation) {
+        await invalidateCache(
+          { assortmentIds: [assortmentProduct.assortmentId] },
+          {
+            skipUpstreamTraversal: false,
+          },
+        );
+      }
+      return assortmentProduct;
+    },
+
+    updateManualOrder: async ({ sortKeys }, options, userId) => {
+      const changedAssortmentProductIds = await Promise.all(
+        sortKeys.map(async ({ assortmentProductId, sortKey }) => {
+          await AssortmentProducts.updateOne(generateDbFilterById(assortmentProductId), {
+            $set: {
+              sortKey: sortKey + 1,
+              updated: new Date(),
+              updatedBy: userId,
+            },
+          });
+          return assortmentProductId;
+        }),
+      );
+
+      const assortmentProducts = await AssortmentProducts.find({
+        _id: { $in: changedAssortmentProductIds },
+      }).toArray();
+
+      if (!options.skipInvalidation && assortmentProducts.length) {
+        await invalidateCache(
+          { assortmentIds: assortmentProducts.map((product) => product.assortmentId) },
+          {
+            skipUpstreamTraversal: false,
+          },
+        );
+      }
+
+      emit('ASSORTMENT_REORDER_PRODUCTS', { assortmentProducts });
+
+      return assortmentProducts;
+    },
+  };
+};

package/src/module/configureAssortmentTextsModule.ts

@@ -0,0 +1,179 @@
+import { Assortment, AssortmentsModule, AssortmentText } from '@unchainedshop/types/assortments';
+import { Collection } from '@unchainedshop/types/common';
+import { Locale } from 'locale';
+import { emit, registerEvents } from '@unchainedshop/events';
+import {
+  findLocalizedText,
+  findUnusedSlug,
+  generateDbFilterById,
+  generateDbObjectId,
+} from '@unchainedshop/utils';
+import { assortmentsSettings } from '../assortments-settings';
+
+const ASSORTMENT_TEXT_EVENTS = ['ASSORTMENT_UPDATE_TEXTS'];
+
+export const configureAssortmentTextsModule = ({
+  Assortments,
+  AssortmentTexts,
+}: {
+  Assortments: Collection<Assortment>;
+  AssortmentTexts: Collection<AssortmentText>;
+}): AssortmentsModule['texts'] => {
+  registerEvents(ASSORTMENT_TEXT_EVENTS);
+
+  const makeSlug = async ({ slug, title, assortmentId }) => {
+    const checkSlugIsUnique = async (newPotentialSlug: string) => {
+      return (
+        (await AssortmentTexts.countDocuments(
+          {
+            assortmentId: { $ne: assortmentId },
+            slug: newPotentialSlug,
+          },
+          { limit: 1 },
+        )) === 0
+      );
+    };
+
+    const findSlug = findUnusedSlug(checkSlugIsUnique, { slugify: assortmentsSettings.slugify });
+    return findSlug({
+      existingSlug: slug,
+      title: title || assortmentId,
+    });
+  };
+
+  const upsertLocalizedText: AssortmentsModule['texts']['upsertLocalizedText'] = async (
+    assortmentId,
+    locale,
+    text,
+    userId,
+  ) => {
+    const { slug: textSlug, ...textFields } = text;
+    const slug = await makeSlug({
+      slug: textSlug,
+      title: text.title,
+      assortmentId,
+    });
+
+    const modifier: any = {
+      $set: {
+        updated: new Date(),
+        updatedBy: userId,
+        authorId: userId,
+        ...textFields,
+      },
+      $setOnInsert: {
+        _id: generateDbObjectId(),
+        created: new Date(),
+        createdBy: userId,
+        locale,
+      },
+    };
+
+    if (text.slug) {
+      modifier.$set.slug = slug;
+    } else {
+      modifier.$setOnInsert.slug = slug;
+    }
+
+    const selector = { assortmentId, locale };
+
+    const updateResult = await AssortmentTexts.updateOne(selector, modifier, {
+      upsert: true,
+    });
+
+    if (updateResult.upsertedCount > 0 || updateResult.modifiedCount > 0) {
+      const assortmentSelector = generateDbFilterById(assortmentId);
+      await Assortments.updateOne(assortmentSelector, {
+        $set: {
+          updated: new Date(),
+          updatedBy: userId,
+        },
+        $addToSet: {
+          slugs: slug,
+        },
+      });
+
+      await Assortments.updateMany(
+        {
+          _id: { $ne: assortmentId },
+          slugs: slug,
+        },
+        {
+          $set: {
+            updated: new Date(),
+            updatedBy: userId,
+          },
+          $pull: {
+            slugs: slug,
+          },
+        },
+      );
+    }
+
+    return AssortmentTexts.findOne(
+      updateResult.upsertedId ? generateDbFilterById(updateResult.upsertedId) : selector,
+      {},
+    );
+  };
+
+  return {
+    // Queries
+    findTexts: async (query, options) => {
+      const texts = AssortmentTexts.find(query, options);
+
+      return texts.toArray();
+    },
+
+    findLocalizedText: async ({ assortmentId, locale }) => {
+      const parsedLocale = new Locale(locale);
+
+      const text = await findLocalizedText<AssortmentText>(
+        AssortmentTexts,
+        { assortmentId },
+        parsedLocale,
+      );
+
+      return text;
+    },
+
+    searchTexts: async ({ searchText }) => {
+      const assortmentIds = AssortmentTexts.find(
+        { $text: { $search: searchText } },
+        {
+          projection: {
+            assortmentId: 1,
+          },
+        },
+      ).map(({ assortmentId }) => assortmentId);
+
+      return assortmentIds.toArray();
+    },
+
+    // Mutations
+    updateTexts: async (assortmentId, texts, userId) => {
+      const assortmentTexts = Array.isArray(texts)
+        ? await Promise.all(
+          texts.map(async ({ locale, ...text }) =>
+            upsertLocalizedText(assortmentId, locale, text, userId),
+          ),
+        )
+        : [];
+
+      emit('ASSORTMENT_UPDATE_TEXTS', {
+        assortmentId,
+        assortmentTexts,
+      });
+
+      return assortmentTexts;
+    },
+
+    upsertLocalizedText,
+    makeSlug,
+
+    deleteMany: async ({ assortmentId }) => {
+      const deletedResult = await AssortmentTexts.deleteMany({ assortmentId });
+
+      return deletedResult.deletedCount;
+    },
+  };
+};