@unchainedshop/plugins 4.7.2 → 4.8.1

package/lib/worker/bulk-import.js

@@ -0,0 +1,65 @@
+import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core';
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:bulk-import');
+export const BulkImportWorker = {
+    ...WorkerAdapter,
+    key: 'shop.unchained.worker-plugin.bulk-import',
+    label: 'Bulk Import',
+    version: '1.0.0',
+    type: 'BULK_IMPORT',
+    maxParallelAllocations: 1,
+    doWork: async (rawPayload, unchainedAPI) => {
+        try {
+            const { createShouldUpsertIfIDExists = false, skipCacheInvalidation = false, updateShouldUpsertIfIDNotExists = false, } = rawPayload;
+            const bulkImporter = unchainedAPI.bulkImporter.createBulkImporter({
+                createShouldUpsertIfIDExists,
+                updateShouldUpsertIfIDNotExists,
+                skipCacheInvalidation,
+            });
+            if (rawPayload.payloadId) {
+                const readStream = await unchainedAPI.services.files.createDownloadStream({
+                    fileId: rawPayload.payloadId,
+                });
+                if (!readStream) {
+                    throw new Error('Could not create download stream from uploaded file');
+                }
+                await unchainedAPI.bulkImporter.pipeEventStream(readStream, bulkImporter, unchainedAPI);
+            }
+            else {
+                const { events } = rawPayload;
+                if (!events?.length)
+                    throw new Error('No events submitted');
+                await events.reduce(async (currentEventPromise, nextEvent) => {
+                    await currentEventPromise;
+                    await bulkImporter.validate(nextEvent);
+                    return bulkImporter.prepare(nextEvent, unchainedAPI);
+                }, Promise.resolve());
+            }
+            const [result, error] = await bulkImporter.execute();
+            await bulkImporter.invalidateCaches(unchainedAPI);
+            if (error) {
+                return {
+                    success: false,
+                    result: result,
+                    error,
+                };
+            }
+            return {
+                success: true,
+                result: result,
+            };
+        }
+        catch (err) {
+            logger.error(err);
+            return {
+                success: false,
+                error: {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack,
+                },
+            };
+        }
+    },
+};
+WorkerDirector.registerAdapter(BulkImportWorker);

package/lib/worker/bulkgate.d.ts

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

package/lib/worker/bulkgate.js

@@ -0,0 +1,91 @@
+import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
+const { BULKGATE_APPLICATION_ID, BULKGATE_APPLICATION_TOKEN } = process.env;
+const BulkGateWorker = {
+    ...WorkerAdapter,
+    key: 'shop.unchained.worker-plugin.bulkgate',
+    label: 'Send SMS through BulkGate',
+    version: '1.0.0',
+    type: 'BULKGATE',
+    doWork: async ({ from, to, text, unicode = false, country, schedule, promotional = false, ...params }) => {
+        try {
+            const url = promotional
+                ? 'https://portal.bulkgate.com/api/1.0/simple/promotional'
+                : 'https://portal.bulkgate.com/api/1.0/simple/transactional';
+            const requestBody = {
+                application_id: BULKGATE_APPLICATION_ID,
+                application_token: BULKGATE_APPLICATION_TOKEN,
+                number: to,
+                text: text || '',
+                unicode: unicode,
+                sender_id: from ? 'gText' : 'gSystem',
+                sender_id_value: from || '',
+                ...(country && { country }),
+                ...(schedule && { schedule }),
+                ...params,
+            };
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Cache-Control': 'no-cache',
+                },
+                body: JSON.stringify(requestBody),
+            });
+            const responseData = await response.json();
+            if (responseData.error || responseData.type) {
+                return {
+                    success: false,
+                    error: {
+                        name: 'BULKGATE_ERROR',
+                        message: responseData.error ||
+                            `Failed to send ${promotional ? 'promotional' : 'transactional'} SMS`,
+                        type: responseData.type || null,
+                        code: responseData.code || response.status,
+                        detail: responseData.detail || null,
+                    },
+                };
+            }
+            if (responseData.data) {
+                if (!promotional && responseData.data.status === 'accepted') {
+                    return {
+                        success: true,
+                        result: {
+                            sms_id: responseData.data.sms_id,
+                            price: responseData.data.price,
+                            credit: responseData.data.credit,
+                            number: responseData.data.number,
+                            status: responseData.data.status,
+                        },
+                        error: null,
+                    };
+                }
+                if (promotional || responseData.data.status) {
+                    return {
+                        success: true,
+                        result: responseData.data,
+                        error: null,
+                    };
+                }
+            }
+            return {
+                success: false,
+                error: {
+                    name: 'BULKGATE_ERROR',
+                    message: 'Unexpected response format from BulkGate API',
+                    response: responseData,
+                },
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack,
+                },
+            };
+        }
+    },
+};
+WorkerDirector.registerAdapter(BulkGateWorker);

