@unchainedshop/plugins 4.6.1 → 4.7.2

package/lib/files/minio/index.d.ts

@@ -1,5 +1,4 @@
-import { type IFileAdapter } from '@unchainedshop/file-upload';
-import { Client } from 'minio';
-export declare function connectToMinio(): Promise<Client | null>;
-export declare const MinioAdapter: IFileAdapter;
-export default MinioAdapter;
+import type { IPlugin } from '@unchainedshop/core';
+export declare const MinioPlugin: IPlugin;
+export default MinioPlugin;
+export { MinioAdapter, connectToMinio } from './adapter.ts';

package/lib/files/minio/index.js

@@ -1,164 +1,25 @@
-import { Readable } from 'node:stream';
-import {} from '@unchainedshop/file-upload';
-import { FileAdapter, FileDirector, buildHashedFilename, resolveExpirationDate, } from '@unchainedshop/file-upload';
-import mime from 'mime/lite';
-import { Client } from 'minio';
-import { AssumeRoleProvider } from 'minio/dist/esm/AssumeRoleProvider.mjs';
-import { expiryOffsetInMs } from '@unchainedshop/file-upload/lib/put-expiration.js';
 import { createLogger } from '@unchainedshop/logger';
+import { MinioAdapter } from "./adapter.js";
+import { minioWebhookHandler } from "./api.js";
 const logger = createLogger('unchained:minio');
