@unchainedshop/plugins 4.6.0 → 4.6.2

package/lib/worker/export-token/adapter.js

@@ -0,0 +1,25 @@
+import { WorkerEventTypes } from '@unchainedshop/core-worker';
+import { WorkerAdapter } 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 ExportTokenWorker;

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

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

package/lib/worker/export-token/index.js

@@ -0,0 +1,13 @@
+import {} from '@unchainedshop/core';
+import { ExportTokenWorker, configureExportToken } from "./adapter.js";
+export const ExportTokenPlugin = {
+    key: 'shop.unchained.worker.export-token',
+    label: 'Export Token Worker Plugin',
+    version: '1.0.0',
+    adapters: [ExportTokenWorker],
+    onRegister: (unchainedAPI) => {
+        configureExportToken(unchainedAPI);
+    },
+};
+export default ExportTokenPlugin;
+export { ExportTokenWorker, configureExportToken } from "./adapter.js";

package/lib/worker/external/adapter.d.ts

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

package/lib/worker/external/adapter.js

@@ -0,0 +1,13 @@
+import { WorkerAdapter } 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');
+    },
+};
+export default ExternalWorkerPlugin;

package/lib/worker/external/index.d.ts

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

package/lib/worker/external/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { ExternalWorkerPlugin as ExternalWorker } from "./adapter.js";
+export const ExternalPlugin = {
+    key: 'shop.unchained.worker-plugin.external',
+    label: 'External Worker Plugin',
+    version: '1.0.0',
+    adapters: [ExternalWorker],
+};
+export default ExternalPlugin;
+export { ExternalWorkerPlugin } from "./adapter.js";

package/lib/worker/heartbeat/adapter.d.ts

@@ -0,0 +1,8 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+interface Arg {
+    wait?: number;
+    fails?: boolean;
+}
+type Result = Arg;
+export declare const Heartbeat: IWorkerAdapter<Arg, Result>;
+export default Heartbeat;

package/lib/worker/heartbeat/adapter.js

@@ -0,0 +1,26 @@
+import { WorkerAdapter } from '@unchainedshop/core';
+import { setTimeout } from 'node:timers/promises';
+export 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,
+        };
+    },
+};
+export default Heartbeat;

package/lib/worker/heartbeat/index.d.ts

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

package/lib/worker/heartbeat/index.js

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

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

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

package/lib/worker/http-request/adapter.js

@@ -0,0 +1,55 @@
+import { WorkerAdapter } 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,
+    });
+};
+export 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,
+                },
+            };
+        }
+    },
+};
+export default HttpRequestWorkerPlugin;

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

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

package/lib/worker/http-request/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { HttpRequestWorkerPlugin as HttpRequestWorker } from "./adapter.js";
+export const HttpRequestPlugin = {
+    key: 'shop.unchained.worker-plugin.http-request',
+    label: 'HTTP Request Worker Plugin',
+    version: '1.0.0',
+    adapters: [HttpRequestWorker],
+};
+export default HttpRequestPlugin;
+export { HttpRequestWorkerPlugin } from "./adapter.js";

package/lib/worker/message/adapter.d.ts

@@ -0,0 +1,11 @@
+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[];
+}>;
+export default MessageWorker;

package/lib/worker/message/adapter.js

@@ -0,0 +1,42 @@
+import { MessagingDirector, WorkerAdapter } 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,
+                },
+            };
+        }
+    },
+};
+export default MessageWorker;

package/lib/worker/message/index.d.ts

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

package/lib/worker/message/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { MessageWorker } from "./adapter.js";
+export const MessagePlugin = {
+    key: 'shop.unchained.worker-plugin.message',
+    label: 'Message Worker Plugin',
+    version: '1.0.0',
+    adapters: [MessageWorker],
+};
+export default MessagePlugin;
+export * from "./adapter.js";

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

@@ -0,0 +1,9 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const PushNotificationWorkerPlugin: IWorkerAdapter<{
+    subscription: any;
+    payload: string;
+    subject: string;
+    urgency?: 'very-low' | 'low' | 'normal' | 'high';
+    topic?: string;
+}, any>;
+export default PushNotificationWorkerPlugin;

package/lib/worker/push-notification/adapter.js

@@ -0,0 +1,87 @@
+import { WorkerAdapter } 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;
+export 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,
+                },
+            };
+        }
+    },
+};
+export default PushNotificationWorkerPlugin;

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

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

package/lib/worker/push-notification/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { PushNotificationWorkerPlugin as PushNotificationWorker } from "./adapter.js";
+export const PushNotificationPlugin = {
+    key: 'shop.unchained.worker-plugin.push-notification',
+    label: 'Push Notification Worker Plugin',
+    version: '1.0.0',
+    adapters: [PushNotificationWorker],
+};
+export default PushNotificationPlugin;
+export { PushNotificationWorkerPlugin } from "./adapter.js";

package/lib/worker/twilio/adapter.d.ts

@@ -0,0 +1,8 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const SmsWorkerPlugin: IWorkerAdapter<{
+    from?: string;
+    to: string;
+    text: string;
+    [key: string]: any;
+}, any>;
+export default SmsWorkerPlugin;

package/lib/worker/twilio/adapter.js

@@ -0,0 +1,59 @@
+import { WorkerAdapter } from '@unchainedshop/core';
+const { TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_SMS_FROM } = process.env;
+export 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,
+                },
+            };
+        }
+    },
+};
+export default SmsWorkerPlugin;

package/lib/worker/twilio/index.d.ts

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

package/lib/worker/twilio/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { SmsWorkerPlugin as TwilioWorker } from "./adapter.js";
+export const TwilioPlugin = {
+    key: 'shop.unchained.worker-plugin.twilio',
+    label: 'Twilio SMS Worker Plugin',
+    version: '1.0.0',
+    adapters: [TwilioWorker],
+};
+export default TwilioPlugin;
+export { SmsWorkerPlugin } from "./adapter.js";

package/lib/worker/update-coinbase-rates/adapter.d.ts

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

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

@@ -0,0 +1,61 @@
+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('* * * * *');
+export 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',
+                },
+            };
+        }
+    },
+};
+export default UpdateCoinbaseRates;
+export const configureUpdateCoinbaseRatesAutoscheduling = () => {
+    WorkerDirector.configureAutoscheduling({
+        type: UpdateCoinbaseRates.type,
+        schedule: everyMinute,
+    });
+};

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

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

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

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

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

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