@unchainedshop/core-assortments 1.1.3

package/src/module/configureAssortmentFiltersModule.ts

@@ -0,0 +1,153 @@
+import { AssortmentFilter, AssortmentsModule } from '@unchainedshop/types/assortments';
+import { Collection, Query } from '@unchainedshop/types/common';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { generateDbFilterById, generateDbObjectId } from '@unchainedshop/utils';
+
+const ASSORTMENT_FILTER_EVENTS = [
+  'ASSORTMENT_ADD_FILTER',
+  'ASSORTMENT_REMOVE_FILTER',
+  'ASSORTMENT_REORDER_FILTERS',
+];
+
+export const configureAssortmentFiltersModule = ({
+  AssortmentFilters,
+}: {
+  AssortmentFilters: Collection<AssortmentFilter>;
+}): AssortmentsModule['filters'] => {
+  registerEvents(ASSORTMENT_FILTER_EVENTS);
+
+  return {
+    findFilter: async ({ assortmentFilterId }) => {
+      return AssortmentFilters.findOne(generateDbFilterById(assortmentFilterId), {});
+    },
+
+    findFilters: async ({ assortmentId }, options) => {
+      const filters = AssortmentFilters.find({ assortmentId }, options);
+      return filters.toArray();
+    },
+
+    findFilterIds: async ({ assortmentId }) => {
+      const filters = AssortmentFilters.find(
+        { assortmentId },
+        {
+          sort: { sortKey: 1 },
+          projection: { filterId: 1 },
+        },
+      ).map((filter) => filter.filterId);
+
+      return filters.toArray();
+    },
+    create: async (doc: AssortmentFilter, userId) => {
+      const { _id, assortmentId, filterId, sortKey, ...rest } = doc;
+
+      const selector = {
+        ...(_id ? generateDbFilterById(_id) : {}),
+        filterId,
+        assortmentId,
+      };
+
+      const $set: any = {
+        updated: new Date(),
+        updatedBy: userId,
+        ...rest,
+      };
+      const $setOnInsert: any = {
+        _id: _id || generateDbObjectId(),
+        filterId,
+        assortmentId,
+        created: new Date(),
+        createdBy: userId,
+      };
+
+      if (!doc.sortKey) {
+        // Get next sort key
+        const lastAssortmentFilter = (await AssortmentFilters.findOne(
+          { assortmentId },
+          { sort: { sortKey: -1 } },
+        )) || { sortKey: 0 };
+        $setOnInsert.sortKey = lastAssortmentFilter.sortKey + 1;
+      } else {
+        $set.sortKey = sortKey;
+      }
+
+      await AssortmentFilters.updateOne(
+        selector,
+        {
+          $set,
+          $setOnInsert,
+        },
+        { upsert: true },
+      );
+
+      const assortmentFilter = await AssortmentFilters.findOne(selector, {});
+
+      emit('ASSORTMENT_ADD_FILTER', { assortmentFilter });
+
+      return assortmentFilter;
+    },
+
+    delete: async (assortmentFilterId) => {
+      const selector: Query = generateDbFilterById(assortmentFilterId);
+
+      const assortmentFilter = await AssortmentFilters.findOne(selector, {
+        projection: { _id: 1 },
+      });
+
+      await AssortmentFilters.deleteOne(selector);
+
+      emit('ASSORTMENT_REMOVE_FILTER', {
+        assortmentFilterId: assortmentFilter._id,
+      });
+
+      return [assortmentFilter];
+    },
+
+    deleteMany: async (selector) => {
+      const assortmentFilters = await AssortmentFilters.find(selector, {
+        projection: { _id: 1 },
+      }).toArray();
+
+      await AssortmentFilters.deleteMany(selector);
+
+      assortmentFilters.forEach((assortmentFilter) => {
+        emit('ASSORTMENT_REMOVE_FILTER', {
+          assortmentFilterId: assortmentFilter._id,
+        });
+      });
+
+      return assortmentFilters;
+    },
+
+    // This action is specifically used for the bulk migration scripts in the platform package
+    update: async (assortmentFilterId, doc) => {
+      const selector = generateDbFilterById(assortmentFilterId);
+      const modifier = { $set: doc };
+      await AssortmentFilters.updateOne(selector, modifier);
+      return AssortmentFilters.findOne(selector, {});
+    },
+
+    updateManualOrder: async ({ sortKeys }, userId) => {
+      const changedAssortmentFilterIds = await Promise.all(
+        sortKeys.map(async ({ assortmentFilterId, sortKey }) => {
+          await AssortmentFilters.updateOne(generateDbFilterById(assortmentFilterId), {
+            $set: {
+              sortKey: sortKey + 1,
+              updated: new Date(),
+              updatedBy: userId,
+            },
+          });
+
+          return assortmentFilterId;
+        }),
+      );
+
+      const assortmentFilters = await AssortmentFilters.find({
+        _id: { $in: changedAssortmentFilterIds },
+      }).toArray();
+
+      emit('ASSORTMENT_REORDER_FILTERS', { assortmentFilters });
+
+      return assortmentFilters;
+    },
+  };
+};

