@unchainedshop/plugins 4.3.4 → 4.4.0

package/src/worker/push-notification.ts

@@ -1,121 +0,0 @@
-import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:worker:push-notification');
-
-let webPush;
-try {
-  const module = await import('web-push');
-  webPush = module.default;
-} catch {
-  logger.warn(`optional peer npm package 'web-push' not installed, push notifications will not work`);
-}
-
-const { PUSH_NOTIFICATION_PUBLIC_KEY, PUSH_NOTIFICATION_PRIVATE_KEY } = process.env;
-
-interface NotificationOptions {
-  vapidDetails: {
-    subject: string;
-    publicKey: string;
-    privateKey: string;
-  };
-  TTL: number;
-  urgency?: 'very-low' | 'low' | 'normal' | 'high';
-  topic?: string;
-}
-
-const PushNotificationWorkerPlugin: IWorkerAdapter<
-  {
-    subscription: any;
-    payload: string;
-    subject: string;
-    urgency?: 'very-low' | 'low' | 'normal' | 'high';
-    topic?: string;
-  },
-  any
-> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker-plugin.push-notification',
-  label: 'Push Notification',
-
-  version: '1.0',
-
-  type: 'PUSH',
-
-  doWork: async ({ subscription, subject, payload, urgency = null, topic = null }) => {
-    if (!webPush) {
-      return {
-        success: false,
-        error: {
-          name: 'WEB_PUSH_NOT_INSTALLED',
-          message: 'npm dependency web-push is not installed, please install it to use this worker',
-        },
-      };
-    }
-
-    if (!PUSH_NOTIFICATION_PUBLIC_KEY)
-      return {
-        success: false,
-        error: {
-          name: 'VAPID_PUBLIC_KEY_REQUIRED',
-          message: 'vapidPublicKey key required to send push notifications',
-        },
-      };
-    if (!PUSH_NOTIFICATION_PRIVATE_KEY)
-      return {
-        success: false,
-        error: {
-          name: 'VAPID_PRIVATE_KEY_REQUIRED',
-          message: 'vapidPrivateKey key are required to send push notifications',
-        },
-      };
-
-    if (!subscription) {
-      return {
-        success: false,
-        error: {
-          name: 'USER_SUBSCRIPTION_OBJECT_REQUIRED',
-          message: 'PUSH service subscription required',
-        },
-      };
-    }
-
-    const options: NotificationOptions = {
-      vapidDetails: {
-        subject,
-        publicKey: PUSH_NOTIFICATION_PUBLIC_KEY,
-        privateKey: PUSH_NOTIFICATION_PRIVATE_KEY,
-      },
-      TTL: 60,
-    };
-
-    if (urgency) {
-      options.urgency = urgency;
-    }
-
-    if (topic) {
-      options.topic = topic;
-    }
-
-    try {
-      await webPush.sendNotification(subscription, payload, options);
-
-      return {
-        success: true,
-        error: null,
-      };
-    } catch (err) {
-      return {
-        success: false,
-        error: {
-          name: err.name,
-          message: err.message,
-          stack: err.stack,
-        },
-      };
-    }
-  },
-};
-
-WorkerDirector.registerAdapter(PushNotificationWorkerPlugin);

package/src/worker/twilio.ts

@@ -1,78 +0,0 @@
-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 {
-      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',
-        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

@@ -1,76 +0,0 @@
-import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-import later from '@breejs/later';
-import { ProductPriceRate } from '@unchainedshop/core-products';
-import { resolveBestCurrency } from '@unchainedshop/utils';
-
-const getExchangeRates = async (base): Promise<{ currency: string; rates: Record<string, string> }> => {
-  return fetch(`https://api.coinbase.com/v2/exchange-rates?currency=${base}`, {
-    method: 'GET',
-  })
-    .then((res) => res.json())
-    .then((r) => r?.data);
-};
-
-const everyMinute = later.parse.cron('* * * * *');
-
-const UpdateCoinbaseRates: IWorkerAdapter<any, any> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker.update-coinbase-rates',
-  label: 'Update Coinbase Rates',
-  version: '1.0.0',
-  type: 'UPDATE_COINBASE_RATES',
-
-  doWork: async (input, unchainedAPI) => {
-    try {
-      const currencies = await unchainedAPI.modules.currencies.findCurrencies({ includeInactive: true });
-      const currencyCode = resolveBestCurrency(null, currencies); // Get fallback currency
-
-      const currencyCodes = currencies.map((currency) => currency.isoCode);
-
-      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: ProductPriceRate[] = Object.entries(pairs)
-        .map(([quoteCurrency, rate]) => {
-          return {
-            baseCurrency,
-            quoteCurrency,
-            rate: parseFloat(rate),
-            timestamp,
-            expiresAt,
-          };
-        })
-        .filter(
-          (rate) =>
-            currencyCodes.includes(rate.quoteCurrency) && rate.quoteCurrency !== rate.baseCurrency,
-        );
-
-      const success = await unchainedAPI.modules.products.prices.rates.updateRates(rates);
-      return {
-        success,
-        result: {
-          ratesUpdated: rates.length,
-        },
-      };
-    } catch {
-      return {
-        success: false,
-        error: {
-          name: 'UPDATE_COINBASE_RATES_FAILED',
-          message: 'Updating Coinbase Rates failed',
-        },
-      };
-    }
-  },
-};
-
-WorkerDirector.registerAdapter(UpdateCoinbaseRates);
-
-WorkerDirector.configureAutoscheduling({
-  type: UpdateCoinbaseRates.type,
-  schedule: everyMinute,
-});

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

