@unchainedshop/plugins 3.1.15 → 4.0.0-rc.10

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

@@ -24,10 +24,10 @@ export const getTaxRate = (context: ProductPricingAdapterContext) => {
 
 export const isDeliveryAddressInSwitzerland = async ({
   order,
-  country,
+  countryCode: forceCountryCode,
   modules,
 }: ProductPricingAdapterContext & { modules: UnchainedCore['modules'] }) => {
-  let countryCode = country?.toUpperCase().trim();
+  let countryCode = forceCountryCode?.toUpperCase().trim() || order.countryCode;
 
   if (order) {
     const orderDelivery = await modules.orders.deliveries.findDelivery({

package/src/warehousing/eth-minter.ts

@@ -119,12 +119,12 @@ const ETHMinter: IWarehousingAdapter = {
         const url = signedUrl && (await modules.files.normalizeUrl(signedUrl, {}));
         const text = await modules.products.texts.findLocalizedText({
           productId: product._id,
-          locale: locale?.baseName || systemLocale.baseName,
+          locale: locale || systemLocale,
         });
 
         const name = `${text.title} #${chainTokenId}`;
 
-        const isDefaultLanguageActive = locale ? locale?.language === systemLocale.language : true;
+        const isDefaultLanguageActive = locale ? locale.language === systemLocale.language : true;
         const localization = isDefaultLanguageActive
           ? {
               uri: `${ROOT_URL}/erc-metadata/${product._id}/{locale}/${tokenId}.json`,

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

@@ -44,7 +44,7 @@ const streamPayloadToBulkImporter = async (
     { highWaterMark: 100, lowWaterMark: 5 },
   );
 
-  for await (const event of eventIterator) { // eslint-disable-line
+  for await (const event of eventIterator) {
     await bulkImporter.prepare(event, unchainedAPI);
   }
 

package/src/worker/bulkgate.ts

@@ -0,0 +1,138 @@
+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/enrollment-order-generator.ts

@@ -12,8 +12,8 @@ import {
 const generateOrder = async (
   enrollment: Enrollment,
   params: {
-    orderPositions: Array<OrderPosition>;
-  } & { [x: string]: any },
+    orderPositions: OrderPosition[];
+  } & Record<string, any>,
   unchainedAPI: Pick<UnchainedCore, 'modules' | 'services'>,
 ) => {
   if (!enrollment.payment || !enrollment.delivery) return null;
@@ -22,7 +22,7 @@ const generateOrder = async (
   const { orderPositions, ...configuration } = params;
   let order = await modules.orders.create({
     userId: enrollment.userId,
-    currency: enrollment.currencyCode,
+    currencyCode: enrollment.currencyCode,
     countryCode: enrollment.countryCode,
     contact: enrollment.contact,
     billingAddress: enrollment.billingAddress,

package/src/worker/error-notifications.ts

@@ -2,13 +2,13 @@ import { WorkStatus } from '@unchainedshop/core-worker';
 import { IWorkerAdapter, WorkerDirector, WorkerAdapter } from '@unchainedshop/core';
 import later from '@breejs/later';
 
-type Arg = {
+interface Arg {
   secondsPassed?: number;
-};
+}
 
-type Result = {
+interface Result {
   forked?: string;
-};
+}
 
 const everyDayAtFourInTheNight = later.parse.cron('0 3 * * *');
 

package/src/worker/heartbeat.ts

@@ -1,17 +1,10 @@
 import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
+import { setTimeout } from 'node:timers/promises';
 
-const wait = async (time: number) => {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(true);
-    }, time);
-  });
-};
-
-type Arg = {
+interface Arg {
   wait?: number;
   fails?: boolean;
-};
+}
 
 type Result = Arg;
 
@@ -26,7 +19,7 @@ const Heartbeat: IWorkerAdapter<Arg, Result> = {
 
   doWork: async (input: Arg): Promise<{ success: boolean; result: Result }> => {
     if (input?.wait) {
-      await wait(input.wait);
+      await setTimeout(input.wait);
     }
     if (input?.fails) {
       return {

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

@@ -0,0 +1,71 @@
+import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
+
+const { TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_SMS_FROM } = process.env;
+
+const SmsWorkerPlugin: IWorkerAdapter<
+  {
+    from?: string;
+    to?: string;
+    text?: string;
+    [key: string]: any; // Allow additional parameters
+  },
+  any
+> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.twilio',
+  label: 'Send Messages through Twilio',
+  version: '1.0.0',
+
+  type: 'TWILIO',
+
+  doWork: async ({ from, to, text, ...params }) => {
+    try {
+      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,
+          ...params, // Include any additional parameters passed
+        }),
+      });
+
+      const data = await response.json();
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: {
+            name: 'TWILIO_ERROR',
+            message: data.message || 'Failed to send SMS',
+          },
+        };
+      }
+
+      return {
+        success: true,
+        result: {
+          sid: data.sid,
+        },
+        error: null,
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+        },
+      };
+    }
+  },
+};
+
+WorkerDirector.registerAdapter(SmsWorkerPlugin);

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/lib/accounts/google-oauth.d.ts

@@ -1,4 +0,0 @@
-import { IOAuth2Adapter } from '@unchainedshop/types/accounts.js';
-declare const GoogleOAuth2Adapter: IOAuth2Adapter;
-export default GoogleOAuth2Adapter;
-//# sourceMappingURL=google-oauth.d.ts.map

package/lib/accounts/google-oauth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"google-oauth.d.ts","sourceRoot":"","sources":["../../src/accounts/google-oauth.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAmFlE,QAAA,MAAM,mBAAmB,EAAE,cA4F1B,CAAC;AAIF,eAAe,mBAAmB,CAAC"}