package/lib/worker/email.d.ts

@@ -0,0 +1 @@
+export declare const checkEmailInterceptionEnabled: () => boolean;

package/lib/worker/email.js

@@ -0,0 +1,136 @@
+import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core';
+import { spawn } from 'node:child_process';
+import { writeFile, mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:worker:email');
+export const checkEmailInterceptionEnabled = () => {
+    return process.env.NODE_ENV !== 'production' && !process.env.UNCHAINED_DISABLE_EMAIL_INTERCEPTION;
+};
+const buildLink = async ({ filename, content, href, contentType, encoding, path }) => {
+    if (path) {
+        return `<a href="file:/${path.startsWith('/') ? path : `${process.cwd()}/${path}`}">${filename}</a>`;
+    }
+    if (href) {
+        return `<a href="${href}">${filename}</a>`;
+    }
+    if (content && encoding === 'base64') {
+        return `<a target="_blank" href="${`data:${contentType};base64,${content}`}">${filename}</a>`;
+    }
+    return '';
+};
+let nodemailer;
+try {
+    const nodemailerModule = await import('nodemailer');
+    nodemailer = nodemailerModule.default;
+}
+catch {
+    logger.warn(`optional peer npm package 'nodemailer' not installed, emails can't be sent`);
+}
+const openInBrowser = async (options) => {
+    const command = {
+        darwin: 'open',
+        win32: 'explorer.exe',
+        linux: 'xdg-open',
+    }[process.platform];
+    if (!command) {
+        return false;
+    }
+    const messageBody = options.html || options.text.replace(/(\r\n|\n|\r)/gm, '<br/>');
+    const attachmentLinks = await Promise.all((options.attachments || []).map(buildLink));
+    const content = `
+<!DOCTYPE html>
+<html lang="en" xmlns="https://www.w3.org/1999/xhtml" xmlns:o="urn:schemas-microsoft-com:office:office">
+  <head>
+    <meta charset="UTF-8"/>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+  </head>
+  <body>
+    <b>From:&nbsp</b>${options.from}<br/>
+    <b>To:&nbsp;</b>${options.to}<br/>
+    <b>Cc:&nbsp;</b>${options.cc}<br/>
+    <b>Bcc:&nbsp;</b>${options.bcc}<br/>
+    <b>Reply-To:&nbsp;</b>${options.replyTo}<br/>
+    <br/>
+    <b>subject:&nbsp;</b>${options.subject}<br/>
+    <b>attachments:&nbsp;</b>${attachmentLinks.join(',&nbsp;')}<br/>
+    <hr/>
+    ${messageBody}
+  </body>
+</html>`;
+    const tempDir = await mkdtemp(join(tmpdir(), 'unchained-email-'));
+    const tempFile = join(tempDir, 'email-preview.html');
+    await writeFile(tempFile, content, 'utf8');
+    return new Promise((resolve) => {
+        const child = spawn(command, [tempFile], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+        resolve(true);
+    });
+};
+const EmailWorkerPlugin = {
+    ...WorkerAdapter,
+    key: 'shop.unchained.worker-plugin.email',
+    label: 'Send a Mail through Nodemailer',
+    version: '1.0.0',
+    type: 'EMAIL',
+    doWork: async ({ from, to, subject, ...rest }) => {
+        if (!to) {
+            return {
+                success: false,
+                error: {
+                    name: 'RECIPIENT_REQUIRED',
+                    message: 'EMAIL requires a to',
+                },
+            };
+        }
+        try {
+            const sendMailOptions = {
+                from,
+                to,
+                subject,
+                ...rest,
+            };
+            if (checkEmailInterceptionEnabled()) {
+                const opened = await openInBrowser(sendMailOptions);
+                return {
+                    success: opened,
+                    result: opened ? { intercepted: true } : undefined,
+                    error: !opened ? { message: "Interception failed due to missing package 'open'" } : undefined,
+                };
+            }
+            if (!process.env.MAIL_URL) {
+                return {
+                    success: false,
+                    error: { name: 'NO_MAIL_URL_SET', message: 'MAIL_URL is not set' },
+                };
+            }
+            if (!nodemailer) {
+                return {
+                    success: false,
+                    error: {
+                        name: 'NODEMAILER_NOT_INSTALLED',
+                        message: 'npm dependency nodemailer is not installed, please install it to use email features',
+                    },
+                };
+            }
+            const transporter = nodemailer.createTransport(process.env.MAIL_URL);
+            const result = await transporter.sendMail(sendMailOptions);
+            return { success: true, result };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack,
+                },
+            };
+        }
+    },
+};
+WorkerDirector.registerAdapter(EmailWorkerPlugin);