package/src/module/configureAssortmentLinksModule.ts

@@ -0,0 +1,212 @@
+import { AssortmentLink, 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_LINK_EVENTS = [
+  'ASSORTMENT_ADD_LINK',
+  'ASSORTMENT_REMOVE_LINK',
+  'ASSORTMENT_REORDER_LINKS',
+];
+
+export const configureAssortmentLinksModule = ({
+  AssortmentLinks,
+  invalidateCache,
+}: {
+  AssortmentLinks: Collection<AssortmentLink>;
+  invalidateCache: AssortmentsModule['invalidateCache'];
+}): AssortmentsModule['links'] => {
+  registerEvents(ASSORTMENT_LINK_EVENTS);
+
+  return {
+    // Queries
+    findLink: async ({ assortmentLinkId, parentAssortmentId, childAssortmentId }) => {
+      return AssortmentLinks.findOne(
+        assortmentLinkId
+          ? generateDbFilterById(assortmentLinkId)
+          : { parentAssortmentId, childAssortmentId },
+        {},
+      );
+    },
+
+    findLinks: async ({ assortmentId, parentAssortmentId }, options) => {
+      const selector = parentAssortmentId
+        ? {
+          parentAssortmentId,
+        }
+        : {
+          $or: [{ parentAssortmentId: assortmentId }, { childAssortmentId: assortmentId }],
+        };
+
+      const links = AssortmentLinks.find(
+        selector,
+        options || {
+          sort: { sortKey: 1 },
+        },
+      );
+
+      return links.toArray();
+    },
+
+    // Mutations
+    create: async (doc, options, userId) => {
+      const { _id: assortmentLinkId, parentAssortmentId, childAssortmentId, sortKey, ...rest } = doc;
+
+      const selector = {
+        ...(assortmentLinkId ? generateDbFilterById(assortmentLinkId) : {}),
+        parentAssortmentId,
+        childAssortmentId,
+      };
+
+      const $set: any = {
+        updated: new Date(),
+        updatedBy: userId,
+        ...rest,
+      };
+      const $setOnInsert: any = {
+        _id: assortmentLinkId || generateDbObjectId(),
+        parentAssortmentId,
+        childAssortmentId,
+        created: new Date(),
+        createdBy: userId,
+      };
+
+      if (!sortKey) {
+        // Get next sort key
+        const lastAssortmentLink = (await AssortmentLinks.findOne(
+          { parentAssortmentId },
+          { sort: { sortKey: -1 } },
+        )) || { sortKey: 0 };
+        $setOnInsert.sortKey = lastAssortmentLink.sortKey + 1;
+      } else {
+        $set.sortKey = sortKey;
+      }
+
+      await AssortmentLinks.updateOne(
+        selector,
+        {
+          $set,
+          $setOnInsert,
+        },
+        {
+          upsert: true,
+        },
+      );
+
+      const assortmentLink = await AssortmentLinks.findOne(selector, {});
+
+      emit('ASSORTMENT_ADD_LINK', { assortmentLink });
+
+      if (!options.skipInvalidation) {
+        await invalidateCache({ assortmentIds: [parentAssortmentId] });
+      }
+
+      return assortmentLink;
+    },
+
+    // This action is specifically used for the bulk migration scripts in the platform package
+    update: async (assortmentLinkId, doc, options, userId) => {
+      const selector = generateDbFilterById(assortmentLinkId);
+      const modifier = {
+        $set: {
+          ...doc,
+          updated: new Date(),
+          updatedBy: userId,
+        },
+      };
+      await AssortmentLinks.updateOne(selector, modifier);
+
+      const assortmentLink = await AssortmentLinks.findOne(selector, {});
+      if (!options.skipInvalidation) {
+        await invalidateCache(
+          { assortmentIds: [assortmentLink.childAssortmentId] },
+          {
+            skipUpstreamTraversal: false,
+          },
+        );
+      }
+      return assortmentLink;
+    },
+
+    delete: async (assortmentLinkId, options) => {
+      const selector = generateDbFilterById(assortmentLinkId);
+
+      const assortmentLink = await AssortmentLinks.findOne(selector, {});
+
+      await AssortmentLinks.deleteOne(selector);
+
+      emit('ASSORTMENT_REMOVE_LINK', {
+        assortmentLinkId: assortmentLink._id,
+      });
+
+      if (!options.skipInvalidation) {
+        await invalidateCache(
+          {
+            assortmentIds: [assortmentLink.childAssortmentId, assortmentLink.parentAssortmentId],
+          },
+          { skipUpstreamTraversal: false },
+        );
+      }
+
+      return assortmentLink;
+    },
+
+    deleteMany: async (selector, options) => {
+      const assortmentLinks = await AssortmentLinks.find(selector, {}).toArray();
+
+      await AssortmentLinks.deleteMany(selector);
+      assortmentLinks.forEach((assortmentLink) => {
+        emit('ASSORTMENT_REMOVE_LINK', {
+          assortmentLinkId: assortmentLink._id,
+        });
+      });
+
+      if (!options.skipInvalidation && assortmentLinks.length) {
+        await invalidateCache(
+          {
+            assortmentIds: assortmentLinks.flatMap((link) => [
+              link.childAssortmentId,
+              link.parentAssortmentId,
+            ]),
+          },
+          { skipUpstreamTraversal: false },
+        );
+      }
+
+      return assortmentLinks;
+    },
+
+    updateManualOrder: async ({ sortKeys }, options, userId) => {
+      const changedAssortmentLinkIds = await Promise.all(
+        sortKeys.map(async ({ assortmentLinkId, sortKey }) => {
+          await AssortmentLinks.updateOne(generateDbFilterById(assortmentLinkId), {
+            $set: {
+              sortKey: sortKey + 1,
+              updated: new Date(),
+              updatedBy: userId,
+            },
+          });
+
+          return assortmentLinkId;
+        }),
+      );
+
+      const assortmentLinks = await AssortmentLinks.find({
+        _id: { $in: changedAssortmentLinkIds },
+      }).toArray();
+
+      if (!options.skipInvalidation && assortmentLinks.length) {
+        await invalidateCache(
+          { assortmentIds: assortmentLinks.map((link) => link.childAssortmentId) },
+          {
+            skipUpstreamTraversal: false,
+          },
+        );
+      }
+
+      emit('ASSORTMENT_REORDER_LINKS', { assortmentLinks });
+
+      return assortmentLinks;
+    },
+  };
+};

package/src/module/configureAssortmentMediaModule.ts

@@ -0,0 +1,259 @@
+import {
+  AssortmentMedia,
+  AssortmentMediaModule,
+  AssortmentMediaText,
+} from '@unchainedshop/types/assortments.media';
+import { ModuleInput, ModuleMutations, Query } from '@unchainedshop/types/common';
+import { Locale } from 'locale';
+import { emit, registerEvents } from '@unchainedshop/events';
+import {
+  findLocalizedText,
+  generateDbFilterById,
+  generateDbMutations,
+  generateDbObjectId,
+} from '@unchainedshop/utils';
+import { FileDirector } from '@unchainedshop/file-upload';
+import { AssortmentMediaCollection } from '../db/AssortmentMediasCollection';
+import { AssortmentMediasSchema } from '../db/AssortmentMediasSchema';
+
+const ASSORTMENT_MEDIA_EVENTS = [
+  'ASSORTMENT_ADD_MEDIA',
+  'ASSORTMENT_REMOVE_MEDIA',
+  'ASSORTMENT_REORDER_MEDIA',
+  'ASSORTMENT_UPDATE_MEDIA_TEXT',
+];
+
+FileDirector.registerFileUploadCallback('assortment-media', async (file, { modules, userId }) => {
+  await modules.assortments.media.create(
+    {
+      assortmentId: file.meta.assortmentId,
+      mediaId: file._id,
+    },
+    file.updatedBy || file.createdBy || userId,
+  );
+});
+
+export const configureAssortmentMediaModule = async ({
+  db,
+}: ModuleInput<Record<string, never>>): Promise<AssortmentMediaModule> => {
+  registerEvents(ASSORTMENT_MEDIA_EVENTS);
+
+  const { AssortmentMedias, AssortmentMediaTexts } = await AssortmentMediaCollection(db);
+
+  const mutations = generateDbMutations<AssortmentMedia>(
+    AssortmentMedias,
+    AssortmentMediasSchema,
+  ) as ModuleMutations<AssortmentMedia>;
+
+  const upsertLocalizedText: AssortmentMediaModule['texts']['upsertLocalizedText'] = async (
+    assortmentMediaId,
+    locale,
+    text,
+    userId,
+  ) => {
+    const selector = {
+      assortmentMediaId,
+      locale,
+    };
+
+    const updsertResult = await AssortmentMediaTexts.updateOne(
+      selector,
+      {
+        $set: {
+          updated: new Date(),
+          updatedBy: userId,
+          authorId: userId,
+          ...text,
+        },
+        $setOnInsert: {
+          _id: generateDbObjectId(),
+          created: new Date(),
+          createdBy: userId,
+          assortmentMediaId,
+          locale,
+        },
+      },
+      {
+        upsert: true,
+      },
+    );
+
+    return AssortmentMediaTexts.findOne(
+      updsertResult.upsertedId ? generateDbFilterById(updsertResult.upsertedId) : selector,
+      {},
+    );
+  };
+
+  return {
+    // Queries
+    findAssortmentMedia: async ({ assortmentMediaId }) => {
+      return AssortmentMedias.findOne(generateDbFilterById(assortmentMediaId), {});
+    },
+
+    findAssortmentMedias: async ({ assortmentId, tags, offset, limit }, options) => {
+      const selector: Query = assortmentId ? { assortmentId } : {};
+      if (tags && tags.length > 0) {
+        selector.tags = { $all: tags };
+      }
+
+      const mediaList = AssortmentMedias.find(selector, {
+        skip: offset,
+        limit,
+        sort: { sortKey: 1 },
+        ...options,
+      });
+
+      return mediaList.toArray();
+    },
+
+    // Mutations
+    create: async (doc: AssortmentMedia, userId) => {
+      let { sortKey } = doc;
+
+      if (!sortKey) {
+        // Get next sort key
+        const lastAssortmentMedia = (await AssortmentMedias.findOne(
+          {
+            assortmentId: doc.assortmentId,
+          },
+          {
+            sort: { sortKey: -1 },
+          },
+        )) || { sortKey: 0 };
+        sortKey = lastAssortmentMedia.sortKey + 1;
+      }
+
+      const assortmentMediaId = await mutations.create(
+        {
+          tags: [],
+          authorId: userId,
+          ...doc,
+          sortKey,
+        },
+        userId,
+      );
+
+      const assortmentMedia = await AssortmentMedias.findOne(
+        generateDbFilterById(assortmentMediaId),
+        {},
+      );
+
+      emit('ASSORTMENT_ADD_MEDIA', {
+        assortmentMedia,
+      });
+
+      return assortmentMedia;
+    },
+
+    delete: async (assortmentMediaId) => {
+      const selector = generateDbFilterById(assortmentMediaId);
+
+      const deletedResult = await AssortmentMedias.deleteOne(selector);
+
+      emit('ASSORTMENT_REMOVE_MEDIA', {
+        assortmentMediaId,
+      });
+
+      return deletedResult.deletedCount;
+    },
+
+    deleteMediaFiles: async ({ assortmentId, excludedAssortmentIds, excludedAssortmentMediaIds }) => {
+      const selector: Query = assortmentId ? { assortmentId } : {};
+
+      if (!assortmentId && excludedAssortmentIds) {
+        selector.assortmentId = { $nin: excludedAssortmentIds };
+      }
+
+      if (excludedAssortmentMediaIds) {
+        selector._id = { $nin: excludedAssortmentMediaIds };
+      }
+
+      const ids = await AssortmentMedias.find(selector, { projection: { _id: true } })
+        .map((m) => m._id)
+        .toArray();
+
+      const deletedResult = await AssortmentMedias.deleteMany(selector);
+
+      ids.forEach((assortmentMediaId) => {
+        emit('ASSORTMENT_REMOVE_MEDIA', {
+          assortmentMediaId,
+        });
+      });
+
+      return deletedResult.deletedCount;
+    },
+
+    // This action is specifically used for the bulk migration scripts in the platform package
+    update: async (assortmentMediaId, doc) => {
+      const selector = generateDbFilterById(assortmentMediaId);
+      const modifier = { $set: doc };
+      await AssortmentMedias.updateOne(selector, modifier);
+      return AssortmentMedias.findOne(selector, {});
+    },
+
+    updateManualOrder: async ({ sortKeys }, userId) => {
+      const changedAssortmentMediaIds = await Promise.all(
+        sortKeys.map(async ({ assortmentMediaId, sortKey }) => {
+          await AssortmentMedias.updateOne(generateDbFilterById(assortmentMediaId), {
+            $set: {
+              sortKey: sortKey + 1,
+              updated: new Date(),
+              updatedBy: userId,
+            },
+          });
+
+          return assortmentMediaId;
+        }),
+      );
+
+      const assortmentMedias = await AssortmentMedias.find({
+        _id: { $in: changedAssortmentMediaIds },
+      }).toArray();
+
+      emit('ASSORTMENT_REORDER_MEDIA', { assortmentMedias });
+
+      return assortmentMedias;
+    },
+
+    /*
+     * Assortment Media Texts
+     */
+
+    texts: {
+      // Queries
+      findMediaTexts: async ({ assortmentMediaId }) => {
+        return AssortmentMediaTexts.find({ assortmentMediaId }).toArray();
+      },
+
+      findLocalizedMediaText: async ({ assortmentMediaId, locale }) => {
+        const parsedLocale = new Locale(locale);
+
+        const text = await findLocalizedText<AssortmentMediaText>(
+          AssortmentMediaTexts,
+          { assortmentMediaId },
+          parsedLocale,
+        );
+
+        return text;
+      },
+
+      // Mutations
+      updateMediaTexts: async (assortmentMediaId, texts, userId) => {
+        const mediaTexts = await Promise.all(
+          texts.map(({ locale, ...text }) =>
+            upsertLocalizedText(assortmentMediaId, locale, text, userId),
+          ),
+        );
+
+        emit('ASSORTMENT_UPDATE_MEDIA_TEXT', {
+          assortmentMediaId,
+          mediaTexts,
+        });
+
+        return mediaTexts;
+      },
+
+      upsertLocalizedText,
+    },
+  };
+};