@unchainedshop/plugins 4.6.2 → 4.7.2

package/README.md

@@ -22,7 +22,6 @@ npm install @unchainedshop/plugins
 | Stripe | `payment/stripe` | Stripe payment integration |
 | Datatrans V2 | `payment/datatrans-v2` | Datatrans payment gateway |
 | Saferpay | `payment/saferpay` | Saferpay payment gateway |
-| PayPal Checkout | `payment/paypal-checkout` | PayPal Checkout integration |
 | Braintree | `payment/braintree` | Braintree payments |
 | Payrexx | `payment/payrexx` | Payrexx payment gateway |
 | Apple IAP | `payment/apple-iap` | Apple In-App Purchase |
@@ -134,7 +133,6 @@ All payment plugins implement secure tokenization patterns for PCI DSS SAQ-A eli
 | Stripe | PaymentIntent/SetupIntent tokenization |
 | Datatrans | Secure Fields with HMAC-SHA-256 signatures |
 | Saferpay | Redirect with SHA-256 transaction signatures |
-| PayPal | Order ID references |
 | Braintree | Client SDK tokenization |
 | Cryptopay | BIP-32 HD wallet address derivation |
 

package/lib/events/node-event-emitter.d.ts

@@ -1 +1,3 @@
-export {};
+import { type EmitAdapter } from '@unchainedshop/events';
+export declare const NodeEventEmitter: () => EmitAdapter;
+export default NodeEventEmitter;

package/lib/events/node-event-emitter.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
-import { setEmitAdapter } from '@unchainedshop/events';
-const NodeEventEmitter = () => {
+import {} from '@unchainedshop/events';
+export const NodeEventEmitter = () => {
     const eventEmitter = new EventEmitter();
     return {
         publish: (eventName, payload) => {
@@ -11,4 +11,4 @@ const NodeEventEmitter = () => {
         },
     };
 };
-setEmitAdapter(NodeEventEmitter());
+export default NodeEventEmitter;

package/lib/files/gridfs/adapter.d.ts

@@ -1,6 +1,6 @@
-import { type IFileAdapter } from '@unchainedshop/file-upload';
+import { type IFileAdapter } from '@unchainedshop/core-files';
 import { type UnchainedCore } from '@unchainedshop/core';
-import { type GridFSFileUploadsModule } from './index.ts';
+import { type GridFSFileUploadsModule } from './module.ts';
 export declare const GridFSAdapter: IFileAdapter<UnchainedCore & {
     modules: GridFSFileUploadsModule;
 }>;

package/lib/files/gridfs/adapter.js

@@ -1,12 +1,10 @@
 import { Readable, PassThrough } from 'node:stream';
 import { finished, pipeline } from 'node:stream/promises';
 import mime from 'mime/lite';
-import { FileAdapter, FileDirector, buildHashedFilename, resolveExpirationDate, } from '@unchainedshop/file-upload';
-import {} from '@unchainedshop/file-upload';
+import { FileAdapter, buildHashedFilename, resolveExpirationDate, filesSettings, } from '@unchainedshop/core-files';
 import sign from "./sign.js";
-import { filesSettings } from '@unchainedshop/core-files';
 import {} from '@unchainedshop/core';
-import {} from "./index.js";
+import {} from "./module.js";
 const { GRIDFS_PUT_SERVER_PATH = '/gridfs' } = process.env;
 const bufferToStream = (buffer) => {
     const stream = new Readable();
@@ -113,4 +111,3 @@ export const GridFSAdapter = {
         await Promise.all(files.map(async ({ _id, path }) => modules.gridfsFileUploads.removeFileFromBucket(path, _id)));
     },
 };
-FileDirector.registerAdapter(GridFSAdapter);

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

@@ -1,4 +1,5 @@
-import './adapter.ts';
-import gridfsModules, { type GridFSFileUploadsModule } from './module.ts';
-export type { GridFSFileUploadsModule };
-export default gridfsModules;
+import type { IPlugin } from '@unchainedshop/core';
+export declare const GridFSPlugin: IPlugin;
+export default GridFSPlugin;
+export { GridFSAdapter } from './adapter.ts';
+export { type GridFSFileUploadsModule } from './module.ts';

package/lib/files/gridfs/index.js

@@ -1,3 +1,30 @@
-import "./adapter.js";
-import gridfsModules, {} from "./module.js";
-export default gridfsModules;
+import { createLogger } from '@unchainedshop/logger';
+import { GridFSAdapter } from "./adapter.js";
+import { configureGridFSFileUploadModule } from "./module.js";
+import { gridfsRouteHandler } from "./api.js";
+const { GRIDFS_PUT_SERVER_PATH = '/gridfs', UNCHAINED_GRIDFS_PUT_UPLOAD_SECRET } = process.env;
+const logger = createLogger('unchained:gridfs');
+export const GridFSPlugin = {
+    key: 'shop.unchained.file-upload-plugin.gridfs',
+    label: 'GridFS File Upload Plugin',
+    version: '1.0.0',
+    adapters: [GridFSAdapter],
+    module: ({ db }) => ({
+        gridfsFileUploads: configureGridFSFileUploadModule({ db }),
+    }),
+    routes: [
+        {
+            path: `${GRIDFS_PUT_SERVER_PATH}/:directoryName/:fileName`,
+            method: 'ALL',
+            handler: gridfsRouteHandler,
+        },
+    ],
+    onRegister: () => {
+        if (!UNCHAINED_GRIDFS_PUT_UPLOAD_SECRET) {
+            logger.warn('UNCHAINED_GRIDFS_PUT_UPLOAD_SECRET not set - PUT uploads and signed downloads will fail');
+        }
+    },
+};
+export default GridFSPlugin;
+export { GridFSAdapter } from "./adapter.js";
+export {} from "./module.js";

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

package/lib/payment/cryptopay/index.js

@@ -1,3 +1,31 @@
-import "./plugin.js";
-import cryptopayModules, {} from "./module.js";
-export default cryptopayModules;
+import cryptopayModules from "./module.js";
+import { Cryptopay } from "./adapter.js";
+import { cryptopayWebhookHandler } from "./api.js";
+const { CRYPTOPAY_SECRET, CRYPTOPAY_BTC_XPUB, CRYPTOPAY_ETH_XPUB, CRYPTOPAY_WEBHOOK_PATH = '/payment/cryptopay', } = process.env;
+export const CryptopayPlugin = {
+    key: 'shop.unchained.payment.cryptopay',
+    label: 'Cryptopay Payment Plugin',
+    version: '1.0.0',
+    adapters: [Cryptopay],
+    module: ({ db }) => ({
+        cryptopay: cryptopayModules.cryptopay.configure({ db }),
+    }),
+    routes: [
+        {
+            path: CRYPTOPAY_WEBHOOK_PATH,
+            method: 'POST',
+            handler: cryptopayWebhookHandler,
+        },
+    ],
+    onRegister: () => {
+        if (!CRYPTOPAY_SECRET) {
+            throw new Error('CRYPTOPAY_SECRET not set');
+        }
+        if (!CRYPTOPAY_BTC_XPUB && !CRYPTOPAY_ETH_XPUB) {
+            throw new Error('No CRYPTOPAY_BTC_XPUB or CRYPTOPAY_ETH_XPUB set');
+        }
+    },
+};
+export default CryptopayPlugin;
+export { Cryptopay } from "./adapter.js";
+export {} from "./module.js";

package/lib/payment/datatrans-v2/index.d.ts

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