@unchainedshop/plugins 4.6.1 → 4.6.2

package/lib/worker/bulk-import/api.js

@@ -0,0 +1,53 @@
+import { createLogger } from '@unchainedshop/logger';
+import { Roles } from '@unchainedshop/roles';
+const logger = createLogger('unchained:bulk-import');
+export async function bulkImportHandler(request, context) {
+    try {
+        const hasPermission = await Roles.userHasPermission(context, 'bulkImport', []);
+        if (!hasPermission) {
+            return Response.json({ error: 'Permission denied', message: 'User does not have bulkImport permission' }, { status: 403 });
+        }
+        const url = new URL(request.url);
+        const input = {
+            createShouldUpsertIfIDExists: url.searchParams.get('createShouldUpsertIfIDExists') === 'true',
+            updateShouldUpsertIfIDNotExists: url.searchParams.get('updateShouldUpsertIfIDNotExists') === 'true',
+            skipCacheInvalidation: url.searchParams.get('skipCacheInvalidation') === 'true',
+            remoteAddress: context.remoteAddress,
+        };
+        const date = new Date().toISOString();
+        const stream = context.rawRequest;
+        if (!stream) {
+            return Response.json({ error: 'No request stream available' }, { status: 400 });
+        }
+        const file = await context.services.files.uploadFileFromStream({
+            directoryName: 'bulk-import-streams',
+            rawFile: Promise.resolve({
+                filename: `${date}.json`,
+                createReadStream: () => stream,
+            }),
+            chunkSizeBytes: 1024 * 1024 * 5,
+            meta: {},
+        });
+        const validationStream = await context.services.files.createDownloadStream({
+            fileId: file._id,
+        });
+        if (!validationStream) {
+            throw new Error('Could not create download stream from uploaded file');
+        }
+        await context.bulkImporter.validateEventStream(validationStream);
+        input.payloadId = file._id;
+        input.payloadSize = file.size;
+        const purgedInput = Object.fromEntries(Object.entries(input).filter(([, value]) => Boolean(value)));
+        const work = await context.modules.worker.addWork({
+            type: 'BULK_IMPORT',
+            input: purgedInput,
+            retries: 0,
+            priority: 10,
+        });
+        return Response.json(work, { status: 200 });
+    }
+    catch (e) {
+        logger.error(e);
+        return Response.json({ name: e.name, code: e.code, message: e.message }, { status: 503 });
+    }
+}

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

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

package/lib/worker/bulk-import/index.js

@@ -0,0 +1,18 @@
+import { BulkImportWorker } from "./adapter.js";
+import { bulkImportHandler } from "./api.js";
+const { BULK_IMPORT_API_PATH = '/bulk-import' } = process.env;
+export const BulkImportPlugin = {
+    key: 'shop.unchained.worker-plugin.bulk-import',
+    label: 'Bulk Import Worker Plugin',
+    version: '1.0.0',
+    adapters: [BulkImportWorker],
+    routes: [
+        {
+            path: BULK_IMPORT_API_PATH,
+            method: 'POST',
+            handler: bulkImportHandler,
+        },
+    ],
+};
+export default BulkImportPlugin;
+export { BulkImportWorker } from "./adapter.js";

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

@@ -0,0 +1,12 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const BulkGateWorker: IWorkerAdapter<{
+    from?: string;
+    to?: string;
+    text?: string;
+    unicode?: boolean;
+    country?: string;
+    schedule?: string | number;
+    promotional?: boolean;
+    [key: string]: any;
+}, any>;
+export default BulkGateWorker;

package/lib/worker/bulkgate/adapter.js

@@ -0,0 +1,91 @@
+import { WorkerAdapter } from '@unchainedshop/core';
+const { BULKGATE_APPLICATION_ID, BULKGATE_APPLICATION_TOKEN } = process.env;
+export 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,
+                },
+            };
+        }
+    },
+};
+export default BulkGateWorker;

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

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

package/lib/worker/bulkgate/index.js

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

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

@@ -0,0 +1,9 @@
+import { type IWorkerAdapter } from '@unchainedshop/core';
+export declare const checkEmailInterceptionEnabled: () => boolean;
+export declare const EmailWorkerPlugin: IWorkerAdapter<{
+    from?: string;
+    to?: string;
+    subject?: string;
+    [x: string]: any;
+}, any>;
+export default EmailWorkerPlugin;

package/lib/worker/email/adapter.js

