@unchainedshop/plugins 4.6.2 → 4.7.2

package/lib/worker/error-notifications.js

@@ -1,61 +0,0 @@
-import { WorkStatus } from '@unchainedshop/core-worker';
-import { WorkerDirector, WorkerAdapter, schedule } from '@unchainedshop/core';
-const everyDayAtFourInTheNight = schedule.parse.cron('0 3 * * *');
-export const ErrorNotifications = {
-    ...WorkerAdapter,
-    key: 'shop.unchained.worker.error-notifications',
-    label: 'Send a daily report about errors that failed permanently/unrecoverable',
-    version: '1.0',
-    type: 'ERROR_NOTIFICATIONS',
-    doWork: async (args, context, workId) => {
-        const work = (await context.modules.worker.findWork({ workId }));
-        const secondsPassed = args?.secondsPassed || 60;
-        const to = new Date();
-        const from = new Date(new Date(work.scheduled).getTime() - secondsPassed * 1000);
-        try {
-            const workItems = (await context.modules.worker.findWorkQueue({
-                scheduled: {
-                    end: to,
-                    start: from,
-                },
-                types: undefined,
-                status: [WorkStatus.FAILED],
-            })).filter((workItem) => workItem.type !== ErrorNotifications.type && workItem.retries === 0);
-            if (!workItems.length) {
-                return { success: true, result: {} };
-            }
-            const message = await context.modules.worker.addWork({
-                type: 'MESSAGE',
-                retries: 0,
-                input: {
-                    workItems,
-                    template: 'ERROR_REPORT',
-                },
-                originalWorkId: workId,
-            });
-            return {
-                success: true,
-                result: { forked: message._id },
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: {
-                    name: err.name,
-                    message: err.message,
-                    stack: err.stack,
-                },
-            };
-        }
-    },
-};
-WorkerDirector.registerAdapter(ErrorNotifications);
-export default ErrorNotifications;
-const ONE_DAY_IN_SECONDS = 24 * 60 * 60;
-WorkerDirector.configureAutoscheduling({
-    type: ErrorNotifications.type,
-    schedule: everyDayAtFourInTheNight,
-    input: async () => ({ secondsPassed: ONE_DAY_IN_SECONDS }),
-    retries: 0,
-});

package/lib/worker/export-token.d.ts

@@ -1,4 +0,0 @@
-import { type IWorkerAdapter, type UnchainedCore } from '@unchainedshop/core';
-export declare const ExportTokenWorker: IWorkerAdapter<void, void>;
-export declare const configureExportToken: (unchainedAPI: UnchainedCore) => void;
-export default configureExportToken;

package/lib/worker/export-token.js

@@ -1,26 +0,0 @@
-import { WorkerEventTypes } from '@unchainedshop/core-worker';
-import { WorkerAdapter, WorkerDirector, } from '@unchainedshop/core';
-import { subscribe } from '@unchainedshop/events';
-export const ExportTokenWorker = {
-    ...WorkerAdapter,
-    key: 'shop.unchained.worker-plugin.export-token',
-    label: 'External worker to hold the state of the minting/export process of tokens',
-    version: '1.0.0',
-    type: 'EXPORT_TOKEN',
-    external: true,
-    async doWork() {
-        throw new Error('Cannot do work for external workers');
-    },
-};
-export const configureExportToken = (unchainedAPI) => {
-    subscribe(WorkerEventTypes.FINISHED, async ({ payload: work }) => {
-        if (work.type === 'EXPORT_TOKEN' && work.success) {
-            await unchainedAPI.modules.warehousing.updateTokenOwnership({
-                tokenId: work.input.token._id,
-                walletAddress: work.input.recipientWalletAddress,
-            });
-        }
-    });
-};
-export default configureExportToken;
-WorkerDirector.registerAdapter(ExportTokenWorker);

package/lib/worker/external.d.ts

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

package/lib/worker/external.js

@@ -1,13 +0,0 @@
-import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-export const ExternalWorkerPlugin = {
-    ...WorkerAdapter,
-    key: 'shop.unchained.worker-plugin.external',
-    label: 'External plugin as a placeholder for workers who interact with the system only via GraphQL',
-    version: '1.0.0',
-    type: 'EXTERNAL',
-    external: true,
-    async doWork() {
-        throw new Error('Cannot do work for external workers');
-    },
-};
-WorkerDirector.registerAdapter(ExternalWorkerPlugin);

package/lib/worker/heartbeat.d.ts

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

package/lib/worker/heartbeat.js

