@unchainedshop/plugins 4.0.0-rc.9 → 4.0.0

package/src/pricing/tax/ch.ts

@@ -1,14 +1,16 @@
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import { Product } from '@unchainedshop/core-products';
+
 const startOf2024 = new Date('2024-01-01T00:00:00.000+0100');
 
 // https://www.estv.admin.ch/estv/en/home/value-added-tax/vat-rates-switzerland.html
 
-export const SwissTaxCategories: Record<
-  string,
-  {
-    value: string;
-    rate: (referenceDate?: Date) => number;
-  }
-> = {
+export interface SwissTaxCategoryResolver {
+  value: string;
+  rate: (referenceDate?: Date) => number;
+}
+
+export const SwissTaxCategories: Record<string, SwissTaxCategoryResolver> = {
   DEFAULT: {
     value: 'default',
     rate: (referenceDate = new Date()) => {
@@ -37,3 +39,27 @@ export const SwissTaxCategories: Record<
     },
   },
 };
+
+export const resolveTaxCategoryFromDeliveryProvider = (
+  provider: DeliveryProvider,
+): SwissTaxCategoryResolver | null => {
+  const taxCategoryFromProvider = provider?.configuration
+    ?.find(({ key }) => {
+      if (key === 'swiss-tax-category') return true;
+      return null;
+    })
+    ?.value?.toUpperCase();
+
+  const taxCategory = taxCategoryFromProvider ? SwissTaxCategories[taxCategoryFromProvider] : null;
+  return taxCategory;
+};
+
+export const resolveTaxCategoryFromProduct = (product: Product): SwissTaxCategoryResolver | null => {
+  const productSpecialTaxTag = product.tags?.find((tag) =>
+    tag?.trim().toLowerCase().startsWith('swiss-tax-category:'),
+  );
+  const taxCategory = Object.values(SwissTaxCategories).find(
+    (t) => `swiss-tax-category:${t.value}` === productSpecialTaxTag?.trim().toLowerCase(),
+  );
+  return taxCategory || null;
+};

package/src/pricing/utils/isDeliveryAddressInCountry.test.ts

@@ -0,0 +1,106 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import isDeliveryAddressInCountry from './isDeliveryAddressInCountry.js';
+
+describe('isDeliveryAddressInCountry', () => {
+  const context = {
+    modules: {
+      orders: {
+        deliveries: {
+          findDelivery: async ({ orderDeliveryId }: any) => {
+            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 isDeliveryAddressInCountry({ ...context, countryCode: 'ch', order: null } as any, [
+        'CH',
+        'LI',
+      ]),
+      true,
+    );
+  });
+
+  it('Should return true when passed country code LI', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInCountry({ ...context, countryCode: 'LI', order: null } as any, [
+        'CH',
+        'LI',
+      ]),
+      true,
+    );
+  });
+
+  it('Should return false when country is neither CH nor LI and order is null', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInCountry({ ...context, countryCode: 'ET', order: null } as any, [
+        'CH',
+        'LI',
+      ]),
+      false,
+    );
+  });
+
+  it('Order should take precedence over country parameter', async () => {
+    // not CH or LI order so returns false
+    assert.strictEqual(
+      await isDeliveryAddressInCountry(
+        {
+          ...context,
+          countryCode: 'CH',
+          order: {
+            deliveryId: 'ET',
+            billingAddress: { countryCode: 'ET' },
+          },
+        } as any,
+        ['CH', 'LI'],
+      ),
+      false,
+    );
+  });
+
+  it('If order is not from CH and LI but billingAddress is, it should take precedence over country ', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInCountry(
+        {
+          ...context,
+          countryCode: 'IT',
+          order: {
+            deliveryId: null,
+            billingAddress: { countryCode: 'CH' },
+          },
+        } as any,
+        ['CH', 'LI'],
+      ),
+      true,
+    );
+  });
+
+  it('Should return false if billingAddress is neither CH or LI and order does not have address', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInCountry(
+        {
+          ...context,
+          country: null,
+          order: {
+            deliveryId: null,
+            billingAddress: { countryCode: 'HH' },
+          },
+        } as any,
+        ['CH', 'LI'],
+      ),
+      false,
+    );
+  });
+});

package/src/pricing/utils/isDeliveryAddressInCountry.ts

@@ -0,0 +1,26 @@
+import { Order, OrderDelivery } from '@unchainedshop/core-orders';
+
+export default function isDeliveryAddressInCountry(
+  {
+    orderDelivery,
+    order,
+    countryCode: forceCountryCode = null,
+  }: {
+    orderDelivery?: OrderDelivery | null;
+    order?: Order | null;
+    countryCode?: string | null;
+  },
+  allowedCountryCodes: string[],
+) {
+  let countryCode = forceCountryCode?.toUpperCase().trim() || order?.countryCode;
+
+  if (orderDelivery || order) {
+    const address = orderDelivery?.context?.address || order?.billingAddress;
+    if (address?.countryCode > '') {
+      countryCode = address.countryCode?.toUpperCase().trim();
+    }
+  }
+
+  if (!countryCode) return false;
+  return allowedCountryCodes.includes(countryCode);
+}