@@ -1,115 +0,0 @@
-import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-import { ProductPriceRate } from '@unchainedshop/core-products';
-import later from '@breejs/later';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:worker:update-ecb-rates');
-
-let xml2json;
-try {
-  const module = await import('xml-js');
-  xml2json = module.xml2json;
-} catch {
-  logger.warn(`optional peer npm package 'xml-js' not installed, skipped ECB rate updates`);
-}
-
-const getExchangeRates = async (): Promise<{ currency: string; rate: string }[]> => {
-  return fetch(`https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml`, {
-    method: 'GET',
-  })
-    .then((res) => res.text())
-    .then((text) => JSON.parse(xml2json(text)))
-    .then((json) =>
-      json.elements?.[0]?.elements
-        .filter((e) => e.name.toLowerCase() === 'cube')[0]
-        ?.elements[0]?.elements.map((element) => element.attributes),
-    );
-};
-
-// https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/index.en.html
-// CET = UTC + 1
-const everyDayAtFour = later.parse.cron('0 15 * * *');
-
-const baseCurrency = 'EUR';
-
-const UpdateECBRates: IWorkerAdapter<any, any> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker.update-ecb-rates',
-  label: 'Update ECB Rates',
-  version: '1.0.0',
-  type: 'UPDATE_ECB_RATES',
-
-  doWork: async (input, unchainedAPI) => {
-    const { modules } = unchainedAPI;
-
-    if (!xml2json) {
-      return {
-        success: false,
-        error: {
-          name: 'XML2JSON_NOT_INSTALLED',
-          message: 'npm dependency xml2json is not installed, please install it to use this worker',
-        },
-      };
-    }
-
-    try {
-      const data = await getExchangeRates();
-      const timestamp = new Date();
-      const expiresAt = new Date(new Date().getTime() + 24 * 60 * 60 * 1000);
-
-      const currencies = await modules.currencies.findCurrencies({ includeInactive: true });
-      const currencyCodes = currencies.map((currency) => currency.isoCode);
-
-      if (!currencyCodes.includes(baseCurrency))
-        return {
-          success: true,
-          result: {
-            ratesUpdated: 0,
-            info: 'EUR not enabled',
-          },
-        };
-
-      const rates: ProductPriceRate[] = data
-        .map((d) => {
-          return {
-            baseCurrency,
-            quoteCurrency: d.currency,
-            rate: parseFloat(d.rate),
-            timestamp,
-            expiresAt,
-          };
-        })
-        .filter(
-          (rate) =>
-            currencyCodes.includes(rate.quoteCurrency) && rate.quoteCurrency !== rate.baseCurrency,
-        );
-
-      const success = await modules.products.prices.rates.updateRates(rates);
-      return {
-        success,
-        result: {
-          ratesUpdated: rates.length,
-        },
-      };
-    } catch {
-      return {
-        success: false,
-        error: {
-          name: 'UPDATE_ECB_RATES_FAILED',
-          message: 'Updating ECB Rates failed',
-        },
-      };
-    }
-  },
-};
-
-WorkerDirector.registerAdapter(UpdateECBRates);
-
-if (xml2json) {
-  WorkerDirector.configureAutoscheduling({
-    type: UpdateECBRates.type,
-    schedule: everyDayAtFour,
-    retries: 5,
-  });
-}

package/src/worker/update-token-ownership.ts