-const { MINIO_ACCESS_KEY, MINIO_REGION, MINIO_STS_ENDPOINT, MINIO_SECRET_KEY, MINIO_ENDPOINT, MINIO_BUCKET_NAME, MINIO_UPLOAD_PREFIX, NODE_ENV, AMAZON_S3_SESSION_TOKEN, } = process.env;
-let client = null;
-export async function connectToMinio() {
-    if (!MINIO_ENDPOINT || !MINIO_BUCKET_NAME) {
-        logger.error('Please configure Minio/S3 by providing MINIO_ENDPOINT & MINIO_BUCKET_NAME to use upload features');
-        return null;
-    }
-    try {
-        const resolvedUrl = new URL(MINIO_ENDPOINT);
-        const minioClient = new Client({
-            endPoint: resolvedUrl.hostname,
-            useSSL: resolvedUrl.protocol === 'https:',
-            port: parseInt(resolvedUrl.port, 10) || undefined,
-            region: MINIO_REGION,
-            sessionToken: AMAZON_S3_SESSION_TOKEN,
-            accessKey: MINIO_ACCESS_KEY,
-            secretKey: MINIO_SECRET_KEY,
-        });
-        if (NODE_ENV === 'development')
-            minioClient?.traceOn(process.stdout);
-        if (MINIO_STS_ENDPOINT) {
-            const ap = new AssumeRoleProvider({
-                stsEndpoint: MINIO_STS_ENDPOINT,
-                accessKey: MINIO_ACCESS_KEY,
-                secretKey: MINIO_SECRET_KEY,
-            });
-            await minioClient.setCredentialsProvider(ap);
-        }
-        return minioClient;
-    }
-    catch (error) {
-        logger.error(`Exception while creating Minio client: ${error.message}`);
-    }
-    return null;
-}
-const generateMinioPath = (directoryName, fileName) => {
-    const prefix = MINIO_UPLOAD_PREFIX || '';
-    return [prefix, directoryName, fileName].filter(Boolean).join('/');
-};
-const generateMinioUrl = (directoryName, hashedFilename) => {
-    return `${MINIO_ENDPOINT}/${MINIO_BUCKET_NAME}/${generateMinioPath(directoryName, hashedFilename)}`;
-};
-connectToMinio().then(function setClient(c) {
-    client = c || client;
-});
-const getObjectStats = async (fileName) => {
-    if (!client)
-        throw new Error('Minio not connected, check env variables');
-    return client.statObject(MINIO_BUCKET_NAME, fileName);
-};
-const bufferToStream = (buffer) => {
-    const stream = new Readable();
-    stream.push(buffer);
-    stream.push(null);
-    return stream;
-};
-export const MinioAdapter = {
+const { MINIO_WEBHOOK_AUTH_TOKEN, MINIO_WEBHOOK_PATH = '/minio/webhook' } = process.env;
+export const MinioPlugin = {
     key: 'shop.unchained.file-upload-plugin.minio',
-    label: 'Uploads files into an S3 bucket using minio',
+    label: 'Minio/S3 File Upload Plugin with Webhook',
     version: '1.1.0',
-    ...FileAdapter,
-    async createDownloadURL(file) {
-        if (file.meta?.isPrivate)
-            throw new Error("Minio Plugin doesn't support private files yet");
-        return generateMinioUrl(file.path, file._id);
-    },
-    async createSignedURL(directoryName, fileName) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        const expiryDate = resolveExpirationDate();
-        const _id = await buildHashedFilename(directoryName, fileName, expiryDate);
-        const url = await client.presignedPutObject(MINIO_BUCKET_NAME, generateMinioPath(directoryName, _id), expiryOffsetInMs() / 1000);
-        return {
-            _id,
-            directoryName,
-            expiryDate,
-            fileName,
-            type: mime.getType(fileName),
-            putURL: url,
-            url: generateMinioUrl(directoryName, _id),
-        };
-    },
-    async removeFiles(files) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        const fileIds = files.map(({ path, _id }) => {
-            return `${path}/${_id}`;
-        });
-        await client.removeObjects(MINIO_BUCKET_NAME, fileIds);
-    },
-    async uploadFileFromStream(directoryName, rawFile) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        let stream;
-        let fileName;
-        if (rawFile instanceof Promise) {
-            const { filename: fname, createReadStream } = await rawFile;
-            fileName = fname;
-            stream = createReadStream();
-        }
-        else {
-            fileName = rawFile.filename;
-            stream = bufferToStream(Buffer.from(rawFile.buffer, 'base64'));
+    adapters: [MinioAdapter],
+    routes: [
+        {
+            path: MINIO_WEBHOOK_PATH,
+            method: 'POST',
+            handler: minioWebhookHandler,
+        },
+    ],
+    onRegister: () => {
+        if (!MINIO_WEBHOOK_AUTH_TOKEN) {
+            logger.warn('MINIO_WEBHOOK_AUTH_TOKEN not set - webhooks will be disabled');
         }
-        const _id = await buildHashedFilename(directoryName, fileName, new Date());
-        const type = mime.getType(fileName) || (await Promise.resolve(rawFile)).mimetype;
-        const metaData = {
-            'Content-Type': type,
-        };
-        await client.putObject(MINIO_BUCKET_NAME, generateMinioPath(directoryName, _id), stream, undefined, metaData);
-        const { size } = await getObjectStats(generateMinioPath(directoryName, _id));
-        return {
-            _id,
-            directoryName,
-            expiryDate: null,
-            fileName,
-            size,
-            type,
-            url: generateMinioUrl(directoryName, _id),
-        };
-    },
-    async uploadFileFromURL(directoryName, { fileLink, fileName: fname, fileId, headers }) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        const { href } = new URL(fileLink);
-        const fileName = fname || href.split('/').pop();
-        const hashedFilename = await buildHashedFilename(directoryName, fileName, new Date());
-        const url = new URL(fileLink);
-        const response = await fetch(url, { headers });
-        const type = mime.getType(fileName) || response.headers['content-type'];
-        const readable = Readable.fromWeb(response.body);
-        const metaData = {
-            'Content-Type': type,
-        };
-        await client.putObject(MINIO_BUCKET_NAME, generateMinioPath(directoryName, hashedFilename), readable, undefined, metaData);
-        const { size } = await getObjectStats(generateMinioPath(directoryName, hashedFilename));
-        return {
-            _id: fileId || hashedFilename,
-            directoryName,
-            expiryDate: null,
-            fileName,
-            size,
-            type,
-            url: generateMinioUrl(directoryName, hashedFilename),
-        };
-    },
-    async createDownloadStream(file) {
-        if (!client)
-            throw new Error('Minio not connected, check env variables');
-        const stream = await client.getObject(MINIO_BUCKET_NAME, generateMinioPath(file.path, file._id));
-        return stream;
     },
 };
-FileDirector.registerAdapter(MinioAdapter);
-export default MinioAdapter;
+export default MinioPlugin;
+export { MinioAdapter, connectToMinio } from "./adapter.js";

package/lib/files/temp-upload/api.d.ts

@@ -0,0 +1,6 @@
+import { type UnchainedCore } from '@unchainedshop/core';
+export declare function tempUploadHandler(request: Request, context: UnchainedCore & {
+    params: Record<string, string>;
+    userId?: string;
+    user?: any;
+}): Promise<Response>;

package/lib/files/temp-upload/api.js