package/src/warehousing/eth-minter.ts

@@ -11,9 +11,12 @@ import { ProductContractStandard, ProductTypes } from '@unchainedshop/core-produ
 import { systemLocale } from '@unchainedshop/utils';
 import { generateDbObjectId } from '@unchainedshop/mongodb';
 import { getFileAdapter } from '@unchainedshop/core-files';
+import { createLogger } from '@unchainedshop/logger';
 
 const { MINTER_TOKEN_OFFSET = '0', ROOT_URL = 'http://localhost:4010' } = process.env;
 
+const logger = createLogger('unchained:eth-minter');
+
 const ETHMinter: IWarehousingAdapter = {
   ...WarehousingAdapter,
 
@@ -40,7 +43,7 @@ const ETHMinter: IWarehousingAdapter = {
           ? { contractAddress: contractStandard }
           : {
               contractAddress: contractStandard,
-              chainTokenId: tokenId,
+              tokenSerialNumber: tokenId,
             },
       );
       const tokensCreated = existingTokens.reduce((acc, curToken) => {
@@ -57,7 +60,13 @@ const ETHMinter: IWarehousingAdapter = {
       },
 
       configurationError() {
-        return null as any as WarehousingError;
+        if (contractStandard === 'ERC1155' && !tokenId) {
+          logger.error(
+            `Token ID is required for ERC1155 contract standard (productId: ${product!._id})`,
+          );
+          return WarehousingError.INCOMPLETE_CONFIGURATION;
+        }
+        return null;
       },
 
       stock: async () => {
@@ -74,11 +83,17 @@ const ETHMinter: IWarehousingAdapter = {
         const meta = { contractStandard };
         const tokensCreated = await getTokensCreated();
 
+        if (!orderPosition) {
+          throw new Error('Order position not found in context');
+        }
+
         if (contractStandard === 'ERC721') {
-          // ERC721 is non-fungible, thus every chainTokenId unique!
-          const items = new Array(orderPosition?.quantity).fill(null).map((_, i) => ({
+          // ERC721 is non-fungible, thus every tokenSerialNumber unique!
+          const items = new Array(orderPosition.quantity).fill(null).map((_, i) => ({
             _id: generateDbObjectId(),
-            chainTokenId: Number(parseInt(MINTER_TOKEN_OFFSET, 10) + tokensCreated + (i + 1)).toString(),
+            tokenSerialNumber: Number(
+              parseInt(MINTER_TOKEN_OFFSET, 10) + tokensCreated + (i + 1),
+            ).toString(),
             contractAddress,
             quantity: 1,
             chainId,
@@ -90,20 +105,24 @@ const ETHMinter: IWarehousingAdapter = {
         return [
           {
             _id: generateDbObjectId(),
-            chainTokenId: tokenId,
+            tokenSerialNumber: tokenId!,
             contractAddress,
-            quantity: orderPosition?.quantity,
+            quantity: orderPosition.quantity,
             chainId,
             meta,
           },
         ];
       },
 
-      tokenMetadata: async (chainTokenId) => {
+      tokenMetadata: async (tokenSerialNumber) => {
         // Metadata standards supported
         // https://eips.ethereum.org/EIPS/eip-1155 (backward compatible with 721)
         // https://eips.ethereum.org/EIPS/eip-721
 
+        if (!product) {
+          throw new Error('Product not found in context');
+        }
+
         const allLanguages = await modules.languages.findLanguages({
           includeInactive: false,
         });
@@ -114,15 +133,15 @@ const ETHMinter: IWarehousingAdapter = {
         });
         const file = firstMedia && (await modules.files.findFile({ fileId: firstMedia.mediaId }));
 
-        const fileUploadAdapter = getFileAdapter();
-        const signedUrl = await fileUploadAdapter.createDownloadURL(file);
+        const fileAdapter = file && getFileAdapter();
+        const signedUrl = await fileAdapter?.createDownloadURL(file!);
         const url = signedUrl && (await modules.files.normalizeUrl(signedUrl, {}));
         const text = await modules.products.texts.findLocalizedText({
           productId: product._id,
           locale: locale || systemLocale,
         });
 
-        const name = `${text.title} #${chainTokenId}`;
+        const name = `${text.title} #${tokenSerialNumber}`;
 
         const isDefaultLanguageActive = locale ? locale.language === systemLocale.language : true;
         const localization = isDefaultLanguageActive

package/src/worker/budgetsms.ts

@@ -8,7 +8,7 @@ const { BUDGETSMS_USERNAME, BUDGETSMS_USERID, BUDGETSMS_HANDLE } = process.env;
 const BudgetSMSWorker: IWorkerAdapter<
   {
     from?: string;
-    to?: string;
+    to: string;
     text?: string;
     test?: boolean; // If true, uses test endpoint (no credit deducted)
     customid?: string;

package/src/worker/bulk-import.ts

@@ -1,57 +1,9 @@
 import { WorkerDirector, WorkerAdapter, IWorkerAdapter } from '@unchainedshop/core';
 import { createLogger } from '@unchainedshop/logger';
-import JSONStream from 'JSONStream';
-import { EventIterator } from 'event-iterator';
-import { UnchainedCore } from '@unchainedshop/core';
 
-const logger = createLogger('unchained:worker:bulk-import');
+const logger = createLogger('unchained:bulk-import');
 
-const streamPayloadToBulkImporter = async (
-  bulkImporter,
-  payloadId,
-  unchainedAPI: Pick<UnchainedCore, 'bulkImporter' | 'modules' | 'services'>,
-) => {
-  logger.trace(`parseAsync start`);
-
-  const readStream = await unchainedAPI.services.files.createDownloadStream({ fileId: payloadId });
-
-  if (!readStream) {
-    throw new Error(
-      'The current file adapter does not support streams when downloading required for streamed events. Please use a different file adapter.',
-    );
-  }
-
-  const eventIterator = new EventIterator(
-    (queue) => {
-      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);
-      readStream.on('error', queue.fail);
-
-      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) {
-    await bulkImporter.prepare(event, unchainedAPI);
-  }
-
-  logger.trace(`parseAsync done`);
-};
-
-export const BulkImportWorker: IWorkerAdapter<any, Record<string, unknown>> = {
+export const BulkImportWorker: IWorkerAdapter<any, Record<string, any>> = {
   ...WorkerAdapter,
 
   key: 'shop.unchained.worker-plugin.bulk-import',
@@ -76,13 +28,20 @@ export const BulkImportWorker: IWorkerAdapter<any, Record<string, unknown>> = {
 
       if (rawPayload.payloadId) {
         // stream payload from gridfs
-        await streamPayloadToBulkImporter(bulkImporter, rawPayload.payloadId, unchainedAPI);
+        const readStream = await unchainedAPI.services.files.createDownloadStream({
+          fileId: rawPayload.payloadId,
+        });
+        if (!readStream) {
+          throw new Error('Could not create download stream from uploaded file');
+        }
+        await unchainedAPI.bulkImporter.pipeEventStream(readStream, bulkImporter, unchainedAPI);
       } else {
         const { events } = rawPayload;
         if (!events?.length) throw new Error('No events submitted');
 
         await events.reduce(async (currentEventPromise, nextEvent) => {
           await currentEventPromise;
+          await bulkImporter.validate(nextEvent);
           return bulkImporter.prepare(nextEvent, unchainedAPI);
         }, Promise.resolve());
       }
@@ -93,13 +52,13 @@ export const BulkImportWorker: IWorkerAdapter<any, Record<string, unknown>> = {
       if (error) {
         return {
           success: false,
-          result,
+          result: result!,
           error,
         };
       }
       return {
         success: true,
-        result,
+        result: result!,
       };
     } catch (err) {
       logger.error(err);

package/src/worker/email.ts

@@ -1,5 +1,9 @@
 import { WorkerDirector, WorkerAdapter, IWorkerAdapter } from '@unchainedshop/core';
 import nodemailer from 'nodemailer';
+import { spawn } from 'node:child_process';
+import { writeFile, mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 export const checkEmailInterceptionEnabled = () => {
   return process.env.NODE_ENV !== 'production' && !process.env.UNCHAINED_DISABLE_EMAIL_INTERCEPTION;
@@ -18,10 +22,16 @@ const buildLink = async ({ filename, content, href, contentType, encoding, path
   return '';
 };
 
-const openInBrowser = async (options) => {
-  // eslint-disable-next-line
-  // @ts-ignore
-  const { default: open, apps } = await import('open');
+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));
@@ -46,11 +56,23 @@ const openInBrowser = async (options) => {
   </body>
 </html>`;
 
-  const base64 = Buffer.from(content).toString('base64');
-  const dataUri = `data:text/html;base64,${base64}`;
+  // 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();
 
-  await open(dataUri, { app: [{ name: apps.chrome }, { name: apps.firefox }, { name: apps.browser }] });
-  return true;
+    // Resolve immediately after spawning since process is detached
+    resolve(true);
+  });
 };
 
 const EmailWorkerPlugin: IWorkerAdapter<

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/twilio.ts

@@ -5,8 +5,8 @@ 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
@@ -21,6 +21,13 @@ const SmsWorkerPlugin: IWorkerAdapter<
 
   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) throw new Error('Missing "to" in input');
+
       const url = `https://api.twilio.com/2010-04-01/Accounts/${TWILIO_ACCOUNT_SID}/Messages.json`;
       const response = await fetch(url, {
         method: 'POST',
@@ -30,7 +37,7 @@ 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
         }),