@@ -1,70 +0,0 @@
-import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-import later from '@breejs/later';
-
-const everyMinute = later.parse.cron('* * * * *');
-
-export const UpdateTokenOwnership: IWorkerAdapter<void, void> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker-plugin.update-token-ownership',
-  label: 'External worker to update ownership of provided tokens',
-  version: '1.0.0',
-  type: 'UPDATE_TOKEN_OWNERSHIP',
-  external: true,
-
-  async doWork() {
-    throw new Error('Cannot do work for external workers');
-  },
-};
-
-export const RefreshTokens: IWorkerAdapter<void, any> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker-plugin.refresh-tokens',
-  label: 'Worker to refresh tokens for accounts',
-  version: '1.0.0',
-  type: 'REFRESH_TOKENS',
-  external: false,
-
-  async doWork(input, unchainedAPI) {
-    const { modules } = unchainedAPI;
-
-    const tokens = await modules.warehousing.findTokens({ walletAddress: { $exists: true } });
-    const users = await modules.users.findUsers({ includeGuests: true, 'services.web3.verified': true });
-    const accounts = users.flatMap((user) => {
-      return user?.services?.web3?.flatMap((service) => {
-        if (service.verified) return [service.address];
-        return [];
-      });
-    });
-
-    tokens.forEach((token) => {
-      accounts.push(token.walletAddress);
-    });
-
-    if (!tokens?.length) {
-      return { success: true, result: {} };
-    }
-
-    const forked = await modules.worker.addWork({
-      type: 'UPDATE_TOKEN_OWNERSHIP',
-      retries: 0,
-      input: {
-        filter: {
-          tokens,
-          accounts: [...new Set(accounts)],
-        },
-      },
-    });
-    return { success: true, result: { forked } };
-  },
-};
-
-WorkerDirector.registerAdapter(RefreshTokens);
-WorkerDirector.registerAdapter(UpdateTokenOwnership);
-
-WorkerDirector.configureAutoscheduling({
-  type: RefreshTokens.type,
-  schedule: everyMinute,
-  retries: 0,
-});

package/src/worker/zombie-killer.ts

@@ -1,139 +0,0 @@
-import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-
-export const ZombieKillerWorker: IWorkerAdapter<
-  { bulkImportMaxAgeInDays: number },
-  {
-    deletedProductMediaCount: number;
-    deletedAssortmentMediaCount: number;
-    deletedFilesCount: number;
-    deletedFilterTextsCount: number;
-    deletedProductTextsCount: number;
-    deletedProductVariationsCount: number;
-    deletedAssortmentTextsCount: number;
-  }
-> = {
-  ...WorkerAdapter,
-
-  key: 'shop.unchained.worker-plugin.zombie-killer',
-  label: 'Zombie Killer',
-  version: '1.0.0',
-  type: 'ZOMBIE_KILLER',
-
-  doWork: async ({ bulkImportMaxAgeInDays } = { bulkImportMaxAgeInDays: 5 }, unchainedAPI) => {
-    const { modules, services } = unchainedAPI;
-
-    try {
-      const error = false;
-
-      // Remove unreferenced filter entities
-      const filters = await modules.filters.findFilters(
-        { includeInactive: true },
-        { projection: { _id: 1 } },
-      );
-      const filterIds = filters.map((a) => a._id);
-      const deletedFilterTextsCount = await modules.filters.texts.deleteMany({
-        excludedFilterIds: filterIds,
-      });
-
-      // Remove unreferenced assortment entities
-      const assortments = await modules.assortments.findAssortments({
-        includeInactive: true,
-        includeLeaves: true,
-      });
-      const assortmentIds = assortments.map((a) => a._id);
-      const deletedAssortmentTextsCount = await modules.assortments.texts.deleteMany({
-        excludedAssortmentIds: assortmentIds,
-      });
-      const deletedAssortmentMediaCount = await modules.assortments.media.deleteMediaFiles({
-        excludedAssortmentIds: assortmentIds,
-      });
-
-      // Remove unreferenced product entities
-      const productIds = await modules.products.findProductIds({ includeDrafts: true });
-      const deletedProductTextsCount = await modules.products.texts.deleteMany({
-        excludedProductIds: productIds,
-      });
-      const deletedProductVariationsCount = await modules.products.variations.deleteVariations({
-        excludedProductIds: productIds,
-      });
-      const deletedProductMediaCount = await modules.products.media.deleteMediaFiles({
-        excludedProductIds: productIds,
-      });
-
-      // Remove unreferenced files
-      const productMedia = await modules.products.media.findProductMedias(
-        {},
-        { projection: { mediaId: 1 } },
-      );
-      const assortmentMedia = await modules.assortments.media.findAssortmentMedias(
-        {},
-        { projection: { mediaId: 1 } },
-      );
-
-      const allFileIdsLinked = [...productMedia, ...assortmentMedia].map((l) => l?.mediaId);
-      const allFileIdsRelevant = (
-        await modules.files.findFiles(
-          { path: { $in: ['product-media', 'assortment-media'] } },
-          { projection: { _id: 1 } },
-        )
-      ).map((a) => a._id);
-
-      const fileIdsToRemove =
-        allFileIdsRelevant.filter((fileId) => {
-          return !allFileIdsLinked.includes(fileId);
-        }) || [];
-
-      // Remove bulk import streams older than X days
-      const bulkImportMedia = await await modules.files.findFiles({
-        path: 'bulk-import-streams',
-        created: { $lt: new Date(Date.now() - 1000 * 60 * 60 * 24 * bulkImportMaxAgeInDays) },
-      });
-      bulkImportMedia.forEach(async (media) => {
-        fileIdsToRemove.push(media._id);
-      });
-
-      const deletedFilesCount =
-        fileIdsToRemove.length > 0
-          ? await services.files.removeFiles({
-              fileIds: fileIdsToRemove,
-            })
-          : 0;
-
-      // Return delete count
-      const result = {
-        deletedFilterTextsCount,
-        deletedProductMediaCount,
-        deletedProductTextsCount,
-        deletedProductVariationsCount,
-        deletedAssortmentMediaCount,
-        deletedAssortmentTextsCount,
-        deletedFilesCount,
-      };
-
-      if (error) {
-        return {
-          success: false,
-          result,
-          error,
-        };
-      }
-      return {
-        success: true,
-        result,
-      };
-    } catch (err) {
-      return {
-        success: false,
-        error: {
-          name: err.name,
-          message: err.message,
-          stack: err.stack,
-        },
-      };
-    }
-  },
-};
-
-export default ZombieKillerWorker;
-
-WorkerDirector.registerAdapter(ZombieKillerWorker);

