@unchainedshop/plugins 4.0.0-rc.8 → 4.0.0

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

@@ -1,73 +1,7 @@
-import { Enrollment } from '@unchainedshop/core-enrollments';
-import { OrderPosition } from '@unchainedshop/core-orders';
 import { enrollmentsSettings, EnrollmentStatus } from '@unchainedshop/core-enrollments';
-import {
-  EnrollmentDirector,
-  UnchainedCore,
-  WorkerDirector,
-  WorkerAdapter,
-  IWorkerAdapter,
-} from '@unchainedshop/core';
+import { EnrollmentDirector, WorkerDirector, WorkerAdapter, IWorkerAdapter } from '@unchainedshop/core';
 
-const generateOrder = async (
-  enrollment: Enrollment,
-  params: {
-    orderPositions: OrderPosition[];
-  } & Record<string, any>,
-  unchainedAPI: Pick<UnchainedCore, 'modules' | 'services'>,
-) => {
-  if (!enrollment.payment || !enrollment.delivery) return null;
-
-  const { modules, services } = unchainedAPI;
-  const { orderPositions, ...configuration } = params;
-  let order = await modules.orders.create({
-    userId: enrollment.userId,
-    currencyCode: enrollment.currencyCode,
-    countryCode: enrollment.countryCode,
-    contact: enrollment.contact,
-    billingAddress: enrollment.billingAddress,
-    originEnrollmentId: enrollment._id,
-    ...configuration,
-  });
-  const orderId = order._id;
-
-  if (orderPositions) {
-    await Promise.all(
-      orderPositions.map((orderPosition) => modules.orders.positions.addProductItem(orderPosition)),
-    );
-  } else {
-    const product = await modules.products.findProduct({
-      productId: enrollment.productId,
-    });
-    await modules.orders.positions.addProductItem({
-      quantity: 1,
-      productId: product._id,
-      originalProductId: product._id,
-      orderId: order._id,
-    });
-  }
-
-  const { paymentProviderId, context: paymentContext } = enrollment.payment;
-  if (paymentProviderId) {
-    await modules.orders.setPaymentProvider(orderId, paymentProviderId);
-  }
-
-  const { deliveryProviderId, context: deliveryContext } = enrollment.delivery;
-  if (deliveryProviderId) {
-    await modules.orders.setDeliveryProvider(orderId, deliveryProviderId);
-  }
-
-  await services.orders.updateCalculation(orderId);
-
-  order = await services.orders.checkoutOrder(order._id, {
-    paymentContext,
-    deliveryContext,
-  });
-
-  return order;
-};
-
-const GenerateOrderWorker: IWorkerAdapter<any, any> = {
+const GenerateOrderWorker: IWorkerAdapter<never, any> = {
   ...WorkerAdapter,
 
   key: 'shop.unchained.worker-plugin.generate-enrollment-orders',
@@ -76,7 +10,7 @@ const GenerateOrderWorker: IWorkerAdapter<any, any> = {
   type: 'ENROLLMENT_ORDER_GENERATOR',
 
   doWork: async (input, unchainedAPI) => {
-    const { modules } = unchainedAPI;
+    const { modules, services } = unchainedAPI;
 
     const enrollments = await modules.enrollments.findEnrollments({
       status: [EnrollmentStatus.ACTIVE, EnrollmentStatus.PAUSED],
@@ -86,7 +20,13 @@ const GenerateOrderWorker: IWorkerAdapter<any, any> = {
       await Promise.all(
         enrollments.map(async (enrollment) => {
           try {
-            const director = await EnrollmentDirector.actions({ enrollment }, unchainedAPI);
+            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) {
@@ -96,11 +36,13 @@ const GenerateOrderWorker: IWorkerAdapter<any, any> = {
                 return null;
               }
               const configuration = await director.configurationForOrder({
-                ...input,
                 period,
               });
               if (configuration) {
-                const order = await generateOrder(enrollment, configuration, unchainedAPI);
+                const order = await services.enrollments.generateOrderFromEnrollment(
+                  enrollment,
+                  configuration,
+                );
                 if (order) {
                   await modules.enrollments.addEnrollmentPeriod(enrollment._id, {
                     ...period,

package/src/worker/error-notifications.ts

@@ -1,4 +1,4 @@
-import { WorkStatus } from '@unchainedshop/core-worker';
+import { Work, WorkStatus } from '@unchainedshop/core-worker';
 import { IWorkerAdapter, WorkerDirector, WorkerAdapter } from '@unchainedshop/core';
 import later from '@breejs/later';
 
@@ -22,7 +22,7 @@ export const ErrorNotifications: IWorkerAdapter<Arg, Result> = {
   type: 'ERROR_NOTIFICATIONS',
 
   doWork: async (args, context, workId) => {
-    const work = await context.modules.worker.findWork({ 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);

package/src/worker/export-token.ts

@@ -21,7 +21,6 @@ export const configureExportToken = (unchainedAPI: UnchainedCore) => {
     if (work.type === 'EXPORT_TOKEN' && work.success) {
       await unchainedAPI.modules.warehousing.updateTokenOwnership({
         tokenId: work.input.token._id,
-        userId: null,
         walletAddress: work.input.recipientWalletAddress,
       });
     }

package/src/worker/message.ts

@@ -2,7 +2,7 @@ import { MessagingDirector, IWorkerAdapter, WorkerAdapter, WorkerDirector } from
 import { Work } from '@unchainedshop/core-worker';
 
 export const MessageWorker: IWorkerAdapter<
-  { template: string; _id?: string; [x: string]: any },
+  { template: string; _id: string; [x: string]: any },
   { info?: string; forked?: Work[] }
 > = {
   ...WorkerAdapter,
@@ -16,6 +16,8 @@ export const MessageWorker: IWorkerAdapter<
     try {
       const templateResolver = MessagingDirector.getTemplate(template);
 
+      if (!templateResolver) throw new Error(`No template resolver found for template ${template}`);
+
       const workConfigurations = await templateResolver(
         {
           template,
@@ -31,13 +33,13 @@ export const MessageWorker: IWorkerAdapter<
               ...workConfiguration,
               originalWorkId: workId,
             });
-            delete work.input;
+            delete (work as any).input; // Remove input from returned work for privacy
             return work;
           }),
         );
         return { success: true, result: { forked } };
       }
-      return { success: true, result: { info: 'Skipped Message' } };
+      return { success: true, result: { forked: [] } };
     } catch (err) {
       return {
         success: false,

package/src/worker/{sms.ts → twilio.ts}

@@ -5,41 +5,29 @@ const { TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_SMS_FROM } = process.env;
 const SmsWorkerPlugin: IWorkerAdapter<
   {
     from?: string;
-    to?: string;
-    text?: string;
+    to: string;
+    text: string;
+    [key: string]: any; // Allow additional parameters
   },
   any
 > = {
   ...WorkerAdapter,
 
-  key: 'shop.unchained.worker-plugin.sms',
-  label: 'Send a SMS through Twilio',
+  key: 'shop.unchained.worker-plugin.twilio',
+  label: 'Send Messages through Twilio',
   version: '1.0.0',
 
-  type: 'SMS',
+  type: 'TWILIO',
 
-  doWork: async ({ from, to, text }) => {
-    if (!TWILIO_SMS_FROM && !from) {
-      return {
-        success: false,
-        error: {
-          name: 'SENDER_REQUIRED',
-          message: 'SMS requires a from, TWILIO_SMS_FROM not set',
-        },
-      };
-    }
+  doWork: async ({ from, to, text, ...params }) => {
+    try {
+      if (!TWILIO_SMS_FROM && !from)
+        throw new Error(
+          'Missing Twilio "from" number. Set TWILIO_SMS_FROM env var or provide "from" in input',
+        );
 
-    if (!to) {
-      return {
-        success: false,
-        error: {
-          name: 'RECIPIENT_REQUIRED',
-          message: 'SMS requires a to',
-        },
-      };
-    }
+      if (!to) throw new Error('Missing "to" in input');
 
-    try {
       const url = `https://api.twilio.com/2010-04-01/Accounts/${TWILIO_ACCOUNT_SID}/Messages.json`;
       const response = await fetch(url, {
         method: 'POST',
@@ -49,8 +37,9 @@ const SmsWorkerPlugin: IWorkerAdapter<
         },
         body: new URLSearchParams({
           Body: text || '',
-          From: from || TWILIO_SMS_FROM,
+          From: from || TWILIO_SMS_FROM!,
           To: to,
+          ...params, // Include any additional parameters passed
         }),
       });
 

package/src/pricing/product-swiss-tax.test.ts

@@ -1,139 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-import { getTaxRate, isDeliveryAddressInSwitzerland } from './product-swiss-tax.js';
-
-describe('ProductSwissTax', () => {
-  describe('getTaxRate', () => {
-    it('default rate', () => {
-      assert.strictEqual(
-        getTaxRate({
-          product: {} as any,
-          order: {} as any,
-        } as any),
-        0.081,
-      );
-    });
-
-    it('reduced rate', () => {
-      assert.strictEqual(
-        getTaxRate({
-          product: {
-            tags: ['swiss-tax-category:reduced'],
-          },
-          order: {},
-        } as any),
-        0.026,
-      );
-    });
-
-    it('special rate', () => {
-      assert.strictEqual(
-        getTaxRate({
-          product: {
-            tags: ['swiss-tax-category:special'],
-          },
-          order: {},
-        } as any),
-        0.038,
-      );
-    });
-
-    it('default rate', () => {
-      assert.strictEqual(
-        getTaxRate({
-          product: {
-            tags: ['swiss-tax-category:default'],
-          },
-          order: {},
-        } as any),
-        0.081,
-      );
-    });
-  });
-
-  describe('isDeliveryAddressInSwitzerland', () => {
-    const context = {
-      modules: {
-        orders: {
-          deliveries: {
-            findDelivery: async ({ orderDeliveryId }) => {
-              if (orderDeliveryId === 'CH' || orderDeliveryId === 'LI')
-                return { context: { address: { countryCode: 'CH' } } };
-              if (orderDeliveryId === null) return { context: { address: null } };
-              return { context: { address: { countryCode: 'RT' } } };
-            },
-          },
-        },
-      },
-      order: {
-        deliveryId: 'CH',
-        billingAddress: { countryCode: 'LI' },
-      },
-      countryCode: 'CH',
-    };
-    it('Should return true when passed country code CH', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({ ...context, countryCode: 'ch', order: null } as any),
-        true,
-      );
-    });
-
-    it('Should return true when passed country code LI', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({ ...context, countryCode: 'LI', order: null } as any),
-        true,
-      );
-    });
-
-    it('Should return false when country is neither CH nor LI and order is null', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({ ...context, countryCode: 'ET', order: null } as any),
-        false,
-      );
-    });
-
-    it('Order should take precedence over country parameter', async () => {
-      // not CH or LI order so returns false
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({
-          ...context,
-          countryCode: 'CH',
-          order: {
-            deliveryId: 'ET',
-            billingAddress: { countryCode: 'ET' },
-          },
-        } as any),
-        false,
-      );
-    });
-
-    it('If order is not from CH and LI but billingAddress is, it should take precedence over country ', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({
-          ...context,
-          countryCode: 'IT',
-          order: {
-            deliveryId: null,
-            billingAddress: { countryCode: 'CH' },
-          },
-        } as any),
-        true,
-      );
-    });
-
-    it('Should return false if billingAddress is neither CH or LI and order does not have address', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({
-          ...context,
-          country: null,
-          order: {
-            deliveryId: null,
-            billingAddress: { countryCode: 'HH' },
-          },
-        } as any),
-        false,
-      );
-    });
-  });
-});