@@ -0,0 +1,49 @@
+import { createLogger } from '@unchainedshop/logger';
+import { getFileAdapter } from '@unchainedshop/core';
+import { Roles } from '@unchainedshop/roles';
+const logger = createLogger('unchained:temp-upload');
+export async function tempUploadHandler(request, context) {
+    try {
+        const hasPermission = await Roles.userHasPermission(context, 'uploadTempFile', []);
+        if (!hasPermission) {
+            return Response.json({ error: 'Permission denied', message: 'User does not have uploadTempFile permission' }, { status: 403 });
+        }
+        const formData = await request.formData();
+        let file = formData.get('file');
+        if (!file || !(file instanceof File)) {
+            for (const [, value] of formData.entries()) {
+                if (value instanceof File) {
+                    file = value;
+                    break;
+                }
+            }
+        }
+        if (!file) {
+            return Response.json({ error: 'No file uploaded' }, { status: 400 });
+        }
+        const buffer = Buffer.from(await file.arrayBuffer());
+        const uploadedFile = await context.services.files.uploadFileFromStream({
+            directoryName: 'temp-uploads',
+            rawFile: {
+                filename: file.name,
+                buffer,
+                mimetype: file.type,
+            },
+            meta: { encoding: 'binary' },
+        });
+        const expires = new Date(Date.now() + 24 * 60 * 60 * 1000);
+        await context.modules.files.update(uploadedFile._id, {
+            expires,
+        });
+        const fileUploadAdapter = getFileAdapter();
+        const rawUrl = await fileUploadAdapter.createDownloadURL(uploadedFile);
+        if (!rawUrl)
+            throw new Error('Could not create download URL for file');
+        const url = context.modules.files.normalizeUrl(rawUrl, {});
+        return Response.json({ fileId: uploadedFile._id, url, expires: expires.toISOString() }, { status: 200 });
+    }
+    catch (e) {
+        logger.error(e);
+        return Response.json({ name: e.name, code: e.code, message: e.message }, { status: 503 });
+    }
+}

package/lib/files/temp-upload/index.d.ts

@@ -0,0 +1,3 @@
+import type { IPlugin } from '@unchainedshop/core';
+export declare const TempUploadPlugin: IPlugin;
+export default TempUploadPlugin;

package/lib/files/temp-upload/index.js

@@ -0,0 +1,15 @@
+import { tempUploadHandler } from "./api.js";
+const { TEMP_UPLOAD_API_PATH = '/temp-upload' } = process.env;
+export const TempUploadPlugin = {
+    key: 'shop.unchained.files.temp-upload',
+    label: 'Temp Upload Plugin',
+    version: '1.0.0',
+    routes: [
+        {
+            path: TEMP_UPLOAD_API_PATH,
+            method: 'POST',
+            handler: tempUploadHandler,
+        },
+    ],
+};
+export default TempUploadPlugin;

package/lib/filters/local-search/adapter.d.ts

@@ -0,0 +1,2 @@
+import { type IFilterAdapter } from '@unchainedshop/core';
+export declare const LocalSearch: IFilterAdapter;

package/lib/filters/{local-search.js → local-search/adapter.js}

@@ -1,8 +1,5 @@
-import { FilterDirector, FilterAdapter } from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-import { isDocumentDBCompatModeEnabled } from '@unchainedshop/mongodb';
-const logger = createLogger('unchained:local-search');
-const LocalSearch = {
+import { FilterAdapter } from '@unchainedshop/core';
+export const LocalSearch = {
     ...FilterAdapter,
     key: 'shop.unchained.filters.local-search',
     label: 'Simple Fulltext search with MongoDB',
@@ -57,10 +54,3 @@ const LocalSearch = {
         };
     },
 };
-export default LocalSearch;
-if (!isDocumentDBCompatModeEnabled()) {
-    FilterDirector.registerAdapter(LocalSearch);
-}
-else {
-    logger.warn('Free text search queries have been disabled due to DocumentDB compatibility mode (env UNCHAINED_DOCUMENTDB_COMPAT_MODE is trueish)');
-}

package/lib/filters/local-search/index.d.ts

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

package/lib/filters/local-search/index.js

