@unchainedshop/plugins 1.1.3

package/src/files/minio/minio-webhook.js

@@ -0,0 +1,51 @@
+import { useMiddlewareWithCurrentContext } from 'meteor/unchained:api';
+import { log, LogLevel } from '@unchainedshop/logger';
+import bodyParser from 'body-parser';
+
+const { MINIO_WEBHOOK_AUTH_TOKEN } = process.env;
+
+const isAuthorized = ({ authorization = '' }) => {
+  const [type, token] = authorization.split(' ');
+  return type === 'Bearer' && token === MINIO_WEBHOOK_AUTH_TOKEN;
+};
+
+useMiddlewareWithCurrentContext(
+  '/minio/',
+  bodyParser.json({
+    strict: false,
+  }),
+);
+
+useMiddlewareWithCurrentContext('/minio/', async (req, res) => {
+  try {
+    if (req.method === 'POST' && req.body) {
+      const { headers } = req;
+      const { Records = [], EventName } = req.body;
+      if (EventName === 's3:ObjectCreated:Put' && isAuthorized(headers)) {
+        const [{ s3 }] = Records;
+        const { object } = s3;
+        const { size, contentType: type } = object;
+        const [fileId] = object.key.split('.');
+        const { services } = req.unchainedContext;
+        await services.files.linkFile({ fileId, type, size }, req.unchainedContext);
+        res.writeHead(200);
+        res.end();
+        return;
+      }
+    }
+    res.writeHead(404);
+    res.end();
+    return;
+  } catch (e) {
+    log(e.message, { level: LogLevel.Error });
+    res.writeHead(503);
+    res.end(JSON.stringify(e));
+  }
+});
+
+/*
+
+curl -X PUT -T /Users/pozylon/Desktop/Bildschirmfoto\ 2022-02-17\ um\ 16.47.22.png  http://localhost:4010/gridfs/3e0cd78ac07f0028890ce36c391057dd0c5fb46f4c147fb73e54bd8a7ffee389/user-avatars/avatar.png?e=1645883865878&s=e7466b30039593e5790e23cab92878e0144289c3710344a55b78c9a916e2f78c
+curl -X PUT -T /Users/pozylon/Desktop/Bildschirmfoto\ 2022-02-17\ um\ 16.47.22.png  https://minio.dev.shared.ucc.dev/unchained-test-bucket/user-avatars/9aedd551499b2850e9483b07cd4c8cff7ad1d710f49933c183861bf40183bc5a?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=unchained-test%2F20220225%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20220225T140957Z&X-Amz-Expires=86400&X-Amz-SignedHeaders=host&X-Amz-Signature=22807026db1210370170cd5cf49bfbb9e86010425c9d1834a56e049faf39b368
+
+*/

package/src/worker/BulkImportWorker.ts