@@ -0,0 +1,150 @@
+import { 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 escapeHtml = (str) => {
+    if (!str)
+        return '';
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+};
+const buildLink = async ({ filename, content, href, contentType, encoding, path }) => {
+    const safeFilename = escapeHtml(filename);
+    if (path) {
+        const safePath = escapeHtml(path.startsWith('/') ? path : `${process.cwd()}/${path}`);
+        return `<a href="file:/${safePath}">${safeFilename}</a>`;
+    }
+    if (href) {
+        const safeHref = escapeHtml(href);
+        return `<a href="${safeHref}">${safeFilename}</a>`;
+    }
+    if (content && encoding === 'base64') {
+        const safeContentType = escapeHtml(contentType);
+        return `<a target="_blank" href="${`data:${safeContentType};base64,${content}`}">${safeFilename}</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 || escapeHtml(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>${escapeHtml(options.from)}<br/>
+    <b>To:&nbsp;</b>${escapeHtml(options.to)}<br/>
+    <b>Cc:&nbsp;</b>${escapeHtml(options.cc)}<br/>
+    <b>Bcc:&nbsp;</b>${escapeHtml(options.bcc)}<br/>
+    <b>Reply-To:&nbsp;</b>${escapeHtml(options.replyTo)}<br/>
+    <br/>
+    <b>subject:&nbsp;</b>${escapeHtml(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);
+    });
+};
+export 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,
+                },
+            };
+        }
+    },
+};
+export default EmailWorkerPlugin;

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

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

package/lib/worker/email/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { EmailWorkerPlugin as EmailWorker } from "./adapter.js";
+export const EmailPlugin = {
+    key: 'shop.unchained.worker-plugin.email',
+    label: 'Email Worker Plugin',
+    version: '1.0.0',
+    adapters: [EmailWorker],
+};
+export default EmailPlugin;
+export { EmailWorkerPlugin, checkEmailInterceptionEnabled } from "./adapter.js";

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

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

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

@@ -0,0 +1,77 @@
+import { enrollmentsSettings, EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { EnrollmentDirector, WorkerDirector, WorkerAdapter, } from '@unchainedshop/core';
+export 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,
+        };
+    },
+};
+export const configureGenerateOrderAutoscheduling = () => {
+    if (enrollmentsSettings.autoSchedulingSchedule) {
+        WorkerDirector.configureAutoscheduling({
+            type: GenerateOrderWorker.type,
+            schedule: enrollmentsSettings.autoSchedulingSchedule,
+            retries: 5,
+        });
+    }
+};
+export default GenerateOrderWorker;

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

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

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

@@ -0,0 +1,13 @@
+import {} from '@unchainedshop/core';
+import { GenerateOrderWorker, configureGenerateOrderAutoscheduling } from "./adapter.js";
+export const EnrollmentOrderGeneratorPlugin = {
+    key: 'shop.unchained.worker.enrollment-order-generator',
+    label: 'Enrollment Order Generator Worker Plugin',
+    version: '1.0.0',
+    adapters: [GenerateOrderWorker],
+    onRegister: () => {
+        configureGenerateOrderAutoscheduling();
+    },
+};
+export default EnrollmentOrderGeneratorPlugin;
+export { GenerateOrderWorker, configureGenerateOrderAutoscheduling } from "./adapter.js";

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

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

package/lib/worker/error-notifications/adapter.js

@@ -0,0 +1,62 @@
+import { WorkStatus } from '@unchainedshop/core-worker';
+import { WorkerAdapter, WorkerDirector, 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,
+                },
+            };
+        }
+    },
+};
+export default ErrorNotifications;
+const ONE_DAY_IN_SECONDS = 24 * 60 * 60;
+export const configureErrorNotificationsAutoscheduling = () => {
+    WorkerDirector.configureAutoscheduling({
+        type: ErrorNotifications.type,
+        schedule: everyDayAtFourInTheNight,
+        input: async () => ({ secondsPassed: ONE_DAY_IN_SECONDS }),
+        retries: 0,
+    });
+};

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

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

package/lib/worker/error-notifications/index.js

@@ -0,0 +1,13 @@
+import {} from '@unchainedshop/core';
+import { ErrorNotifications, configureErrorNotificationsAutoscheduling } from "./adapter.js";
+export const ErrorNotificationsPlugin = {
+    key: 'shop.unchained.worker.error-notifications',
+    label: 'Error Notifications Worker Plugin',
+    version: '1.0.0',
+    adapters: [ErrorNotifications],
+    onRegister: () => {
+        configureErrorNotificationsAutoscheduling();
+    },
+};
+export default ErrorNotificationsPlugin;
+export * from "./adapter.js";

package/lib/worker/export-token/adapter.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 ExportTokenWorker;

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';