@unchainedshop/plugins 2.0.0-beta7 → 2.0.0-beta9

package/src/worker/enrollment-order-generator.ts

@@ -1,4 +1,3 @@
-import { Context } from '@unchainedshop/types/api';
 import { Enrollment } from '@unchainedshop/types/enrollments';
 import { OrderPosition } from '@unchainedshop/types/orders.positions';
 import { Product } from '@unchainedshop/types/products';
@@ -9,6 +8,7 @@ import {
   EnrollmentStatus,
 } from '@unchainedshop/core-enrollments';
 import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core-worker';
+import { UnchainedCore } from '@unchainedshop/types/core';
 
 const generateOrder = async (
   enrollment: Enrollment,
@@ -16,29 +16,27 @@ const generateOrder = async (
     orderProducts: Array<{ orderPosition: OrderPosition; product: Product }>;
     orderContext?: any;
   } & { [x: string]: any },
-  requestContext: Context,
+  unchainedAPI: UnchainedCore,
 ) => {
   if (!enrollment.payment || !enrollment.delivery) return null;
 
-  const { modules } = requestContext;
+  const { modules } = unchainedAPI;
   const { orderProducts, orderContext, ...configuration } = params;
-  let order = await modules.orders.create(
-    {
-      currency: enrollment.currencyCode,
-      countryCode: enrollment.countryCode,
-      contact: enrollment.contact,
-      billingAddress: enrollment.billingAddress,
-      originEnrollmentId: enrollment._id,
-      ...configuration,
-    },
-    enrollment.userId,
-  );
+  let order = await modules.orders.create({
+    userId: enrollment.userId,
+    currency: enrollment.currencyCode,
+    countryCode: enrollment.countryCode,
+    contact: enrollment.contact,
+    billingAddress: enrollment.billingAddress,
+    originEnrollmentId: enrollment._id,
+    ...configuration,
+  });
   const orderId = order._id;
 
   if (orderProducts) {
     await Promise.all(
       orderProducts.map(({ orderPosition, product }) =>
-        modules.orders.positions.addProductItem(orderPosition, { order, product }, requestContext),
+        modules.orders.positions.addProductItem(orderPosition, { order, product }, unchainedAPI),
       ),
     );
   } else {
@@ -51,18 +49,18 @@ const generateOrder = async (
         order,
         product,
       },
-      requestContext,
+      unchainedAPI,
     );
   }
 
   const { paymentProviderId, context: paymentContext } = enrollment.payment;
 
   if (paymentProviderId) {
-    await modules.orders.setPaymentProvider(orderId, paymentProviderId, requestContext);
+    await modules.orders.setPaymentProvider(orderId, paymentProviderId, unchainedAPI);
   }
   const { deliveryProviderId, context: deliveryContext } = enrollment.delivery;
   if (deliveryProviderId) {
-    await modules.orders.setDeliveryProvider(orderId, deliveryProviderId, requestContext);
+    await modules.orders.setDeliveryProvider(orderId, deliveryProviderId, unchainedAPI);
   }
 
   order = await modules.orders.checkout(
@@ -72,7 +70,7 @@ const generateOrder = async (
       deliveryContext,
       orderContext,
     },
-    requestContext,
+    unchainedAPI,
   );
 
   return order;
