@unchainedshop/plugins 4.3.4 → 4.4.0

package/src/worker/bulkgate.ts

@@ -1,138 +0,0 @@
-import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-
-const { BULKGATE_APPLICATION_ID, BULKGATE_APPLICATION_TOKEN } = process.env;
-
-// BulkGate Simple API for SMS (transactional by default, promotional via boolean)
-const BulkGateWorker: IWorkerAdapter<
-  {
-    from?: string;
-    to?: string;
-    text?: string;
-    unicode?: boolean;
-    country?: string;
-    schedule?: string | number; // ISO 8601 format or Unix timestamp
-    promotional?: boolean; // Set to true for promotional SMS, defaults to transactional
-    [key: string]: any;
-  },
-  any
-> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker-plugin.bulkgate',
-  label: 'Send SMS through BulkGate',
-  version: '1.0.0',
-
-  type: 'BULKGATE',
-
-  doWork: async ({
-    from,
-    to,
-    text,
-    unicode = false,
-    country,
-    schedule,
-    promotional = false,
-    ...params
-  }) => {
-    try {
-      // Choose API endpoint based on promotional flag
-      const url = promotional
-        ? 'https://portal.bulkgate.com/api/1.0/simple/promotional'
-        : 'https://portal.bulkgate.com/api/1.0/simple/transactional';
-
-      // Prepare the request body
-      const requestBody = {
-        application_id: BULKGATE_APPLICATION_ID,
-        application_token: BULKGATE_APPLICATION_TOKEN,
-        number: to, // Phone number in international format (or semicolon-separated for promotional)
-        text: text || '',
-        unicode: unicode, // Boolean value for unicode support
-        sender_id: from ? 'gText' : 'gSystem', // Use text sender if 'from' is provided
-        sender_id_value: from || '', // Custom sender name if using gText
-        ...(country && { country }), // Optional country code
-        ...(schedule && { schedule }), // Optional scheduled time
-        ...params, // Any additional parameters
-      };
-
-      const response = await fetch(url, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Cache-Control': 'no-cache',
-        },
-        body: JSON.stringify(requestBody),
-      });
-
-      const responseData = await response.json();
-
-      // Check if we have an error response
-      if (responseData.error || responseData.type) {
-        return {
-          success: false,
-          error: {
-            name: 'BULKGATE_ERROR',
-            message:
-              responseData.error ||
-              `Failed to send ${promotional ? 'promotional' : 'transactional'} SMS`,
-            type: responseData.type || null,
-            code: responseData.code || response.status,
-            detail: responseData.detail || null,
-          },
-        };
-      }
-
-      // Success response (transactional has specific structure, promotional might vary)
-      if (responseData.data) {
-        // For transactional SMS, check for specific accepted status
-        if (!promotional && responseData.data.status === 'accepted') {
-          return {
-            success: true,
-            result: {
-              sms_id: responseData.data.sms_id,
-              price: responseData.data.price,
-              credit: responseData.data.credit,
-              number: responseData.data.number,
-              status: responseData.data.status,
-            },
-            error: null,
-          };
-        }
-
-        // For promotional SMS or other successful responses
-        if (promotional || responseData.data.status) {
-          return {
-            success: true,
-            result: responseData.data,
-            error: null,
-          };
-        }
-      }
-
-      // Unexpected response format
-      return {
-        success: false,
-        error: {
-          name: 'BULKGATE_ERROR',
-          message: 'Unexpected response format from BulkGate API',
-          response: responseData,
-        },
-      };
-    } catch (err) {
-      return {
-        success: false,
-        error: {
-          name: err.name,
-          message: err.message,
-          stack: err.stack,
-        },
-      };
-    }
-  },
-};
-
-// Register the plugin
-WorkerDirector.registerAdapter(BulkGateWorker);
-
-// Environment variables needed:
-// BULKGATE_APPLICATION_ID=your_application_id
-// BULKGATE_APPLICATION_TOKEN=your_application_token

package/src/worker/email.ts