@@ -0,0 +1,117 @@
+import { IWorkerAdapter } from '@unchainedshop/types/worker';
+import { WorkerDirector } from '@unchainedshop/core-worker';
+import { createLogger } from '@unchainedshop/logger';
+import { BaseAdapter } from '@unchainedshop/utils';
+import fs from 'fs';
+import JSONStream from 'JSONStream';
+import { EventIterator } from 'event-iterator';
+
+const logger = createLogger('unchained:platform:bulk-import');
+
+const streamPayloadToBulkImporter = async (bulkImporter, createReadStream) => {
+  logger.profile(`parseAsync`, { level: 'verbose' });
+
+  const eventIterator = new EventIterator(
+    (queue) => {
+      const readStream = createReadStream();
+      const jsonStream = JSONStream.parse('events.*'); // rows, ANYTHING, doc
+      jsonStream.on('data', queue.push);
+      jsonStream.on('close', queue.stop);
+      jsonStream.on('error', queue.fail);
+
+      queue.on('highWater', () => readStream.pause());
+      queue.on('lowWater', () => readStream.resume());
+
+      readStream.pipe(jsonStream);
+      return () => {
+        jsonStream.removeListener('data', queue.push);
+        jsonStream.removeListener('close', queue.stop);
+        jsonStream.removeListener('error', queue.fail);
+        jsonStream.destroy();
+      };
+    },
+    { highWaterMark: 100, lowWaterMark: 5 },
+  );
+
+  for await (const event of eventIterator) { // eslint-disable-line
+    await bulkImporter.prepare(event);
+  }
+
+  logger.profile(`parseAsync`, { level: 'verbose' });
+};
+
+export const BulkImportWorker: IWorkerAdapter<any, Record<string, unknown>> = {
+  ...BaseAdapter,
+
+  key: 'shop.unchained.worker-plugin.bulk-import',
+  label: 'Bulk Import',
+  version: '1.0',
+  type: 'BULK_IMPORT',
+
+  doWork: async (rawPayload, context) => {
+    try {
+      const {
+        createShouldUpsertIfIDExists = false,
+        skipCacheInvalidation = false,
+        authorId = 'root',
+      } = rawPayload;
+
+      const bulkImporter = context.bulkImporter.createBulkImporter(
+        {
+          logger,
+          authorId,
+          createShouldUpsertIfIDExists,
+          skipCacheInvalidation,
+        },
+        context,
+      );
+
+      if (rawPayload.payloadFilePath) {
+        // stream payload from file system
+        await streamPayloadToBulkImporter(bulkImporter, () =>
+          fs.createReadStream(rawPayload.payloadFilePath),
+        );
+      } else if (rawPayload.payloadId) {
+        // stream payload from gridfs
+        await streamPayloadToBulkImporter(bulkImporter, () =>
+          context.bulkImporter.BulkImportPayloads.openDownloadStream(rawPayload.payloadId),
+        );
+      } else {
+        const { events } = rawPayload;
+        if (!events?.length) throw new Error('No events submitted');
+
+        await events.reduce(async (currentEventPromise, nextEvent) => {
+          await currentEventPromise;
+          return bulkImporter.prepare(nextEvent);
+        }, Promise.resolve());
+      }
+
+      const [result, error] = await bulkImporter.execute();
+      await bulkImporter.invalidateCaches();
+
+      if (error) {
+        return {
+          success: false,
+          result,
+          error,
+        };
+      }
+      return {
+        success: true,
+        result,
+      };
+    } catch (err) {
+      logger.error(err.message, err);
+      return {
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+        },
+      };
+    }
+  },
+};
+
+WorkerDirector.registerAdapter(BulkImportWorker);

package/src/worker/GenerateOrderWorker.ts