@@ -0,0 +1,16 @@
+import {} from '@unchainedshop/core';
+import { LocalSearch } from "./adapter.js";
+import { isDocumentDBCompatModeEnabled } from '@unchainedshop/mongodb';
+export const LocalSearchPlugin = {
+    key: 'shop.unchained.filters.local-search',
+    label: 'Local Search Filter Plugin',
+    version: '1.0.0',
+    adapters: [LocalSearch],
+    onRegister: () => {
+        if (isDocumentDBCompatModeEnabled()) {
+            throw new Error('Full-text search queries have been disabled due to DocumentDB compatibility mode (env UNCHAINED_DOCUMENTDB_COMPAT_MODE is trueish)');
+        }
+    },
+};
+export default LocalSearchPlugin;
+export { LocalSearch } from "./adapter.js";

package/lib/filters/strict-equal/adapter.d.ts

@@ -0,0 +1,2 @@
+import { type IFilterAdapter } from '@unchainedshop/core';
+export declare const StrictQualFilter: IFilterAdapter;

package/lib/filters/{strict-equal.js → strict-equal/adapter.js}

@@ -1,5 +1,5 @@
-import { FilterDirector, FilterAdapter } from '@unchainedshop/core';
-const StrictQualFilter = {
+import { FilterAdapter } from '@unchainedshop/core';
+export const StrictQualFilter = {
     ...FilterAdapter,
     key: 'shop.unchained.filters.strict-qual',
     label: 'Simple Strict Equal DB Filter',
@@ -21,4 +21,3 @@ const StrictQualFilter = {
         };
     },
 };
-FilterDirector.registerAdapter(StrictQualFilter);

package/lib/filters/strict-equal/index.d.ts

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

package/lib/filters/strict-equal/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { StrictQualFilter } from "./adapter.js";
+export const StrictQualFilterPlugin = {
+    key: 'shop.unchained.filters.strict-qual',
+    label: 'Strict Equal Filter Plugin',
+    version: '1.0.0',
+    adapters: [StrictQualFilter],
+};
+export default StrictQualFilterPlugin;
+export { StrictQualFilter } from "./adapter.js";

package/lib/payment/apple-iap/adapter.d.ts

@@ -1 +1,2 @@
-export {};
+import { type IPaymentAdapter } from '@unchainedshop/core';
+export declare const AppleIAP: IPaymentAdapter;

package/lib/payment/apple-iap/adapter.js

@@ -1,10 +1,10 @@
-import { PaymentAdapter, PaymentDirector, PaymentError, } from '@unchainedshop/core';
+import { PaymentAdapter, PaymentError } from '@unchainedshop/core';
 import { createLogger } from '@unchainedshop/logger';
 import {} from "./module.js";
 import { verifyReceipt } from "./verify-receipt.js";
 const logger = createLogger('unchained:apple-iap');
 const { APPLE_IAP_SHARED_SECRET } = process.env;