@@ -1,165 +0,0 @@
-import { WorkerDirector, WorkerAdapter, IWorkerAdapter } from '@unchainedshop/core';
-import { spawn } from 'node:child_process';
-import { writeFile, mkdtemp } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:worker:email');
-
-export const checkEmailInterceptionEnabled = () => {
-  return process.env.NODE_ENV !== 'production' && !process.env.UNCHAINED_DISABLE_EMAIL_INTERCEPTION;
-};
-
-const buildLink = async ({ filename, content, href, contentType, encoding, path }) => {
-  if (path) {
-    return `<a href="file:/${path.startsWith('/') ? path : `${process.cwd()}/${path}`}">${filename}</a>`;
-  }
-  if (href) {
-    return `<a href="${href}">${filename}</a>`;
-  }
-  if (content && encoding === 'base64') {
-    return `<a target="_blank" href="${`data:${contentType};base64,${content}`}">${filename}</a>`;
-  }
-  return '';
-};
-
-let nodemailer;
-try {
-  const nodemailerModule = await import('nodemailer');
-  nodemailer = nodemailerModule.default;
-} catch {
-  logger.warn(`optional peer npm package 'nodemailer' not installed, emails can't be sent`);
-}
-
-const openInBrowser = async (options): Promise<boolean> => {
-  const command = {
-    darwin: 'open',
-    win32: 'explorer.exe',
-    linux: 'xdg-open',
-  }[process.platform];
-
-  if (!command) {
-    return false;
-  }
-
-  const messageBody = options.html || options.text.replace(/(\r\n|\n|\r)/gm, '<br/>');
-  const attachmentLinks = await Promise.all((options.attachments || []).map(buildLink));
-  const content = `
-<!DOCTYPE html>
-<html lang="en" xmlns="https://www.w3.org/1999/xhtml" xmlns:o="urn:schemas-microsoft-com:office:office">
-  <head>
-    <meta charset="UTF-8"/>
-    <meta name="viewport" content="width=device-width,initial-scale=1">
-  </head>
-  <body>
-    <b>From:&nbsp</b>${options.from}<br/>
-    <b>To:&nbsp;</b>${options.to}<br/>
-    <b>Cc:&nbsp;</b>${options.cc}<br/>
-    <b>Bcc:&nbsp;</b>${options.bcc}<br/>
-    <b>Reply-To:&nbsp;</b>${options.replyTo}<br/>
-    <br/>
-    <b>subject:&nbsp;</b>${options.subject}<br/>
-    <b>attachments:&nbsp;</b>${attachmentLinks.join(',&nbsp;')}<br/>
-    <hr/>
-    ${messageBody}
-  </body>
-</html>`;
-
-  // Create a temporary directory and file
-  const tempDir = await mkdtemp(join(tmpdir(), 'unchained-email-'));
-  const tempFile = join(tempDir, 'email-preview.html');
-
-  await writeFile(tempFile, content, 'utf8');
-
-  return new Promise((resolve) => {
-    const child = spawn(command, [tempFile], {
-      detached: true,
-      stdio: 'ignore',
-    });
-
-    child.unref();
-
-    // Resolve immediately after spawning since process is detached
-    resolve(true);
-  });
-};
-
-const EmailWorkerPlugin: IWorkerAdapter<
-  {
-    from?: string;
-    to?: string;
-    subject?: string;
-    [x: string]: any;
-  },
-  any
-> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker-plugin.email',
-  label: 'Send a Mail through Nodemailer',
-  version: '1.0.0',
-  type: 'EMAIL',
-
-  doWork: async ({ from, to, subject, ...rest }) => {
-    if (!to) {
-      return {
-        success: false,
-        error: {
-          name: 'RECIPIENT_REQUIRED',
-          message: 'EMAIL requires a to',
-        },
-      };
-    }
-
-    try {
-      const sendMailOptions = {
-        from,
-        to,
-        subject,
-        ...rest,
-      };
-      if (checkEmailInterceptionEnabled()) {
-        const opened = await openInBrowser(sendMailOptions);
-        return {
-          success: opened,
-          result: opened ? { intercepted: true } : undefined,
-          error: !opened ? { message: "Interception failed due to missing package 'open'" } : undefined,
-        };
-      }
-
-      if (!process.env.MAIL_URL) {
-        return {
-          success: false,
-          error: { name: 'NO_MAIL_URL_SET', message: 'MAIL_URL is not set' },
-        };
-      }
-
-      if (!nodemailer) {
-        return {
-          success: false,
-          error: {
-            name: 'NODEMAILER_NOT_INSTALLED',
-            message:
-              'npm dependency nodemailer is not installed, please install it to use email features',
-          },
-        };
-      }
-
-      const transporter = nodemailer.createTransport(process.env.MAIL_URL);
-      const result = await transporter.sendMail(sendMailOptions);
-      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/enrollment-order-generator.ts

@@ -1,94 +0,0 @@
-import { enrollmentsSettings, EnrollmentStatus } from '@unchainedshop/core-enrollments';
-import { EnrollmentDirector, WorkerDirector, WorkerAdapter, IWorkerAdapter } from '@unchainedshop/core';
-
-const GenerateOrderWorker: IWorkerAdapter<never, any> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker-plugin.generate-enrollment-orders',
-  label: 'Generates new Orders from Enrollments',
-  version: '1.0.0',
-  type: 'ENROLLMENT_ORDER_GENERATOR',
-
-  doWork: async (input, unchainedAPI) => {
-    const { modules, services } = unchainedAPI;
-
-    const enrollments = await modules.enrollments.findEnrollments({
-      status: [EnrollmentStatus.ACTIVE, EnrollmentStatus.PAUSED],
-    });
-
-    const errors = (
-      await Promise.all(
-        enrollments.map(async (enrollment) => {
-          try {
-            const product = await unchainedAPI.modules.products.findProduct({
-              productId: enrollment.productId,
-            });
-            const director = await EnrollmentDirector.actions(
-              { enrollment, product: product! },
-              unchainedAPI,
-            );
-            const period = await director.nextPeriod();
-            if (period) {
-              if (period.isTrial) {
-                await modules.enrollments.addEnrollmentPeriod(enrollment._id, {
-                  ...period,
-                });
-                return null;
-              }
-              const configuration = await director.configurationForOrder({
-                period,
-              });
-              if (configuration) {
-                const order = await services.enrollments.generateOrderFromEnrollment(
-                  enrollment,
-                  configuration,
-                );
-                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({
-      type: GenerateOrderWorker.type,
-      schedule: enrollmentsSettings.autoSchedulingSchedule,
-      retries: 5,
-    });
-  }
-};

package/src/worker/error-notifications.ts

@@ -1,83 +0,0 @@
-import { Work, WorkStatus } from '@unchainedshop/core-worker';
-import { IWorkerAdapter, WorkerDirector, WorkerAdapter } from '@unchainedshop/core';
-import later from '@breejs/later';
-
-interface Arg {
-  secondsPassed?: number;
-}
-
-interface Result {
-  forked?: string;
-}
-
-const everyDayAtFourInTheNight = later.parse.cron('0 3 * * *');
-
-export const ErrorNotifications: IWorkerAdapter<Arg, Result> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker.error-notifications',
-  label: 'Send a daily report about errors that failed permanently/unrecoverable',
-  version: '1.0',
-
-  type: 'ERROR_NOTIFICATIONS',
-
-  doWork: async (args, context, workId) => {
-    const work = (await context.modules.worker.findWork({ workId })) as Work;
-    const secondsPassed = args?.secondsPassed || 60;
-    const to = new Date();
-    const from = new Date(new Date(work.scheduled).getTime() - secondsPassed * 1000);
-
-    try {
-      const workItems = (
-        await context.modules.worker.findWorkQueue({
-          scheduled: {
-            end: to,
-            start: from,
-          },
-          types: undefined,
-          status: [WorkStatus.FAILED],
-        })
-      ).filter((workItem) => workItem.type !== ErrorNotifications.type && workItem.retries === 0);
-
-      if (!workItems.length) {
-        return { success: true, result: {} };
-      }
-
-      const message = await context.modules.worker.addWork({
-        type: 'MESSAGE',
-        retries: 0,
-        input: {
-          workItems,
-          template: 'ERROR_REPORT',
-        },
-        originalWorkId: workId,
-      });
-
-      return {
-        success: true,
-        result: { forked: message._id },
-      };
-    } catch (err) {
-      return {
-        success: false,
-        error: {
-          name: err.name,
-          message: err.message,
-          stack: err.stack,
-        },
-      };
-    }
-  },
-};
-
-WorkerDirector.registerAdapter(ErrorNotifications);
-
-export default ErrorNotifications;
-
-const ONE_DAY_IN_SECONDS = 24 * 60 * 60;
-WorkerDirector.configureAutoscheduling({
-  type: ErrorNotifications.type,
-  schedule: everyDayAtFourInTheNight,
-  input: async () => ({ secondsPassed: ONE_DAY_IN_SECONDS }),
-  retries: 0,
-});

package/src/worker/export-token.ts

@@ -1,32 +0,0 @@
-import { WorkerEventTypes, Work } from '@unchainedshop/core-worker';
-import { IWorkerAdapter, UnchainedCore, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-import { subscribe } from '@unchainedshop/events';
-
-export const ExportTokenWorker: IWorkerAdapter<void, void> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker-plugin.export-token',
-  label: 'External worker to hold the state of the minting/export process of tokens',
-  version: '1.0.0',
-  type: 'EXPORT_TOKEN',
-  external: true,
-
-  async doWork() {
-    throw new Error('Cannot do work for external workers');
-  },
-};
-
-export const configureExportToken = (unchainedAPI: UnchainedCore) => {
-  subscribe<Work>(WorkerEventTypes.FINISHED, async ({ payload: work }) => {
-    if (work.type === 'EXPORT_TOKEN' && work.success) {
-      await unchainedAPI.modules.warehousing.updateTokenOwnership({
-        tokenId: work.input.token._id,
-        walletAddress: work.input.recipientWalletAddress,
-      });
-    }
-  });
-};
-
-export default configureExportToken;
-
-WorkerDirector.registerAdapter(ExportTokenWorker);

package/src/worker/external.ts

@@ -1,17 +0,0 @@
-import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-
-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.0',
-  type: 'EXTERNAL',
-  external: true,
-
-  async doWork() {
-    throw new Error('Cannot do work for external workers');
-  },
-};
-
-WorkerDirector.registerAdapter(ExternalWorkerPlugin);

package/src/worker/heartbeat.ts

@@ -1,37 +0,0 @@
-import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-import { setTimeout } from 'node:timers/promises';
-
-interface 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.0',
-  type: 'HEARTBEAT',
-  maxParallelAllocations: 1,
-
-  doWork: async (input: Arg): Promise<{ success: boolean; result: Result }> => {
-    if (input?.wait) {
-      await setTimeout(input.wait);
-    }
-    if (input?.fails) {
-      return {
-        success: false,
-        result: input,
-      };
-    }
-    return {
-      success: true,
-      result: input,
-    };
-  },
-};
-
-WorkerDirector.registerAdapter(Heartbeat);

package/src/worker/http-request.ts

@@ -1,71 +0,0 @@
-import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-
-const postFetch = async (url, { data, headers }) => {
-  return fetch(url, {
-    method: 'POST',
-    body: JSON.stringify(data),
-    // eslint-disable-next-line
-    // @ts-ignore
-    duplex: 'half',
-    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.0',
-  type: 'HTTP_REQUEST',
-
-  async doWork({ url, data = {}, headers, method = 'POST' } = { method: 'POST' }) {
-    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;

package/src/worker/message.ts

@@ -1,56 +0,0 @@
-import { MessagingDirector, IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-import { Work } from '@unchainedshop/core-worker';
-
-export const MessageWorker: IWorkerAdapter<
-  { template: string; _id: string; [x: string]: any },
-  { info?: string; forked?: Work[] }
-> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker-plugin.message',
-  label: 'Send Message by combining payload with a template and start concrete jobs',
-  version: '1.0.0',
-  type: 'MESSAGE',
-
-  doWork: async ({ template, ...payload }, unchainedAPI, workId) => {
-    try {
-      const templateResolver = MessagingDirector.getTemplate(template);
-
-      if (!templateResolver) throw new Error(`No template resolver found for template ${template}`);
-
-      const workConfigurations = await templateResolver(
-        {
-          template,
-          ...payload,
-        },
-        unchainedAPI,
-      );
-
-      if (workConfigurations.length > 0) {
-        const forked = await Promise.all(
-          workConfigurations.map(async (workConfiguration: any) => {
-            const work = await unchainedAPI.modules.worker.addWork({
-              ...workConfiguration,
-              originalWorkId: workId,
-            });
-            delete (work as any).input; // Remove input from returned work for privacy
-            return work;
-          }),
-        );
-        return { success: true, result: { forked } };
-      }
-      return { success: true, result: { forked: [] } };
-    } catch (err) {
-      return {
-        success: false,
-        error: {
-          name: err.name,
-          message: err.message,
-          stack: err.stack,
-        },
-      };
-    }
-  },
-};
-
-WorkerDirector.registerAdapter(MessageWorker);