@@ -0,0 +1,156 @@
+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';
+import { IWorkerAdapter } from '@unchainedshop/types/worker';
+import {
+  EnrollmentDirector,
+  enrollmentsSettings,
+  EnrollmentStatus,
+} from 'meteor/unchained:core-enrollments';
+import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core-worker';
+
+const generateOrder = async (
+  enrollment: Enrollment,
+  params: {
+    orderProducts: Array<{ orderPosition: OrderPosition; product: Product }>;
+    orderContext?: any;
+  } & { [x: string]: any },
+  requestContext: Context,
+) => {
+  if (!enrollment.payment || !enrollment.delivery) return null;
+
+  const { modules } = requestContext;
+  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,
+  );
+  const orderId = order._id;
+
+  if (orderProducts) {
+    await Promise.all(
+      orderProducts.map(({ orderPosition, product }) =>
+        modules.orders.positions.addProductItem(orderPosition, { order, product }, requestContext),
+      ),
+    );
+  } else {
+    const product = await modules.products.findProduct({
+      productId: enrollment.productId,
+    });
+    await modules.orders.positions.addProductItem(
+      { quantity: 1 },
+      {
+        order,
+        product,
+      },
+      requestContext,
+    );
+  }
+
+  const { paymentProviderId, context: paymentContext } = enrollment.payment;
+
+  if (paymentProviderId) {
+    await modules.orders.setPaymentProvider(orderId, paymentProviderId, requestContext);
+  }
+  const { deliveryProviderId, context: deliveryContext } = enrollment.delivery;
+  if (deliveryProviderId) {
+    await modules.orders.setDeliveryProvider(orderId, deliveryProviderId, requestContext);
+  }
+
+  order = await modules.orders.checkout(
+    order._id,
+    {
+      paymentContext,
+      deliveryContext,
+      orderContext,
+    },
+    requestContext,
+  );
+
+  return order;
+};
+
+const GenerateOrderWorker: IWorkerAdapter<any, any> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.generate-enrollment-orders',
+  label: 'Generates new Orders from Enrollments',
+  version: '1.0',
+  type: 'ENROLLMENT_ORDER_GENERATOR',
+
+  doWork: async (input, requestContext) => {
+    const { modules } = requestContext;
+
+    const enrollments = await modules.enrollments.findEnrollments({
+      status: [EnrollmentStatus.ACTIVE, EnrollmentStatus.PAUSED],
+    });
+
+    const errors = (
+      await Promise.all(
+        enrollments.map(async (enrollment) => {
+          try {
+            const director = await EnrollmentDirector.actions({ enrollment }, requestContext);
+            const period = await director.nextPeriod();
+            if (period) {
+              const configuration = await director.configurationForOrder({
+                ...input,
+                period,
+              });
+              if (configuration) {
+                const order = await generateOrder(enrollment, configuration, requestContext);
+                if (order) {
+                  await modules.enrollments.addEnrollmentPeriod(enrollment._id, {
+                    ...period,
+                    orderId: order._id,
+                  });
+                }
+              }
+            }
+          } catch (e) {
+            return {
+              name: e.name,
+              message: e.message,
+              stack: e.stack,
+            };
+          }
+          return null;
+        }),
+      )
+    ).filter(Boolean);
+
+    if (errors.length) {
+      return {
+        success: false,
+        error: {
+          name: 'SOME_ENROLLMENTS_COULD_NOT_PROCESS',
+          message: 'Some errors have been reported during order generation',
+          logs: errors,
+        },
+        result: {},
+      };
+    }
+    return {
+      success: true,
+      result: input,
+    };
+  },
+};
+
+WorkerDirector.registerAdapter(GenerateOrderWorker);
+
+export const configureGenerateOrderAutoscheduling = () => {
+  if (enrollmentsSettings.autoSchedulingSchedule) {
+    WorkerDirector.configureAutoscheduling(GenerateOrderWorker, {
+      schedule: enrollmentsSettings.autoSchedulingSchedule,
+      input: enrollmentsSettings.autoSchedulingInput,
+    });
+  }
+};

package/src/worker/MessageWorker.ts

@@ -0,0 +1,62 @@
+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';
+
+export const messagingLogger = createLogger('unchained:core-messaging');
+
+export const MessageWorker: IWorkerAdapter<
+  { template: string; _id?: string; [x: string]: any },
+  { info?: string; forked?: Array<Work> }
+> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.message',
+  label: 'Send Message by combining payload with a template and start concrete jobs',
+  version: '1.0',
+  type: 'MESSAGE',
+
+  doWork: async ({ template, ...payload }, requestContext, workId) => {
+    try {
+      const templateResolver = MessagingDirector.getTemplate(template);
+
+      const workConfigurations = await templateResolver(
+        {
+          template,
+          ...payload,
+        },
+        requestContext,
+      );
+
+      if (workConfigurations.length > 0) {
+        const forked = await Promise.all(
+          workConfigurations.map(async (workConfiguration: any) => {
+            const work = await requestContext.modules.worker.addWork(
+              {
+                ...workConfiguration,
+                originalWorkId: workId,
+              },
+              requestContext.userId,
+            );
+            delete work.input;
+            return work;
+          }),
+        );
+        return { success: true, result: { forked } };
+      }
+      return { success: true, result: { info: 'Skipped Message' } };
+    } catch (err) {
+      messagingLogger.warn(err.stack);
+      return {
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+        },
+      };
+    }
+  },
+};
+
+WorkerDirector.registerAdapter(MessageWorker);