@@ -1,26 +0,0 @@
-import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-import { setTimeout } from 'node:timers/promises';
-const Heartbeat = {
-    ...WorkerAdapter,
-    key: 'shop.unchained.worker-plugin.heartbeat',
-    label: 'Heartbeat plugin to check if workers are working',
-    version: '1.0.0',
-    type: 'HEARTBEAT',
-    maxParallelAllocations: 1,
-    doWork: async (input) => {
-        if (input?.wait) {
-            await setTimeout(input.wait);
-        }
-        if (input?.fails) {
-            return {
-                success: false,
-                result: input,
-            };
-        }
-        return {
-            success: true,
-            result: input,
-        };
-    },
-};
-WorkerDirector.registerAdapter(Heartbeat);

package/lib/worker/http-request.d.ts

@@ -1,8 +0,0 @@
-import { type IWorkerAdapter } from '@unchainedshop/core';
-declare const HttpRequestWorkerPlugin: IWorkerAdapter<{
-    url?: string;
-    data?: any;
-    headers?: any;
-    method: 'POST' | 'GET';
-}, any>;
-export default HttpRequestWorkerPlugin;

package/lib/worker/http-request.js

@@ -1,56 +0,0 @@
-import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-const postFetch = async (url, { data, headers }) => {
-    return fetch(url, {
-        method: 'POST',
-        body: JSON.stringify(data),
-        duplex: 'half',
-        headers: { 'Content-Type': 'application/json', ...headers },
-    });
-};
-const nonPostFetch = async (url, { headers, method = 'GET' }) => {
-    return fetch(url, {
-        method,
-        headers,
-    });
-};
-const HttpRequestWorkerPlugin = {
-    ...WorkerAdapter,
-    key: 'shop.unchained.worker-plugin.http-request',
-    label: 'Request a resource via http request. 200 = success',
-    version: '1.0.0',
-    type: 'HTTP_REQUEST',
-    async doWork({ url, data = {}, headers, method = 'POST' } = { method: 'POST' }) {
-        if (!url) {
-            return {
-                success: false,
-                error: {
-                    name: 'URL_REQUIRED',
-                    message: 'HTTP_REQUEST requires an url',
-                },
-            };
-        }
-        try {
-            const normalizedFetch = method.toUpperCase() === 'POST' ? postFetch : nonPostFetch;
-            const res = await normalizedFetch(url, { data, headers, method });
-            const contentType = res.headers.get('content-type');
-            const isJson = contentType && contentType.includes('application/json');
-            const result = isJson ? await res.json() : { text: await res.text() };
-            if (res.status === 200 && res.ok) {
-                return { success: true, result };
-            }
-            return { success: false, result };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: {
-                    name: err.name,
-                    message: err.message,
-                    stack: err.stack,
-                },
-            };
-        }
-    },
-};
-WorkerDirector.registerAdapter(HttpRequestWorkerPlugin);
-export default HttpRequestWorkerPlugin;

package/lib/worker/message.d.ts

@@ -1,10 +0,0 @@
-import { type IWorkerAdapter } from '@unchainedshop/core';
-import type { Work } from '@unchainedshop/core-worker';
-export declare const MessageWorker: IWorkerAdapter<{
-    template: string;
-    _id: string;
-    [x: string]: any;
-}, {
-    info?: string;
-    forked?: Work[];
-}>;

package/lib/worker/message.js

@@ -1,42 +0,0 @@
-import { MessagingDirector, WorkerAdapter, WorkerDirector, } from '@unchainedshop/core';
-export const MessageWorker = {
-    ...WorkerAdapter,
-    key: 'shop.unchained.worker-plugin.message',
-    label: 'Send Message by combining payload with a template and start concrete jobs',
-    version: '1.0.0',
-    type: 'MESSAGE',
-    doWork: async ({ template, ...payload }, unchainedAPI, workId) => {
-        try {
-            const templateResolver = MessagingDirector.getTemplate(template);
-            if (!templateResolver)
-                throw new Error(`No template resolver found for template ${template}`);
-            const workConfigurations = await templateResolver({
-                template,
-                ...payload,
-            }, unchainedAPI);
-            if (workConfigurations.length > 0) {
-                const forked = await Promise.all(workConfigurations.map(async (workConfiguration) => {
-                    const work = await unchainedAPI.modules.worker.addWork({
-                        ...workConfiguration,
-                        originalWorkId: workId,
-                    });
-                    delete work.input;
-                    return work;
-                }));
-                return { success: true, result: { forked } };
-            }
-            return { success: true, result: { forked: [] } };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: {
-                    name: err.name,
-                    message: err.message,
-                    stack: err.stack,
-                },
-            };
-        }
-    },
-};
-WorkerDirector.registerAdapter(MessageWorker);

package/lib/worker/push-notification.d.ts

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

package/lib/worker/push-notification.js

@@ -1,87 +0,0 @@
-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

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

package/lib/worker/twilio.js

@@ -1,59 +0,0 @@
-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

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

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

@@ -1,59 +0,0 @@
-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

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

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

@@ -1,92 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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;