@unchainedshop/plugins 4.6.2 → 4.7.2

package/lib/worker/budgetsms.js

@@ -1,169 +0,0 @@
-import { WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-const { BUDGETSMS_USERNAME, BUDGETSMS_USERID, BUDGETSMS_HANDLE } = process.env;
-const BudgetSMSWorker = {
-    ...WorkerAdapter,
-    key: 'shop.unchained.worker-plugin.budgetsms',
-    label: 'Send Messages through BudgetSMS',
-    version: '1.0.0',
-    type: 'BUDGETSMS',
-    doWork: async ({ from, to, text, test = false, customid, price = false, mccmnc = false, credit = false, ...params }) => {
-        try {
-            if (!BUDGETSMS_USERNAME || !BUDGETSMS_USERID || !BUDGETSMS_HANDLE) {
-                throw new Error('Missing BudgetSMS credentials. Please set BUDGETSMS_USERNAME, BUDGETSMS_USERID, and BUDGETSMS_HANDLE');
-            }
-            const username = BUDGETSMS_USERNAME.trim();
-            const userid = BUDGETSMS_USERID.trim();
-            const handle = BUDGETSMS_HANDLE.trim();
-            if (!/^\d+$/.test(userid)) {
-                throw new Error('BUDGETSMS_USERID must be numeric only. Found: ' + userid);
-            }
-            const url = test ? 'https://api.budgetsms.net/testsms/' : 'https://api.budgetsms.net/sendsms/';
-            const formattedTo = to.replace(/^\+|^00/, '').replace(/[\s-]/g, '');
-            const queryParams = new URLSearchParams({
-                username: username,
-                userid: userid,
-                handle: handle,
-                msg: text || '',
-                from: from || '',
-                to: formattedTo,
-                ...(customid && { customid }),
-                ...(!test && price && { price: '1' }),
-                ...(!test && mccmnc && { mccmnc: '1' }),
-                ...(!test && credit && { credit: '1' }),
-                ...params,
-            });
-            const fullUrl = `${url}?${queryParams.toString()}`;
-            const response = await fetch(fullUrl, {
-                method: 'GET',
-                headers: {
-                    Accept: 'text/plain',
-                    'User-Agent': 'Unchained/BudgetSMS-Plugin',
-                },
-            });
-            const responseText = await response.text().then((text) => text.trim());
-            if (responseText.startsWith('OK')) {
-                const parts = responseText.split(' ');
-                const result = {
-                    sms_id: parts[1] || null,
-                    status: test ? 'test_successful' : 'sent',
-                    test_mode: test,
-                };
-                if (test) {
-                    result.message = 'Test SMS validated successfully (no credit deducted)';
-                }
-                else {
-                    let index = 2;
-                    if (price && parts[index] && parts[index + 1]) {
-                        result.price = parseFloat(parts[index]);
-                        result.parts = parseInt(parts[index + 1]);
-                        index += 2;
-                    }
-                    if (mccmnc && parts[index]) {
-                        result.mccmnc = parts[index];
-                        index += 1;
-                    }
-                    if (credit && parts[index]) {
-                        result.remaining_credit = parseFloat(parts[index]);
-                    }
-                }
-                return {
-                    success: true,
-                    result,
-                    error: null,
-                };
-            }
-            if (responseText.startsWith('ERR')) {
-                const parts = responseText.split(' ');
-                const errorCode = parts[1] || 'UNKNOWN';
-                const errorMessages = {
-                    '1001': 'Authentication failed OR insufficient credit (BudgetSMS returns 1001 for both)',
-                    '1002': 'Account not active',
-                    '1003': 'Insufficient credit',
-                    '1004': 'No access to this API',
-                    '1005': 'No handle provided',
-                    '1006': 'No UserID provided',
-                    '1007': 'No Username provided',
-                    '2001': 'SMS message text is empty',
-                    '2002': 'SMS numeric senderid can be max. 16 numbers',
-                    '2003': 'SMS alphanumeric sender can be max. 11 characters',
-                    '2004': 'SMS senderid is empty or invalid',
-                    '2005': 'Destination number is too short',
-                    '2006': 'Destination is not numeric',
-                    '2007': 'Destination is empty',
-                    '2008': 'SMS text is not OK (check encoding?)',
-                    '2009': 'Parameter issue',
-                    '2010': 'Destination number is invalidly formatted',
-                    '2011': 'Destination is invalid',
-                    '2012': 'SMS message text is too long',
-                    '2013': 'SMS message is invalid',
-                    '2014': 'SMS CustomID is used before',
-                    '2015': 'Charset problem',
-                    '2016': 'Invalid UTF-8 encoding',
-                    '3001': 'No route to destination',
-                    '3002': 'No routes are setup',
-                    '3003': 'Invalid destination',
-                    '4001': 'System error, related to customid',
-                    '4002': 'System error, temporary issue',
-                };
-                let message = errorMessages[errorCode] || `Unknown error code: ${errorCode}`;
-                if (errorCode === '1001') {
-                    message += '. Note: Check your account balance - BudgetSMS may return 1001 when credit is 0.';
-                }
-                return {
-                    success: false,
-                    error: {
-                        name: 'BUDGETSMS_ERROR',
-                        code: errorCode,
-                        message,
-                    },
-                };
-            }
-            return {
-                success: false,
-                error: {
-                    name: 'BUDGETSMS_ERROR',
-                    message: 'Unexpected response format from BudgetSMS API',
-                    response: responseText,
-                },
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: {
-                    name: err.name,
-                    message: err.message,
-                    stack: err.stack,
-                },
-            };
-        }
-    },
-};
-WorkerDirector.registerAdapter(BudgetSMSWorker);
-export async function checkBudgetSmsCredentials() {
-    const url = 'https://api.budgetsms.net/checkcredit/';
-    const username = process.env.BUDGETSMS_USERNAME?.trim();
-    const userid = process.env.BUDGETSMS_USERID?.trim();
-    const handle = process.env.BUDGETSMS_HANDLE?.trim();
-    if (!username || !userid || !handle) {
-        return { error: 'Missing credentials' };
-    }
-    if (!/^\d+$/.test(userid)) {
-        return { error: 'UserID must be numeric only' };
-    }
-    const queryParams = new URLSearchParams({ username, userid, handle });
-    try {
-        const response = await fetch(`${url}?${queryParams.toString()}`, { method: 'GET' });
-        const text = await response.text();
-        if (text.startsWith('OK')) {
-            const credit = parseFloat(text.split(' ')[1]) || 0;
-            return { success: true, credit };
-        }
-        else {
-            return { error: text };
-        }
-    }
-    catch (err) {
-        return { error: err.message };
-    }
-}

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

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

package/lib/worker/bulk-export.js

@@ -1,64 +0,0 @@
-import { WorkerDirector, WorkerAdapter } from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-const isSupportedLocale = (locale) => {
-    try {
-        const dtf = new Intl.DateTimeFormat(locale);
-        const resolved = dtf.resolvedOptions().locale;
-        return resolved.toLowerCase() === locale.toLowerCase();
-    }
-    catch (e) {
-        console.error(e);
-        return false;
-    }
-};
-const createLanguageDialectList = (languages, countries) => {
-    const result = new Set();
-    (languages || []).forEach(({ isoCode: baseIsoCode }) => {
-        result.add(baseIsoCode);
-        (countries || []).forEach(({ isoCode: countryIsoCode }) => {
-            const dialectIsoCode = [baseIsoCode, countryIsoCode.toUpperCase()].join('-');
-            if (isSupportedLocale(dialectIsoCode))
-                result.add(dialectIsoCode);
-        });
-    });
-    return Array.from(result);
-};
-const logger = createLogger('unchained:bulk-export');
-export const BulkExportWorker = {
-    ...WorkerAdapter,
-    key: 'shop.unchained.worker-plugin.bulk-export',
-    label: 'Bulk Export',
-    version: '2.1.0',
-    type: 'BULK_EXPORT',
-    maxParallelAllocations: 1,
-    doWork: async (payload, unchainedAPI) => {
-        try {
-            const { modules } = unchainedAPI;
-            const languages = await modules.languages.findLanguages({ includeInactive: false });
-            const countries = await modules.countries.findCountries({ includeInactive: false });
-            const bulkExporter = unchainedAPI.bulkExporter.createBulkExporter({ entity: payload.type });
-            await bulkExporter.validate(payload);
-            const locales = createLanguageDialectList(languages, countries);
-            const [result, error] = await bulkExporter.execute(payload, locales, unchainedAPI);
-            if (error) {
-                return {
-                    success: false,
-                    result: result,
-                    error,
-                };
-            }
-            return {
-                success: true,
-                result,
-            };
-        }
-        catch (err) {
-            logger.error(err);
-            return {
-                success: false,
-                error: { name: err.name, message: err.message, stack: err.stack },
-            };
-        }
-    },
-};
-WorkerDirector.registerAdapter(BulkExportWorker);

package/lib/worker/bulk-import.d.ts

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

package/lib/worker/bulk-import.js

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

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

package/lib/worker/bulkgate.js

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

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

package/lib/worker/email.js

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

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

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

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

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