package/src/worker/ZombieKillerWorker.ts

@@ -0,0 +1,114 @@
+import { IWorkerAdapter } from '@unchainedshop/types/worker';
+import { WorkerDirector } from '@unchainedshop/core-worker';
+import { createLogger } from '@unchainedshop/logger';
+import { BaseAdapter } from '@unchainedshop/utils';
+
+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,
+  {
+    deletedProductMediaCount: number;
+    deletedAssortmentMediaCount: number;
+    deletedFilesCount: number;
+  }
+> = {
+  ...BaseAdapter,
+
+  key: 'shop.unchained.worker-plugin.zombie-killer',
+  label: 'Zombie Killer',
+  version: '1.0',
+  type: 'ZOMBIE_KILLER',
+
+  doWork: async (_, unchainedAPI) => {
+    const { modules, services } = unchainedAPI;
+
+    try {
+      const error = false;
+
+      // Remove unreferenced product media objects
+      const products = await modules.products.findProducts({}, findId);
+      const deletedProductMediaCount = await modules.products.media.deleteMediaFiles({
+        excludedProdcutIds: products.map(mapId),
+      });
+
+      // Remove unreferenced assortment media objects
+      const assortments = await modules.assortments.findAssortments({}, findId);
+      const deletedAssortmentMediaCount = await modules.assortments.media.deleteMediaFiles({
+        excludedAssortmentIds: assortments.map(mapId),
+      });
+
+      // 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 },
+        },
+      });
+      const filesWithAssortmentId = await modules.files.findFilesByMetaData({
+        meta: {
+          assortmentId: { $exists: true },
+        },
+      });
+
+      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));
+
+      const deletedFilesCount =
+        fileIdsToRemove.length > 0
+          ? await services.files.removeFiles(
+            {
+              fileIds: fileIdsToRemove,
+            },
+            unchainedAPI,
+          )
+          : 0;
+
+      // Return delete count
+      const result = {
+        deletedProductMediaCount,
+        deletedAssortmentMediaCount,
+        deletedFilesCount,
+      };
+
+      if (error) {
+        return {
+          success: false,
+          result,
+          error,
+        };
+      }
+      return {
+        success: true,
+        result,
+      };
+    } catch (err) {
+      logger.error(err.message, err);
+      return {
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+        },
+      };
+    }
+  },
+};
+
+export default ZombieKillerWorker;
+
+WorkerDirector.registerAdapter(ZombieKillerWorker);

package/src/worker/email.ts

@@ -0,0 +1,60 @@
+import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core-worker';
+import { createLogger } from '@unchainedshop/logger';
+import { Email } from 'meteor/email';
+import { IWorkerAdapter } from '@unchainedshop/types/worker';
+
+const logger = createLogger('unchained:plugins:worker:email');
+
+const EmailWorkerPlugin: IWorkerAdapter<
+  {
+    from?: string;
+    to?: string;
+    subject?: string;
+    [x: string]: any;
+  },
+  void
+> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.email',
+  label: 'Send a Mail through Meteor Mailer',
+  version: '1.0',
+
+  type: 'EMAIL',
+
+  doWork: async ({ from, to, subject, ...rest }) => {
+    logger.debug(`${EmailWorkerPlugin.key} -> doWork: ${from} -> ${to} (${subject})`);
+
+    if (!to) {
+      return {
+        success: false,
+        error: {
+          name: 'RECIPIENT_REQUIRED',
+          message: 'EMAIL requires a to',
+        },
+      };
+    }
+
+    try {
+      // https://docs.meteor.com/api/email.html#Email-send
+      const result = Email.send({
+        from,
+        to,
+        subject,
+        ...rest,
+      });
+      return { success: true, result };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+        },
+      };
+    }
+  },
+};
+
+WorkerDirector.registerAdapter(EmailWorkerPlugin);