package/lib/worker/enrollment-order-generator.d.ts

@@ -0,0 +1 @@
+export declare const configureGenerateOrderAutoscheduling: () => void;

package/lib/worker/enrollment-order-generator.js

@@ -0,0 +1,77 @@
+import { enrollmentsSettings, EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { EnrollmentDirector, WorkerDirector, WorkerAdapter, } from '@unchainedshop/core';
+const GenerateOrderWorker = {
+    ...WorkerAdapter,
+    key: 'shop.unchained.worker-plugin.generate-enrollment-orders',
+    label: 'Generates new Orders from Enrollments',
+    version: '1.0.0',
+    type: 'ENROLLMENT_ORDER_GENERATOR',
+    doWork: async (input, unchainedAPI) => {
+        const { modules, services } = unchainedAPI;
+        const enrollments = await modules.enrollments.findEnrollments({
+            status: [EnrollmentStatus.ACTIVE, EnrollmentStatus.PAUSED],
+        });
+        const errors = (await Promise.all(enrollments.map(async (enrollment) => {
+            try {
+                const product = await unchainedAPI.modules.products.findProduct({
+                    productId: enrollment.productId,
+                });
+                const director = await EnrollmentDirector.actions({ enrollment, product: product }, unchainedAPI);
+                const period = await director.nextPeriod();
+                if (period) {
+                    if (period.isTrial) {
+                        await modules.enrollments.addEnrollmentPeriod(enrollment._id, {
+                            ...period,
+                        });
+                        return null;
+                    }
+                    const configuration = await director.configurationForOrder({
+                        period,
+                    });
+                    if (configuration) {
+                        const order = await services.enrollments.generateOrderFromEnrollment(enrollment, configuration);
+                        if (order) {
+                            await modules.enrollments.addEnrollmentPeriod(enrollment._id, {
+                                ...period,
+                                orderId: order._id,
+                            });
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                return {
+                    name: e.name,
+                    message: e.message,
+                    stack: e.stack,
+                };
+            }
+            return null;
+        }))).filter(Boolean);
+        if (errors.length) {
+            return {
+                success: false,
+                error: {
+                    name: 'SOME_ENROLLMENTS_COULD_NOT_PROCESS',
+                    message: 'Some errors have been reported during order generation',
+                    logs: errors,
+                },
+                result: {},
+            };
+        }
+        return {
+            success: true,
+            result: input,
+        };
+    },
+};
+WorkerDirector.registerAdapter(GenerateOrderWorker);
+export const configureGenerateOrderAutoscheduling = () => {
+    if (enrollmentsSettings.autoSchedulingSchedule) {
+        WorkerDirector.configureAutoscheduling({
+            type: GenerateOrderWorker.type,
+            schedule: enrollmentsSettings.autoSchedulingSchedule,
+            retries: 5,
+        });
+    }
+};

package/lib/worker/error-notifications.d.ts

@@ -0,0 +1,9 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+interface Arg {
+    secondsPassed?: number;
+}
+interface Result {
+    forked?: string;
+}
+export declare const ErrorNotifications: IWorkerAdapter<Arg, Result>;
+export default ErrorNotifications;

package/lib/worker/error-notifications.js

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

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

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

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

package/lib/worker/external.js

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

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

package/lib/worker/heartbeat.js

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

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

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

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

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

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