package/tests/mock/datatrans/v1/secure-fields.json

@@ -1,4 +0,0 @@
-{
-  "location": "https://pay.sandbox.datatrans.com/v1/start/new-transaction-secure-fields",
-  "transactionId": "new-transaction-secure-fields"
-}

package/tests/mock/datatrans/v1/transactions/authorize.json

@@ -1,48 +0,0 @@
-{
-  "transactionId": "payment_alias_authorized",
-  "type": "payment",
-  "status": "authorized",
-  "currency": "CHF",
-  "refno": "MTExMTExMjIyMjI=",
-  "refno2": "user",
-  "paymentMethod": "VIS",
-  "detail": {
-    "authorize": {
-      "amount": 30000,
-      "acquirerAuthorizationCode": "131704"
-    }
-  },
-  "language": "de",
-  "card": {
-    "alias": "70119122433810042",
-    "masked": "424242xxxxxx4242",
-    "expiryMonth": "12",
-    "expiryYear": "21",
-    "info": {
-      "brand": "VISA CREDIT",
-      "type": "credit",
-      "usage": "consumer",
-      "country": "GB",
-      "issuer": "DATATRANS"
-    },
-    "3D": {
-      "authenticationResponse": "D"
-    }
-  },
-  "history": [
-    {
-      "action": "init",
-      "source": "api",
-      "date": "2021-09-03T11:16:50Z",
-      "success": true,
-      "ip": "212.232.234.26"
-    },
-    {
-      "action": "authorize",
-      "source": "redirect",
-      "date": "2021-09-03T11:17:04Z",
-      "success": true,
-      "ip": "212.232.234.26"
-    }
-  ]
-}

package/tests/mock/datatrans/v1/transactions/card_check_authorized.json

@@ -1,47 +0,0 @@
-{
-  "transactionId": "card_check_authorized",
-  "type": "card_check",
-  "status": "authorized",
-  "currency": "CHF",
-  "refno": "ZDRkNGQ0ZDRkNA==",
-  "refno2": "user",
-  "paymentMethod": "VIS",
-  "detail": {
-    "authorize": {
-      "acquirerAuthorizationCode": "131704"
-    }
-  },
-  "language": "de",
-  "card": {
-    "alias": "70119122433810042",
-    "masked": "424242xxxxxx4242",
-    "expiryMonth": "12",
-    "expiryYear": "21",
-    "info": {
-      "brand": "VISA CREDIT",
-      "type": "credit",
-      "usage": "consumer",
-      "country": "GB",
-      "issuer": "DATATRANS"
-    },
-    "3D": {
-      "authenticationResponse": "D"
-    }
-  },
-  "history": [
-    {
-      "action": "init",
-      "source": "api",
-      "date": "2021-09-03T11:16:50Z",
-      "success": true,
-      "ip": "212.232.234.26"
-    },
-    {
-      "action": "authorize",
-      "source": "redirect",
-      "date": "2021-09-03T11:17:04Z",
-      "success": true,
-      "ip": "212.232.234.26"
-    }
-  ]
-}

package/tests/mock/datatrans/v1/transactions/payment_alias_authorized/settle.json

@@ -1 +0,0 @@
-{}