package/src/worker/external.ts

@@ -0,0 +1,17 @@
+import { IWorkerAdapter } from '@unchainedshop/types/worker';
+import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core-worker';
+
+export const ExternalWorkerPlugin: IWorkerAdapter<void, void> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.external',
+  label: 'External plugin as a placeholder for workers who interact with the system only via GraphQL',
+  version: '1.0',
+  type: 'EXTERNAL',
+
+  async doWork() {
+    throw new Error('Cannot do work for external workers');
+  },
+};
+
+WorkerDirector.registerAdapter(ExternalWorkerPlugin);

package/src/worker/heartbeat.ts

@@ -0,0 +1,45 @@
+import { IWorkerAdapter } from '@unchainedshop/types/worker';
+import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core-worker';
+
+const wait = async (time: number) => {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(true);
+    }, time);
+  });
+};
+
+type Arg = {
+  wait?: number;
+  fails?: boolean;
+};
+
+type Result = Arg;
+
+const Heartbeat: IWorkerAdapter<Arg, Result> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.heartbeat',
+  label: 'Heartbeat plugin to check if workers are working',
+  version: '1.0',
+
+  type: 'HEARTBEAT',
+
+  doWork: async (input: Arg): Promise<{ success: boolean; result: Result }> => {
+    if (input?.wait) {
+      await wait(input.wait);
+    }
+    if (input?.fails) {
+      return {
+        success: false,
+        result: input,
+      };
+    }
+    return {
+      success: true,
+      result: input,
+    };
+  },
+};
+
+WorkerDirector.registerAdapter(Heartbeat);

package/src/worker/http-request.ts

@@ -0,0 +1,75 @@
+import { IWorkerAdapter } from '@unchainedshop/types/worker';
+import fetch from 'isomorphic-unfetch';
+import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core-worker';
+import { log, LogLevel } from '@unchainedshop/logger';
+
+const postFetch = async (url, { data, headers }) => {
+  return fetch(url, {
+    method: 'POST',
+    body: JSON.stringify(data),
+    headers: { 'Content-Type': 'application/json', ...headers },
+  });
+};
+
+const nonPostFetch = async (url, { headers, method = 'GET' }) => {
+  return fetch(url, {
+    method,
+    headers,
+  });
+};
+
+const HttpRequestWorkerPlugin: IWorkerAdapter<
+  { url?: string; data?: any; headers?: any; method: 'POST' | 'GET' },
+  any
+> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.http-request',
+  label: 'Request a resource via http request. 200 = success',
+  version: '1.0',
+  type: 'HTTP_REQUEST',
+
+  async doWork({ url, data = {}, headers, method = 'POST' } = { method: 'POST' }) {
+    log(`${this.key} -> doWork: ${method} ${url} ${data}`, {
+      level: LogLevel.Debug,
+    });
+
+    if (!url) {
+      return {
+        success: false,
+        error: {
+          name: 'URL_REQUIRED',
+          message: 'HTTP_REQUEST requires an url',
+        },
+      };
+    }
+
+    try {
+      const normalizedFetch = method.toUpperCase() === 'POST' ? postFetch : nonPostFetch;
+      const res = await normalizedFetch(url, { data, headers, method });
+
+      const contentType = res.headers.get('content-type');
+      const isJson = contentType && contentType.includes('application/json');
+
+      const result = isJson ? await res.json() : { text: await res.text() };
+
+      if (res.status === 200 && res.ok) {
+        return { success: true, result };
+      }
+      return { success: false, result };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+        },
+      };
+    }
+  },
+};
+
+WorkerDirector.registerAdapter(HttpRequestWorkerPlugin);
+
+export default HttpRequestWorkerPlugin;