@unchainedshop/plugins 4.0.0-rc.2 → 4.0.0-rc.21

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

@@ -0,0 +1,268 @@
+import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
+
+const { BUDGETSMS_USERNAME, BUDGETSMS_USERID, BUDGETSMS_HANDLE } = process.env;
+
+// BudgetSMS Plugin - Verified against official API documentation
+// Note: BudgetSMS API has a quirk where it returns error 1001 (authentication failed)
+// when you have insufficient credit, instead of the correct error 1003.
+const BudgetSMSWorker: IWorkerAdapter<
+  {
+    from?: string;
+    to: string;
+    text?: string;
+    test?: boolean; // If true, uses test endpoint (no credit deducted)
+    customid?: string;
+    price?: boolean; // Include price info in response
+    mccmnc?: boolean; // Include carrier info in response
+    credit?: boolean; // Include remaining credit in response
+    [key: string]: any;
+  },
+  any
+> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.budgetsms',
+  label: 'Send Messages through BudgetSMS',
+  version: '1.0.0',
+
+  type: 'BUDGETSMS',
+
+  doWork: async ({
+    from,
+    to,
+    text,
+    test = false,
+    customid,
+    price = false,
+    mccmnc = false,
+    credit = false,
+    ...params
+  }) => {
+    try {
+      // Validate credentials
+      if (!BUDGETSMS_USERNAME || !BUDGETSMS_USERID || !BUDGETSMS_HANDLE) {
+        throw new Error(
+          'Missing BudgetSMS credentials. Please set BUDGETSMS_USERNAME, BUDGETSMS_USERID, and BUDGETSMS_HANDLE',
+        );
+      }
+
+      // Trim credentials to remove any whitespace
+      const username = BUDGETSMS_USERNAME.trim();
+      const userid = BUDGETSMS_USERID.trim();
+      const handle = BUDGETSMS_HANDLE.trim();
+
+      // Validate userid is numeric only
+      if (!/^\d+$/.test(userid)) {
+        throw new Error('BUDGETSMS_USERID must be numeric only. Found: ' + userid);
+      }
+
+      // Choose endpoint based on test mode
+      const url = test ? 'https://api.budgetsms.net/testsms/' : 'https://api.budgetsms.net/sendsms/';
+
+      // Format phone number according to E.164 (no + or 00, no spaces/dashes)
+      const formattedTo = to.replace(/^\+|^00/, '').replace(/[\s-]/g, '');
+
+      // Build query parameters
+      const queryParams = new URLSearchParams({
+        username: username,
+        userid: userid,
+        handle: handle,
+        msg: text || '', // Note: parameter is 'msg' not 'text'
+        from: from || '',
+        to: formattedTo,
+        ...(customid && { customid }),
+        ...(!test && price && { price: '1' }), // Price info only for real sends
+        ...(!test && mccmnc && { mccmnc: '1' }), // Carrier info only for real sends
+        ...(!test && credit && { credit: '1' }), // Credit info only for real sends
+        ...params,
+      });
+
+      // Make GET request
+      const fullUrl = `${url}?${queryParams.toString()}`;
+
+      const response = await fetch(fullUrl, {
+        method: 'GET',
+        headers: {
+          Accept: 'text/plain',
+          'User-Agent': 'Unchained/BudgetSMS-Plugin',
+        },
+      });
+
+      const responseText = await response.text().then((text) => text.trim());
+
+      // Parse response: "OK <smsid> [price] [parts] [mccmnc] [credit]" or "ERR <errorcode>"
+      if (responseText.startsWith('OK')) {
+        const parts = responseText.split(' ');
+        const result: any = {
+          sms_id: parts[1] || null,
+          status: test ? 'test_successful' : 'sent',
+          test_mode: test,
+        };
+
+        if (test) {
+          result.message = 'Test SMS validated successfully (no credit deducted)';
+        } else {
+          // Parse additional info based on parameters used
+          let index = 2;
+          if (price && parts[index] && parts[index + 1]) {
+            result.price = parseFloat(parts[index]);
+            result.parts = parseInt(parts[index + 1]);
+            index += 2;
+          }
+          if (mccmnc && parts[index]) {
+            result.mccmnc = parts[index];
+            index += 1;
+          }
+          if (credit && parts[index]) {
+            result.remaining_credit = parseFloat(parts[index]);
+          }
+        }
+
+        return {
+          success: true,
+          result,
+          error: null,
+        };
+      }
+
+      if (responseText.startsWith('ERR')) {
+        const parts = responseText.split(' ');
+        const errorCode = parts[1] || 'UNKNOWN';
+
+        // Error code mappings from documentation
+        const errorMessages: Record<string, string> = {
+          '1001': 'Authentication failed OR insufficient credit (BudgetSMS returns 1001 for both)',
+          '1002': 'Account not active',
+          '1003': 'Insufficient credit',
+          '1004': 'No access to this API',
+          '1005': 'No handle provided',
+          '1006': 'No UserID provided',
+          '1007': 'No Username provided',
+          '2001': 'SMS message text is empty',
+          '2002': 'SMS numeric senderid can be max. 16 numbers',
+          '2003': 'SMS alphanumeric sender can be max. 11 characters',
+          '2004': 'SMS senderid is empty or invalid',
+          '2005': 'Destination number is too short',
+          '2006': 'Destination is not numeric',
+          '2007': 'Destination is empty',
+          '2008': 'SMS text is not OK (check encoding?)',
+          '2009': 'Parameter issue',
+          '2010': 'Destination number is invalidly formatted',
+          '2011': 'Destination is invalid',
+          '2012': 'SMS message text is too long',
+          '2013': 'SMS message is invalid',
+          '2014': 'SMS CustomID is used before',
+          '2015': 'Charset problem',
+          '2016': 'Invalid UTF-8 encoding',
+          '3001': 'No route to destination',
+          '3002': 'No routes are setup',
+          '3003': 'Invalid destination',
+          '4001': 'System error, related to customid',
+          '4002': 'System error, temporary issue',
+        };
+
+        // Special handling for 1001 error
+        let message = errorMessages[errorCode] || `Unknown error code: ${errorCode}`;
+        if (errorCode === '1001') {
+          message += '. Note: Check your account balance - BudgetSMS may return 1001 when credit is 0.';
+        }
+
+        return {
+          success: false,
+          error: {
+            name: 'BUDGETSMS_ERROR',
+            code: errorCode,
+            message,
+          },
+        };
+      }
+
+      // Unexpected response
+      return {
+        success: false,
+        error: {
+          name: 'BUDGETSMS_ERROR',
+          message: 'Unexpected response format from BudgetSMS API',
+          response: responseText,
+        },
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+        },
+      };
+    }
+  },
+};
+
+WorkerDirector.registerAdapter(BudgetSMSWorker);
+
+// Environment variables needed:
+// BUDGETSMS_USERNAME=your_username (alphanumeric)
+// BUDGETSMS_USERID=your_userid (NUMERIC ONLY - found in BudgetSMS control panel)
+// BUDGETSMS_HANDLE=your_api_handle (alphanumeric - found in BudgetSMS control panel)
+
+// IMPORTANT: The userid MUST be numeric only. You can find it in the BudgetSMS control panel after login.
+// Example: BUDGETSMS_USERID=12345 (NOT "user12345" or any non-numeric value)
+
+// Usage examples:
+//
+// Send real SMS (requires credits):
+// await WorkerDirector.doWork({
+//   type: 'BUDGETSMS',
+//   from: 'YourCompany',
+//   to: '+41791234567',
+//   text: 'Your message here',
+//   price: true, // Get price info
+//   credit: true, // Get remaining credit
+// });
+//
+// Test SMS (no credit deducted):
+// await WorkerDirector.doWork({
+//   type: 'BUDGETSMS',
+//   test: true,
+//   from: 'YourCompany',
+//   to: '+41791234567',
+//   text: 'Test message',
+// });
+//
+// IMPORTANT: If you get error 1001, it could mean either:
+// 1. Authentication failed (wrong credentials)
+// 2. Insufficient credit (0 balance)
+// Use the checkBudgetSmsCredentials() helper to verify which one it is.
+
+// Helper function to check credentials and balance
+export async function checkBudgetSmsCredentials() {
+  const url = 'https://api.budgetsms.net/checkcredit/';
+  const username = process.env.BUDGETSMS_USERNAME?.trim();
+  const userid = process.env.BUDGETSMS_USERID?.trim();
+  const handle = process.env.BUDGETSMS_HANDLE?.trim();
+
+  if (!username || !userid || !handle) {
+    return { error: 'Missing credentials' };
+  }
+
+  if (!/^\d+$/.test(userid)) {
+    return { error: 'UserID must be numeric only' };
+  }
+
+  const queryParams = new URLSearchParams({ username, userid, handle });
+
+  try {
+    const response = await fetch(`${url}?${queryParams.toString()}`, { method: 'GET' });
+    const text = await response.text();
+
+    if (text.startsWith('OK')) {
+      const credit = parseFloat(text.split(' ')[1]) || 0;
+      return { success: true, credit };
+    } else {
+      return { error: text };
+    }
+  } catch (err) {
+    return { error: err.message };
+  }
+}

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);