@unchainedshop/plugins 3.1.11 → 4.0.0-rc.2

package/src/worker/message.ts

@@ -3,7 +3,7 @@ import { Work } from '@unchainedshop/core-worker';
 
 export const MessageWorker: IWorkerAdapter<
   { template: string; _id?: string; [x: string]: any },
-  { info?: string; forked?: Array<Work> }
+  { info?: string; forked?: Work[] }
 > = {
   ...WorkerAdapter,
 

package/src/worker/push-notification.ts

@@ -3,7 +3,7 @@ import webPush from 'web-push';
 
 const { PUSH_NOTIFICATION_PUBLIC_KEY, PUSH_NOTIFICATION_PRIVATE_KEY } = process.env;
 
-type NotificationOptions = {
+interface NotificationOptions {
   vapidDetails: {
     subject: string;
     publicKey: string;
@@ -12,7 +12,7 @@ type NotificationOptions = {
   TTL: number;
   urgency?: 'very-low' | 'low' | 'normal' | 'high';
   topic?: string;
-};
+}
 
 const PushNotificationWorkerPlugin: IWorkerAdapter<
   {

package/src/worker/sms.ts

@@ -1,16 +1,7 @@
 import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-import Twilio from 'twilio';
 
 const { TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_SMS_FROM } = process.env;
 
-/* Potential: no need for twilio npm
-curl -X POST "https://api.twilio.com/2010-04-01/Accounts/$TWILIO_ACCOUNT_SID/Messages.json" \
---data-urlencode "From=+15017122661" \
---data-urlencode "Body=Hi there" \
---data-urlencode "To=+15558675310" \
--u $TWILIO_ACCOUNT_SID:$TWILIO_AUTH_TOKEN
-*/
-
 const SmsWorkerPlugin: IWorkerAdapter<
   {
     from?: string;
@@ -49,25 +40,36 @@ const SmsWorkerPlugin: IWorkerAdapter<
     }
 
     try {
-      const client = Twilio(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN);
-      const { sid, errorMessage } = await client.messages.create({
-        body: text,
-        from: from || TWILIO_SMS_FROM,
-        to,
+      const url = `https://api.twilio.com/2010-04-01/Accounts/${TWILIO_ACCOUNT_SID}/Messages.json`;
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          Authorization: `Basic ${Buffer.from(`${TWILIO_ACCOUNT_SID}:${TWILIO_AUTH_TOKEN}`).toString('base64')}`,
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+          Body: text || '',
+          From: from || TWILIO_SMS_FROM,
+          To: to,
+        }),
       });
-      if (errorMessage) {
+
+      const data = await response.json();
+
+      if (!response.ok) {
         return {
           success: false,
           error: {
             name: 'TWILIO_ERROR',
-            message: errorMessage.toString(),
+            message: data.message || 'Failed to send SMS',
           },
         };
       }
+
       return {
         success: true,
         result: {
-          sid,
+          sid: data.sid,
         },
         error: null,
       };

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

@@ -3,7 +3,7 @@ import later from '@breejs/later';
 import { ProductPriceRate } from '@unchainedshop/core-products';
 import { resolveBestCurrency } from '@unchainedshop/utils';
 
-const getExchangeRates = async (base) => {
+const getExchangeRates = async (base): Promise<{ currency: string; rates: Record<string, string> }> => {
   return fetch(`https://api.coinbase.com/v2/exchange-rates?currency=${base}`, {
     method: 'GET',
   })
@@ -28,16 +28,13 @@ const UpdateCoinbaseRates: IWorkerAdapter<any, any> = {
 
       const currencyCodes = currencies.map((currency) => currency.isoCode);
 
-      const {
-        currency: baseCurrency,
-        rates: pairs,
-      }: { currency: string; rates: Record<string, string> } = await getExchangeRates(currencyCode);
+      const { currency: baseCurrency, rates: pairs } = await getExchangeRates(currencyCode);
       const timestamp = new Date();
 
       // five minutes
       const expiresAt = new Date(new Date().getTime() + 5 * 60 * 1000);
 
-      const rates: Array<ProductPriceRate> = Object.entries(pairs)
+      const rates: ProductPriceRate[] = Object.entries(pairs)
         .map(([quoteCurrency, rate]) => {
           return {
             baseCurrency,

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

@@ -3,7 +3,7 @@ import later from '@breejs/later';
 import { xml2json } from 'xml-js';
 import { ProductPriceRate } from '@unchainedshop/core-products';
 
-const getExchangeRates = async () => {
+const getExchangeRates = async (): Promise<{ currency: string; rate: string }[]> => {
   return fetch(`https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml`, {
     method: 'GET',
   })
@@ -34,7 +34,7 @@ const UpdateECBRates: IWorkerAdapter<any, any> = {
     const { modules } = unchainedAPI;
 
     try {
-      const data: Array<{ currency: string; rate: string }> = await getExchangeRates();
+      const data = await getExchangeRates();
       const timestamp = new Date();
       const expiresAt = new Date(new Date().getTime() + 24 * 60 * 60 * 1000);
 
@@ -50,7 +50,7 @@ const UpdateECBRates: IWorkerAdapter<any, any> = {
           },
         };
 
-      const rates: Array<ProductPriceRate> = data
+      const rates: ProductPriceRate[] = data
         .map((d) => {
           return {
             baseCurrency,

package/src/worker/BaseWorker.ts

@@ -1,116 +0,0 @@
-import later from '@breejs/later';
-import { Work, WorkData } from '@unchainedshop/core-worker';
-import { WorkerDirector } from '@unchainedshop/core';
-
-export type IWorker<P extends { workerId?: string }> = {
-  key: string;
-  label: string;
-  version: string;
-  type: string;
-  external: boolean;
-
-  getFloorDate: (date?: Date) => Date;
-
-  actions: (
-    params: P,
-    unchainedAPI,
-  ) => {
-    autorescheduleTypes: (options: { referenceDate: Date }) => Promise<Array<Work | null>>;
-    process: (options: { maxWorkItemCount?: number; referenceDate?: Date }) => Promise<void>;
-    reset: () => Promise<void>;
-    start: () => void;
-    stop: () => void;
-  };
-};
-
-interface WorkerParams {
-  workerId?: string;
-  worker: IWorker<any>;
-}
-
-export const BaseWorker: IWorker<WorkerParams> = {
-  key: 'shop.unchained.worker.base',
-  label: 'Base worker. Do not use this directly.',
-  version: '1.0.0',
-  type: 'BASE',
-  external: false,
-
-  getFloorDate: (date = new Date()) => {
-    const floored = new Date(Math.floor(date.getTime() / 1000) * 1000);
-    return floored;
-  },
-
-  actions: ({ workerId }: WorkerParams, unchainedAPI) => {
-    const workerActions = {
-      start() {
-        throw new Error(`Not implemented on ${this.constructor.key}`);
-      },
-
-      stop() {
-        throw new Error(`Not implemented on ${this.constructor.key}`);
-      },
-
-      reset: async (referenceDate = new Date()) => {
-        await unchainedAPI.modules.worker.markOldWorkAsFailed({
-          types: WorkerDirector.getActivePluginTypes({ external: false }),
-          worker: workerId,
-          referenceDate,
-        });
-      },
-
-      autorescheduleTypes: async ({ referenceDate }) => {
-        return Promise.all(
-          WorkerDirector.getAutoSchedules().map(async ([scheduleId, workConfig]) => {
-            if (!workConfig.schedule) {
-              await unchainedAPI.modules.worker.ensureNoWork({
-                type: workConfig.type,
-                priority: workConfig.priority || 0,
-                scheduleId,
-              });
-              return null;
-            }
-
-            const fixedSchedule = { ...workConfig.schedule };
-            fixedSchedule.schedules[0].s = [0]; // ignore seconds, always run on second 0
-            const nextDate = later.schedule(fixedSchedule).next(1, referenceDate) as Date;
-            nextDate.setMilliseconds(0);
-            const workData: WorkData = {
-              type: workConfig.type,
-              scheduleId,
-              scheduled: nextDate,
-              timeout: workConfig.timeout,
-              priority: workConfig.priority || 0,
-              retries: workConfig.retries || 0,
-            };
-            if (workConfig.input) {
-              workData.input = await workConfig.input(workData);
-              // A work input fn can skip auto scheduling a new record
-              // when it explicitly returns a falsish input instead of a dictionary
-              if (!workData.input) return null;
-            }
-            return unchainedAPI.modules.worker.ensureOneWork(workData);
-          }),
-        );
-      },
-
-      process: async ({ maxWorkItemCount, referenceDate }) => {
-        await workerActions.autorescheduleTypes({
-          referenceDate,
-        });
-
-        const processRecursively = async (recursionCounter = 0) => {
-          if (maxWorkItemCount && maxWorkItemCount < recursionCounter) return null;
-          const doneWork = await WorkerDirector.processNextWork(unchainedAPI, workerId);
-          if (doneWork) return processRecursively(recursionCounter + 1);
-          return null;
-        };
-
-        await processRecursively();
-      },
-    };
-
-    workerActions.reset();
-
-    return workerActions;
-  },
-};

package/src/worker/EventListenerWorker.ts

@@ -1,61 +0,0 @@
-import { subscribe } from '@unchainedshop/events';
-import { BaseWorker, IWorker } from './BaseWorker.js';
-import { WorkerEventTypes } from '@unchainedshop/core-worker';
-
-function debounce<T extends (...args: any) => any>(func: T, wait) {
-  let timeout;
-  return (...args) => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => {
-      timeout = null;
-      func(...args);
-    }, wait);
-  };
-}
-
-export interface EventListenerWorkerParams {
-  workerId?: string;
-}
-
-export const EventListenerWorker: IWorker<EventListenerWorkerParams> = {
-  ...BaseWorker,
-
-  key: 'shop.unchained.worker.event-listener',
-  label: 'Allocates work on events. This worker does not make sense on multiple containers.',
-  version: '1.0.0',
-  type: 'EVENT_LISTENER',
-
-  actions: ({ workerId }, unchainedAPI) => {
-    const baseWorkerActions = BaseWorker.actions(
-      { workerId, worker: EventListenerWorker },
-      unchainedAPI,
-    );
-
-    // Debounce in the event of many work queue events conflicting with each other
-    const processWorkQueue = debounce<() => Promise<void>>(async () => {
-      await baseWorkerActions.process({
-        maxWorkItemCount: 1, // only one work item at a time, else we could end up in a loop
-        referenceDate: EventListenerWorker.getFloorDate(),
-      });
-    }, 300);
-
-    return {
-      ...baseWorkerActions,
-
-      start() {
-        subscribe(WorkerEventTypes.ADDED, processWorkQueue);
-        subscribe(WorkerEventTypes.FINISHED, processWorkQueue);
-
-        setTimeout(async () => {
-          await baseWorkerActions.autorescheduleTypes({
-            referenceDate: EventListenerWorker.getFloorDate(),
-          });
-        }, 300);
-      },
-
-      stop() {
-        /* */
-      },
-    };
-  },
-};

package/src/worker/FailedRescheduler.ts

@@ -1,80 +0,0 @@
-import { defaultLogger } from '@unchainedshop/logger';
-import { subscribe } from '@unchainedshop/events';
-import { Work, WorkData, WorkerEventTypes } from '@unchainedshop/core-worker';
-
-export interface FailedReschedulerParams {
-  retryInput?: (
-    workData: WorkData,
-    priorInput: Record<string, any>,
-  ) => Promise<Record<string, any> | null>;
-}
-
-export type IScheduler<P> = {
-  key: string;
-  label: string;
-  version: string;
-
-  actions: (
-    params: P,
-    unchainedAPI,
-  ) => {
-    start: () => void;
-    stop: () => void;
-  };
-};
-
-export const FailedRescheduler: IScheduler<FailedReschedulerParams> = {
-  key: 'shop.unchained.scheduler.failed',
-  label: 'Reschedule failed works',
-  version: '1.0.0',
-
-  actions: ({ retryInput }, unchainedAPI) => {
-    const handleFinishedWork = async ({ payload: work }: { payload: Work }) => {
-      if (!work.success && work.retries > 0) {
-        const now = new Date();
-        const workDelayMs = work.scheduled.getTime() - work.created.getTime();
-
-        // In short: Double the delay of the old work or delay for 5 seconds
-        const scheduled =
-          workDelayMs > 1000
-            ? new Date(now.getTime() + workDelayMs * 2)
-            : new Date(now.setSeconds(now.getSeconds() + 5));
-
-        defaultLogger.error(
-          `${FailedRescheduler.key} -> Reschedule failed work ${work._id} ${
-            work.type
-          } for ${scheduled.toISOString()} (in ${Math.round(workDelayMs / 1000)}). Remaining retries: ${
-            work.retries
-          }`,
-        );
-
-        const workData: WorkData = {
-          type: work.type,
-          priority: work.priority,
-          originalWorkId: work.originalWorkId || work._id,
-          retries: work.retries - 1,
-          timeout: work.timeout,
-          scheduled,
-        };
-
-        if (retryInput) {
-          workData.input = await retryInput(workData, work.input);
-        } else {
-          workData.input = work.input;
-        }
-
-        unchainedAPI.modules.worker.addWork(workData);
-      }
-    };
-
-    return {
-      start() {
-        subscribe<Work>(WorkerEventTypes.FINISHED, handleFinishedWork);
-      },
-
-      stop() {
-        /* */
-      },
-    };
-  },
-};

package/src/worker/IntervalWorker.ts

@@ -1,54 +0,0 @@
-import later, { ScheduleData } from '@breejs/later';
-import { BaseWorker, IWorker } from './BaseWorker.js';
-
-const { NODE_ENV } = process.env;
-
-export interface IntervalWorkerParams {
-  workerId?: string;
-  batchCount?: number;
-  schedule?: ScheduleData;
-}
-
-const defaultSchedule = later.parse.text(
-  NODE_ENV !== 'production' ? 'every 2 seconds' : 'every 30 seconds',
-);
-
-export const scheduleToInterval = (schedule: ScheduleData) => {
-  const referenceDate = new Date(1000);
-  const [one, two] = later.schedule(schedule).next(2, referenceDate) as Date[];
-  const diff = new Date(two).getTime() - new Date(one).getTime();
-  return Math.min(1000 * 60 * 60, diff); // at least once every hour!
-};
-
-export const IntervalWorker: IWorker<IntervalWorkerParams> = {
-  ...BaseWorker,
-
-  key: 'shop.unchained.worker.cron',
-  label: 'Allocates work on fixed intervals with native node setInterval',
-  version: '1.0.0',
-  type: 'CRON',
-
-  actions: ({ workerId, batchCount = 0, schedule = defaultSchedule }, unchainedAPI) => {
-    const baseWorkerActions = BaseWorker.actions({ workerId, worker: IntervalWorker }, unchainedAPI);
-
-    const intervalDelay = scheduleToInterval(schedule);
-    let intervalHandle: NodeJS.Timeout;
-
-    return {
-      ...baseWorkerActions,
-
-      start() {
-        intervalHandle = setInterval(() => {
-          baseWorkerActions.process({
-            maxWorkItemCount: batchCount,
-            referenceDate: IntervalWorker.getFloorDate(),
-          });
-        }, intervalDelay);
-      },
-
-      stop() {
-        clearInterval(intervalHandle);
-      },
-    };
-  },
-};