@@ -86,8 +84,8 @@ const GenerateOrderWorker: IWorkerAdapter<any, any> = {
   version: '1.0.0',
   type: 'ENROLLMENT_ORDER_GENERATOR',
 
-  doWork: async (input, requestContext) => {
-    const { modules } = requestContext;
+  doWork: async (input, unchainedAPI) => {
+    const { modules } = unchainedAPI;
 
     const enrollments = await modules.enrollments.findEnrollments({
       status: [EnrollmentStatus.ACTIVE, EnrollmentStatus.PAUSED],
@@ -97,7 +95,7 @@ const GenerateOrderWorker: IWorkerAdapter<any, any> = {
       await Promise.all(
         enrollments.map(async (enrollment) => {
           try {
-            const director = await EnrollmentDirector.actions({ enrollment }, requestContext as Context); // TODO: Type Refactor
+            const director = await EnrollmentDirector.actions({ enrollment }, unchainedAPI);
             const period = await director.nextPeriod();
             if (period) {
               const configuration = await director.configurationForOrder({
@@ -105,7 +103,7 @@ const GenerateOrderWorker: IWorkerAdapter<any, any> = {
                 period,
               });
               if (configuration) {
-                const order = await generateOrder(enrollment, configuration, requestContext as Context); // TODO: Type Refactor
+                const order = await generateOrder(enrollment, configuration, unchainedAPI);
                 if (order) {
                   await modules.enrollments.addEnrollmentPeriod(enrollment._id, {
                     ...period,

package/src/worker/message.ts

@@ -2,7 +2,6 @@ import { IWorkerAdapter, Work } from '@unchainedshop/types/worker';
 import { MessagingDirector } from '@unchainedshop/core-messaging';
 import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core-worker';
 import { createLogger } from '@unchainedshop/logger';
-import { Context } from '@unchainedshop/types/api';
 
 export const messagingLogger = createLogger('unchained:core-messaging');
 
@@ -17,7 +16,7 @@ export const MessageWorker: IWorkerAdapter<
   version: '1.0.0',
   type: 'MESSAGE',
 
-  doWork: async ({ template, ...payload }, requestContext, workId) => {
+  doWork: async ({ template, ...payload }, unchainedAPI, workId) => {
     try {
       const templateResolver = MessagingDirector.getTemplate(template);
 
@@ -26,19 +25,16 @@ export const MessageWorker: IWorkerAdapter<
           template,
           ...payload,
         },
-        requestContext as Context, // TODO: Type Refactor
+        unchainedAPI,
       );
 
       if (workConfigurations.length > 0) {
         const forked = await Promise.all(
           workConfigurations.map(async (workConfiguration: any) => {
-            const work = await requestContext.modules.worker.addWork(
-              {
-                ...workConfiguration,
-                originalWorkId: workId,
-              },
-              null,
-            );
+            const work = await unchainedAPI.modules.worker.addWork({
+              ...workConfiguration,
+              originalWorkId: workId,
+            });
             delete work.input;
             return work;
           }),

package/src/worker/update-coinbase-rates.ts

@@ -23,15 +23,15 @@ const UpdateCoinbaseRates: IWorkerAdapter<any, any> = {
   version: '1.0.0',
   type: 'UPDATE_COINBASE_RATES',
 
-  doWork: async (input, requestContext) => {
-    const { modules, services } = requestContext;
+  doWork: async (input, unchainedAPI) => {
+    const { modules, services } = unchainedAPI;
 
     try {
       const currencyCode = await services.countries.resolveDefaultCurrencyCode(
         {
           isoCode: systemLocale.country,
         },
-        requestContext,
+        unchainedAPI,
       );
 
       const currencies = await modules.currencies.findCurrencies({ includeInactive: true });

package/src/worker/update-ecb-rates.ts

@@ -32,8 +32,8 @@ const UpdateECBRates: IWorkerAdapter<any, any> = {
   version: '1.0.0',
   type: 'UPDATE_ECB_RATES',
 
-  doWork: async (input, requestContext) => {
-    const { modules } = requestContext;
+  doWork: async (input, unchainedAPI) => {
+    const { modules } = unchainedAPI;
 
     try {
       const data: Array<{ currency: string; rate: string }> = await getExchangeRates();

package/src/worker/update-token-ownership.ts

@@ -28,8 +28,8 @@ export const RefreshTokens: IWorkerAdapter<void, any> = {
   type: 'REFRESH_TOKENS',
   external: false,
 
-  async doWork(input, requestContext) {
-    const { modules } = requestContext;
+  async doWork(input, unchainedAPI) {
+    const { modules } = unchainedAPI;
 
     const tokens = await modules.warehousing.findTokens({});
     const users = await modules.users.findUsers({ includeGuests: true });
@@ -48,19 +48,16 @@ export const RefreshTokens: IWorkerAdapter<void, any> = {
       return { success: true, result: {} };
     }
 
-    const forked = await modules.worker.addWork(
-      {
-        type: 'UPDATE_TOKEN_OWNERSHIP',
-        retries: 0,
-        input: {
-          filter: {
-            tokens,
-            accounts: [...new Set(accounts)],
-          },
+    const forked = await modules.worker.addWork({
+      type: 'UPDATE_TOKEN_OWNERSHIP',
+      retries: 0,
+      input: {
+        filter: {
+          tokens,
+          accounts: [...new Set(accounts)],
         },
       },
-      null,
-    );
+    });
     return { success: true, result: { forked } };
   },
 };

package/src/worker/zombie-killer.ts

@@ -4,10 +4,6 @@ import { createLogger } from '@unchainedshop/logger';
 
 const logger = createLogger('unchained:platform:zombie-killer');
 
-const findId = { projection: { _id: 1 } };
-const findFileId = { projection: { mediaId: 1 } };
-const mapId = (a: any) => a._id;
-
 export const ZombieKillerWorker: IWorkerAdapter<
   never,
   {
@@ -29,42 +25,68 @@ export const ZombieKillerWorker: IWorkerAdapter<
     try {
       const error = false;
 
-      // Remove unreferenced product media objects
-      const products = await modules.products.findProducts({}, findId);
-      const deletedProductMediaCount = await modules.products.media.deleteMediaFiles({
-        excludedProductIds: products.map(mapId),
+      // Remove unreferenced filter entities
+      const filters = await modules.filters.findFilters(
+        { includeInactive: true },
+        { projection: { _id: 1 } },
+      );
+      const filterIds = filters.map((a) => a._id);
+      const deletedFilterTextsCount = await modules.filters.texts.deleteMany({
+        excludedFilterIds: filterIds,
       });
 
-      // Remove unreferenced assortment media objects
-      const assortments = await modules.assortments.findAssortments({}, findId);
+      // Remove unreferenced assortment entities
+      const assortments = await modules.assortments.findAssortments(
+        { includeInactive: true, includeLeaves: true },
+        { projection: { _id: 1 } },
+      );
+      const assortmentIds = assortments.map((a) => a._id);
+      const deletedAssortmentTextsCount = await modules.assortments.texts.deleteMany({
+        excludedAssortmentIds: assortmentIds,
+      });
       const deletedAssortmentMediaCount = await modules.assortments.media.deleteMediaFiles({
-        excludedAssortmentIds: assortments.map(mapId),
+        excludedAssortmentIds: assortmentIds,
       });
 
-      // Remove unreferenced files
-      const fileIdsToRemove = [];
-      const productMedia = await modules.products.media.findProductMedias({}, findFileId);
-      const assortmentMedia = await modules.assortments.media.findAssortmentMedias({}, findFileId);
-
-      const filesWithProductId = await modules.files.findFilesByMetaData({
-        meta: {
-          productId: { $exists: true },
-        },
+      // Remove unreferenced product entities
+      const products = await modules.products.findProducts(
+        { includeDrafts: true },
+        { projection: { _id: 1 } },
+      );
+      const productIds = products.map((a) => a._id);
+      const deletedProductTextsCount = await modules.products.texts.deleteMany({
+        excludedProductIds: productIds,
       });
-      const filesWithAssortmentId = await modules.files.findFilesByMetaData({
-        meta: {
-          assortmentId: { $exists: true },
-        },
+      const deletedProductVariationsCount = await modules.products.variations.deleteVariations({
+        excludedProductIds: productIds,
+      });
+      const deletedProductMediaCount = await modules.products.media.deleteMediaFiles({
+        excludedProductIds: productIds,
+      });
+
+      // Remove unreferenced files
+      const productMedia = await modules.products.media.findProductMedias(
+        {},
+        { projection: { mediaId: 1 } },
+      );
+      const assortmentMedia = await modules.assortments.media.findAssortmentMedias(
+        {},
+        { projection: { mediaId: 1 } },
+      );
+
+      const allFileIdsLinked = [...productMedia, ...assortmentMedia].map((l) => l?.mediaId);
+      const allFileIdsRelevant = (
+        await modules.files.findFiles(
+          { path: { $in: ['product-media', 'assortment-media'] } },
+          { projection: { _id: 1 } },
+        )
+      ).map((a) => a._id);
+
+      const fileIdsToRemove = allFileIdsRelevant.filter((fileId) => {
+        return !allFileIdsLinked.includes(fileId);
       });
 
-      filesWithProductId
-        .concat(filesWithAssortmentId)
-        .filter((file) => {
-          const fileInProductMedia = productMedia.some((media) => media.mediaId === file._id);
-          const fileInAssortmentMedia = assortmentMedia.some((media) => media.mediaId === file._id);
-          return !fileInProductMedia && !fileInAssortmentMedia;
-        })
-        .forEach((m) => fileIdsToRemove.push(m._id));
+      logger.verbose(`File Id's to remove: ${fileIdsToRemove.join(', ')}`);
 
       const deletedFilesCount =
         fileIdsToRemove.length > 0
@@ -78,8 +100,12 @@ export const ZombieKillerWorker: IWorkerAdapter<
 
       // Return delete count
       const result = {
+        deletedFilterTextsCount,
         deletedProductMediaCount,
+        deletedProductTextsCount,
+        deletedProductVariationsCount,
         deletedAssortmentMediaCount,
+        deletedAssortmentTextsCount,
         deletedFilesCount,
       };
 

package/tests/plugins-index.test.js

@@ -0,0 +1,3 @@
+describe('Plugins', () => {
+    it.todo("Plugins Tests")
+});