@unchainedshop/plugins 4.6.0 → 4.6.2

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

@@ -0,0 +1,94 @@
+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';
+export 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',
+                },
+            };
+        }
+    },
+};
+export default UpdateECBRates;
+export const configureUpdateECBRatesAutoscheduling = () => {
+    if (xml2json) {
+        WorkerDirector.configureAutoscheduling({
+            type: UpdateECBRates.type,
+            schedule: everyDayAtFour,
+            retries: 5,
+        });
+    }
+};

package/lib/worker/update-ecb-rates/index.d.ts

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const UpdateECBRatesPlugin: IPlugin;
+export default UpdateECBRatesPlugin;
+export { UpdateECBRates, configureUpdateECBRatesAutoscheduling } from './adapter.ts';

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

@@ -0,0 +1,13 @@
+import {} from '@unchainedshop/core';
+import { UpdateECBRates, configureUpdateECBRatesAutoscheduling } from "./adapter.js";
+export const UpdateECBRatesPlugin = {
+    key: 'shop.unchained.worker.update-ecb-rates',
+    label: 'Update ECB Rates Worker Plugin',
+    version: '1.0.0',
+    adapters: [UpdateECBRates],
+    onRegister: () => {
+        configureUpdateECBRatesAutoscheduling();
+    },
+};
+export default UpdateECBRatesPlugin;
+export { UpdateECBRates, configureUpdateECBRatesAutoscheduling } from "./adapter.js";

package/lib/worker/update-token-ownership/adapter.d.ts

@@ -0,0 +1,5 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const UpdateTokenOwnership: IWorkerAdapter<void, void>;
+export declare const RefreshTokens: IWorkerAdapter<void, any>;
+export default UpdateTokenOwnership;
+export declare const configureRefreshTokensAutoscheduling: () => void;

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

@@ -0,0 +1,58 @@
+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 } };
+    },
+};
+export default UpdateTokenOwnership;
+export const configureRefreshTokensAutoscheduling = () => {
+    WorkerDirector.configureAutoscheduling({
+        type: RefreshTokens.type,
+        schedule: everyMinute,
+        retries: 0,
+    });
+};

package/lib/worker/update-token-ownership/index.d.ts

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const UpdateTokenOwnershipPlugin: IPlugin;
+export default UpdateTokenOwnershipPlugin;
+export { UpdateTokenOwnership, RefreshTokens, configureRefreshTokensAutoscheduling } from './adapter.ts';

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

@@ -0,0 +1,13 @@
+import {} from '@unchainedshop/core';
+import { UpdateTokenOwnership, RefreshTokens, configureRefreshTokensAutoscheduling } from "./adapter.js";
+export const UpdateTokenOwnershipPlugin = {
+    key: 'shop.unchained.worker.update-token-ownership',
+    label: 'Update Token Ownership Worker Plugin',
+    version: '1.0.0',
+    adapters: [UpdateTokenOwnership, RefreshTokens],
+    onRegister: () => {
+        configureRefreshTokensAutoscheduling();
+    },
+};
+export default UpdateTokenOwnershipPlugin;
+export { UpdateTokenOwnership, RefreshTokens, configureRefreshTokensAutoscheduling } from "./adapter.js";

package/lib/worker/zombie-killer/adapter.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/adapter.js

@@ -0,0 +1,90 @@
+import { WorkerAdapter } 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;

package/lib/worker/zombie-killer/index.d.ts

@@ -0,0 +1,4 @@
+import { type IPlugin } from '@unchainedshop/core';
+export declare const ZombieKillerPlugin: IPlugin;
+export default ZombieKillerPlugin;
+export { ZombieKillerWorker } from './adapter.ts';

package/lib/worker/zombie-killer/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { ZombieKillerWorker } from "./adapter.js";
+export const ZombieKillerPlugin = {
+    key: 'shop.unchained.worker-plugin.zombie-killer',
+    label: 'Zombie Killer Worker Plugin',
+    version: '1.0.0',
+    adapters: [ZombieKillerWorker],
+};
+export default ZombieKillerPlugin;
+export { ZombieKillerWorker } from "./adapter.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/plugins",
   "description": "Official plugin collection for the Unchained Engine with payment, delivery, and pricing adapters",
-  "version": "4.6.0",
+  "version": "4.6.2",
   "main": "lib/plugins-index.js",
   "types": "lib/plugins-index.d.ts",
   "exports": {