@unchainedshop/plugins 4.7.2 → 4.8.0

package/lib/worker/push-notification.js

@@ -0,0 +1,87 @@
+import { 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;
+const PushNotificationWorkerPlugin = {
+    ...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 = {
+            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/lib/worker/twilio.d.ts

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

package/lib/worker/twilio.js

@@ -0,0 +1,59 @@
+import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
+const { TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_SMS_FROM } = process.env;
+const SmsWorkerPlugin = {
+    ...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,
+                }),
+            });
+            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/lib/worker/update-coinbase-rates.d.ts

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

package/lib/worker/update-coinbase-rates.js

@@ -0,0 +1,59 @@
+import { WorkerAdapter, WorkerDirector, schedule } from '@unchainedshop/core';
+import { resolveBestCurrency } from '@unchainedshop/utils';
+const getExchangeRates = async (base) => {
+    return fetch(`https://api.coinbase.com/v2/exchange-rates?currency=${base}`, {
+        method: 'GET',
+    })
+        .then((res) => res.json())
+        .then((r) => r?.data);
+};
+const everyMinute = schedule.parse.cron('* * * * *');
+const UpdateCoinbaseRates = {
+    ...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);
+            const currencyCodes = currencies.map((currency) => currency.isoCode);
+            const { currency: baseCurrency, rates: pairs } = await getExchangeRates(currencyCode);
+            const timestamp = new Date();
+            const expiresAt = new Date(new Date().getTime() + 5 * 60 * 1000);
+            const rates = 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/lib/worker/update-ecb-rates.d.ts

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

package/lib/worker/update-ecb-rates.js

@@ -0,0 +1,92 @@
+import { WorkerAdapter, WorkerDirector, schedule } from '@unchainedshop/core';
+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 () => {
+    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));
+};
+const everyDayAtFour = schedule.parse.cron('0 15 * * *');
+const baseCurrency = 'EUR';
+const UpdateECBRates = {
+    ...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 = 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/lib/worker/update-token-ownership.d.ts

@@ -0,0 +1,3 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const UpdateTokenOwnership: IWorkerAdapter<void, void>;
+export declare const RefreshTokens: IWorkerAdapter<void, any>;

package/lib/worker/update-token-ownership.js

@@ -0,0 +1,57 @@
+import { WorkerAdapter, WorkerDirector, schedule } from '@unchainedshop/core';
+const everyMinute = schedule.parse.cron('* * * * *');
+export const UpdateTokenOwnership = {
+    ...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 = {
+    ...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({ walletAddressExists: true });
+        const users = await modules.users.findUsers({ includeGuests: true, web3Verified: 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/lib/worker/zombie-killer.d.ts

@@ -0,0 +1,13 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const ZombieKillerWorker: IWorkerAdapter<{
+    bulkImportMaxAgeInDays: number;
+}, {
+    deletedProductMediaCount: number;
+    deletedAssortmentMediaCount: number;
+    deletedFilesCount: number;
+    deletedFilterTextsCount: number;
+    deletedProductTextsCount: number;
+    deletedProductVariationsCount: number;
+    deletedAssortmentTextsCount: number;
+}>;
+export default ZombieKillerWorker;

package/lib/worker/zombie-killer.js

@@ -0,0 +1,91 @@
+import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
+export const ZombieKillerWorker = {
+    ...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;
+            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,
+            });
+            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,
+            });
+            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,
+            });
+            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({ paths: ['product-media', 'assortment-media'] }, { projection: { _id: 1 } })).map((a) => a._id);
+            const fileIdsToRemove = allFileIdsRelevant.filter((fileId) => {
+                return !allFileIdsLinked.includes(fileId);
+            }) || [];
+            const bulkImportMedia = await await modules.files.findFiles({
+                path: 'bulk-import-streams',
+                createdBefore: 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;
+            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/package.json

@@ -1,22 +1,11 @@
 {
   "name": "@unchainedshop/plugins",
   "description": "Official plugin collection for the Unchained Engine with payment, delivery, and pricing adapters",
-  "version": "4.7.2",
+  "version": "4.8.0",
   "main": "lib/plugins-index.js",
   "types": "lib/plugins-index.d.ts",
   "exports": {
-    "./presets/*": "./lib/presets/*.js",
-    "./presets/countries/*": "./lib/presets/countries/*.js",
-    "./events/*": "./lib/events/*.js",
-    "./enrollments/*": "./lib/enrollments/*/index.js",
-    "./quotations/*": "./lib/quotations/*/index.js",
-    "./filters/*": "./lib/filters/*/index.js",
-    "./delivery/*": "./lib/delivery/*/index.js",
-    "./warehousing/*": "./lib/warehousing/*/index.js",
-    "./payment/*": "./lib/payment/*/index.js",
-    "./files/*": "./lib/files/*/index.js",
-    "./pricing/*": "./lib/pricing/*/index.js",
-    "./worker/*": "./lib/worker/*/index.js"
+    "./*": "./lib/*"
   },
   "type": "module",
   "scripts": {
@@ -57,11 +46,13 @@
     "@unchainedshop/core-warehousing": "^4.6.0",
     "@unchainedshop/core-worker": "^4.6.0",
     "@unchainedshop/events": "^4.6.0",
+    "@unchainedshop/file-upload": "^4.6.0",
     "@unchainedshop/logger": "^4.6.0",
     "@unchainedshop/utils": "^4.6.0"
   },
   "peerDependencies": {
     "@aws-sdk/client-eventbridge": ">= 3.714 < 4",
+    "@paypal/checkout-server-sdk": "1.x",
     "@redis/client": ">= 1 < 6",
     "@scure/bip32": ">= 2",
     "@scure/btc-signer": ">= 2",
@@ -70,7 +61,7 @@
     "express": ">= 5 < 6",
     "fastify": ">= 5.2 < 6",
     "minio": "8.x",
-    "nodemailer": ">= 6.9 < 9",
+    "nodemailer": ">= 6.9 < 8",
     "p-memoize": "8.x",
     "stripe": ">= 19 < 21",
     "web-push": ">= 3.6 <4",
@@ -80,6 +71,9 @@
     "@aws-sdk/client-eventbridge": {
       "optional": true
     },
+    "@paypal/checkout-server-sdk": {
+      "optional": true
+    },
     "@redis/client": {
       "optional": true
     },
@@ -118,6 +112,7 @@
     }
   },
   "devDependencies": {
+    "@paypal/checkout-server-sdk": "^1.0.3",
     "@redis/client": "^5.6.0",
     "@scure/bip32": "^2.0.0",
     "@scure/btc-signer": "^2.0.0",
@@ -127,7 +122,7 @@
     "express": "^5.1.0",
     "fastify": "^5.4.0",
     "minio": "^8.0.5",
-    "nodemailer": "^8.0.1",
+    "nodemailer": "^7.0.5",
     "p-memoize": "^8.0.0",
     "stripe": "^20.0.0",
     "typescript": "^5.8.3",