-const AppleIAP = {
+export const AppleIAP = {
     ...PaymentAdapter,
     key: 'shop.unchained.apple-iap',
     label: 'Apple In-App-Purchase',
@@ -111,4 +111,3 @@ const AppleIAP = {
         return adapterActions;
     },
 };
-PaymentDirector.registerAdapter(AppleIAP);

package/lib/payment/apple-iap/api.d.ts

@@ -0,0 +1,2 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare function appleIAPWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;

package/lib/payment/apple-iap/{handler-fastify.js → api.js}

@@ -1,10 +1,7 @@
-import {} from '@unchainedshop/api';
-import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
 import { createLogger } from '@unchainedshop/logger';
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
 import { fixPeriods } from "./fix-periods.js";
-import {} from 'fastify';
-import {} from "./module.js";
-const logger = createLogger('unchained:apple-iap:handler');
+const logger = createLogger('unchained:apple-iap');
 const { APPLE_IAP_SHARED_SECRET } = process.env;
 const AppleNotificationTypes = {
     INITIAL_BUY: 'INITIAL_BUY',
@@ -13,47 +10,61 @@ const AppleNotificationTypes = {
     DID_FAIL_TO_RENEW: 'DID_FAIL_TO_RENEW',
     DID_CHANGE_RENEWAL_PREF: 'DID_CHANGE_RENEWAL_PREF',
 };
-export const appleIAPHandler = async (req, reply) => {
+export async function appleIAPWebhookHandler(request, context) {
     try {
-        const resolvedContext = req.unchainedContext;
-        const { modules, services } = resolvedContext;
-        const responseBody = req.body || {};
+        const { modules, services } = context;
+        const responseBody = await request.json();
         if (responseBody.password !== APPLE_IAP_SHARED_SECRET) {
-            throw new Error('shared secret not valid');
+            logger.warn('Apple IAP Webhook: Invalid shared secret');
+            return new Response(JSON.stringify({
+                error: 'Invalid shared secret',
+                name: 'AuthenticationError',
+                code: 'INVALID_SECRET',
+            }), {
+                status: 403,
+                headers: { 'Content-Type': 'application/json' },
+            });
         }
         const transactions = responseBody?.unified_receipt?.latest_receipt_info;
-        const latestTransaction = transactions[0];
+        const latestTransaction = transactions?.[0];
+        if (!latestTransaction) {
+            throw new Error('No transaction found in receipt');
+        }
         if (responseBody.notification_type === AppleNotificationTypes.INITIAL_BUY) {
             const orderPayment = await modules.orders.payments.findOrderPaymentByTransactionId(latestTransaction.transaction_id);
-            if (!orderPayment)
+            if (!orderPayment) {
                 throw new Error('Could not find any matching order payment');
+            }
             const order = await services.orders.checkoutOrder(orderPayment.orderId, {
                 paymentContext: {
                     receiptData: responseBody?.unified_receipt?.latest_receipt,
                 },
             });
-            if (!order)
+            if (!order) {
                 throw new Error(`Order with id ${orderPayment.orderId} not found`);
+            }
             const orderId = order._id;
             const enrollment = await modules.enrollments.findEnrollment({
                 orderId,
             });
-            if (!enrollment)
-                throw new Error('Enrollent not found');
+            if (!enrollment) {
+                throw new Error('Could not find any matching enrollment');
+            }
             await fixPeriods({
                 transactionId: latestTransaction.original_transaction_id,
                 transactions,
                 enrollmentId: enrollment._id,
                 orderId,
-            }, resolvedContext);
-            logger.info(`Webhook confirmed checkout for order ${order.orderNumber}`, {
+            }, context);
+            logger.info(`Apple IAP Webhook: Confirmed checkout for order ${order.orderNumber}`, {
                 orderId: order._id,
             });
         }
         else {
             const originalOrderPayment = await modules.orders.payments.findOrderPaymentByTransactionId(latestTransaction.original_transaction_id);
-            if (!originalOrderPayment)
+            if (!originalOrderPayment) {
                 throw new Error('Could not find any matching order payment');
+            }
             const originalOrder = await modules.orders.findOrder({
                 orderId: originalOrderPayment.orderId,
             });
@@ -61,8 +72,9 @@ export const appleIAPHandler = async (req, reply) => {
                 (await modules.enrollments.findEnrollment({
                     orderId: originalOrder._id,
                 }));
-            if (!enrollment?.payment)
+            if (!enrollment?.payment) {
                 throw new Error('Could not find a valid enrollment payment method');
+            }
             await services.orders.registerPaymentCredentials(enrollment.payment.paymentProviderId, {
                 transactionContext: {
                     receiptData: responseBody?.unified_receipt?.latest_receipt,
@@ -74,8 +86,8 @@ export const appleIAPHandler = async (req, reply) => {
                 transactions,
                 enrollmentId: enrollment._id,
                 orderId: originalOrder._id,
-            }, resolvedContext);
-            logger.info(`Webhook rocessed notification for ${latestTransaction.original_transaction_id} and type ${responseBody.notification_type}`);
+            }, context);
+            logger.info(`Apple IAP Webhook: Processed notification for ${latestTransaction.original_transaction_id} and type ${responseBody.notification_type}`);
             if (responseBody.notification_type === AppleNotificationTypes.DID_RECOVER) {
                 if (enrollment.status !== EnrollmentStatus.TERMINATED &&
                     responseBody.auto_renew_status === 'false') {
@@ -88,15 +100,20 @@ export const appleIAPHandler = async (req, reply) => {
                     await services.enrollments.terminateEnrollment(enrollment);
                 }
             }
-            logger.info(`Apple IAP Webhook: Updated enrollment from Apple`);
+            logger.info('Apple IAP Webhook: Updated enrollment from Apple');
         }
-        reply.status(200);
-        return reply.send();
+        return new Response(null, { status: 200 });
     }
-    catch (e) {
-        logger.error(e);
-        reply.status(503);
-        return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
+    catch (error) {
+        logger.error('Apple IAP Webhook error:', error);
+        return new Response(JSON.stringify({
+            success: false,
+            error: error.message,
+            name: error.name,
+            code: error.code,
+        }), {
+            status: 503,
+            headers: { 'Content-Type': 'application/json' },
+        });
     }
-};
-export default appleIAPHandler;
+}

package/lib/payment/apple-iap/index.d.ts

@@ -1,4 +1,6 @@
-export * from './adapter.ts';
-import appleTransactionsModule, { type AppleTransactionsModule } from './module.ts';
-export type { AppleTransactionsModule };
-export default appleTransactionsModule;
+import type { IPlugin } from '@unchainedshop/core';
+import { type AppleTransactionsModule } from './module.ts';
+export declare const AppleIAPPlugin: IPlugin;
+export default AppleIAPPlugin;
+export { AppleIAP } from './adapter.ts';
+export { type AppleTransactionsModule };

package/lib/payment/apple-iap/index.js

@@ -1,3 +1,28 @@
-export * from "./adapter.js";
-import appleTransactionsModule, {} from "./module.js";
-export default appleTransactionsModule;
+import { AppleIAP } from "./adapter.js";
+import { configureAppleTransactionsModule } from "./module.js";
+import { appleIAPWebhookHandler } from "./api.js";
+const { APPLE_IAP_WEBHOOK_PATH = '/payment/apple-iap', APPLE_IAP_SHARED_SECRET } = process.env;
+export const AppleIAPPlugin = {
+    key: 'shop.unchained.payment.apple-iap',
+    label: 'Apple In-App-Purchase Payment Plugin',
+    version: '1.0.0',
+    adapters: [AppleIAP],
+    module: ({ db }) => ({
+        appleTransactions: configureAppleTransactionsModule({ db }),
+    }),
+    routes: [
+        {
+            path: APPLE_IAP_WEBHOOK_PATH,
+            method: 'POST',
+            handler: appleIAPWebhookHandler,
+        },
+    ],
+    onRegister: () => {
+        if (!APPLE_IAP_SHARED_SECRET) {
+            throw new Error('APPLE_IAP_SHARED_SECRET not set');
+        }
+    },
+};
+export default AppleIAPPlugin;
+export { AppleIAP } from "./adapter.js";
+export {};

package/lib/payment/cryptopay/adapter.d.ts

@@ -0,0 +1,2 @@
+import { type IPaymentAdapter } from '@unchainedshop/core';
+export declare const Cryptopay: IPaymentAdapter;

package/lib/payment/cryptopay/{plugin.js → adapter.js}

@@ -1,4 +1,4 @@
-import { PaymentAdapter, PaymentDirector, PaymentError, OrderPricingSheet, } from '@unchainedshop/core';
+import { PaymentAdapter, PaymentError, OrderPricingSheet, } from '@unchainedshop/core';
 import { createLogger } from '@unchainedshop/logger';
 import {} from "./module.js";
 import deriveBtcAddress from "./derive-btc-address.js";
@@ -10,7 +10,7 @@ const CryptopayCurrencies = {
     BTC: 'BTC',
     ETH: 'ETH',
 };
-const Cryptopay = {
+export const Cryptopay = {
     ...PaymentAdapter,
     key: 'shop.unchained.payment.cryptopay',
     label: 'Cryptopay',
@@ -155,5 +155,3 @@ const Cryptopay = {
         return adapterActions;
     },
 };
-PaymentDirector.registerAdapter(Cryptopay);
-export default Cryptopay;

package/lib/payment/cryptopay/api.d.ts

@@ -0,0 +1,2 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare function cryptopayWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;

package/lib/payment/cryptopay/api.js

@@ -0,0 +1,23 @@
+import { createLogger } from '@unchainedshop/logger';
+import handleWebhook from "./handle-webhook.js";
+const logger = createLogger('unchained:cryptopay');
+export async function cryptopayWebhookHandler(request, context) {
+    try {
+        const body = await request.json();
+        await handleWebhook(body, context);
+        return new Response(JSON.stringify({ success: true }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    catch (error) {
+        logger.error('Cryptopay webhook error:', error);
+        return new Response(JSON.stringify({
+            success: false,
+            error: error.message,
+        }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+}

package/lib/payment/cryptopay/index.d.ts

@@ -1,4 +1,5 @@
-import './plugin.ts';
-import cryptopayModules, { type CryptopayModule } from './module.ts';
-export type { CryptopayModule };
-export default cryptopayModules;
+import type { IPlugin } from '@unchainedshop/core';
+export declare const CryptopayPlugin: IPlugin;
+export default CryptopayPlugin;
+export { Cryptopay } from './adapter.ts';
+export { type CryptopayModule } from './module.ts';