@unchainedshop/plugins 4.7.2 → 4.8.1

package/lib/files/minio/index.js

@@ -1,25 +1,164 @@
+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_WEBHOOK_AUTH_TOKEN, MINIO_WEBHOOK_PATH = '/minio/webhook' } = process.env;
-export const MinioPlugin = {
+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 = {
     key: 'shop.unchained.file-upload-plugin.minio',
-    label: 'Minio/S3 File Upload Plugin with Webhook',
+    label: 'Uploads files into an S3 bucket using minio',
     version: '1.1.0',
-    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');
+    ...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'));
         }
+        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;
     },
 };
-export default MinioPlugin;
-export { MinioAdapter, connectToMinio } from "./adapter.js";
+FileDirector.registerAdapter(MinioAdapter);
+export default MinioAdapter;

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

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

package/lib/filters/local-search.js

@@ -0,0 +1,66 @@
+import { FilterDirector, FilterAdapter } from '@unchainedshop/core';
+import { createLogger } from '@unchainedshop/logger';
+import { isDocumentDBCompatModeEnabled } from '@unchainedshop/mongodb';
+const logger = createLogger('unchained:local-search');
+const LocalSearch = {
+    ...FilterAdapter,
+    key: 'shop.unchained.filters.local-search',
+    label: 'Simple Fulltext search with MongoDB',
+    version: '1.0.0',
+    orderIndex: 10,
+    actions: (params) => {
+        return {
+            ...FilterAdapter.actions(params),
+            searchProducts: async ({ productIds }) => {
+                const { queryString } = params.searchQuery;
+                if (!queryString)
+                    return productIds;
+                const products = await params.modules.products.texts.findTexts({
+                    queryString,
+                    productIds: productIds ? [...new Set(productIds)] : undefined,
+                }, {
+                    projection: {
+                        productId: 1,
+                    },
+                });
+                return products.map(({ productId }) => productId);
+            },
+            searchAssortments: async ({ assortmentIds }) => {
+                const { queryString } = params.searchQuery;
+                if (!queryString) {
+                    return assortmentIds;
+                }
+                const assortments = await params.modules.assortments.texts.findTexts({
+                    queryString,
+                    assortmentIds,
+                }, {
+                    projection: {
+                        assortmentId: 1,
+                    },
+                });
+                return assortments.map(({ assortmentId }) => assortmentId);
+            },
+            async transformFilterSelector(last) {
+                const { queryString, filterIds, includeInactive } = params.searchQuery;
+                if (queryString && !filterIds) {
+                    const selector = { ...last };
+                    if (selector?.key) {
+                        delete selector.key;
+                    }
+                    if (!includeInactive) {
+                        selector.isActive = true;
+                    }
+                    return selector;
+                }
+                return last;
+            },
+        };
+    },
+};
+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/strict-equal.d.ts

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

package/lib/filters/strict-equal.js

@@ -0,0 +1,24 @@
+import { FilterDirector, FilterAdapter } from '@unchainedshop/core';
+const StrictQualFilter = {
+    ...FilterAdapter,
+    key: 'shop.unchained.filters.strict-qual',
+    label: 'Simple Strict Equal DB Filter',
+    version: '1.0.0',
+    orderIndex: 0,
+    actions: (params) => {
+        return {
+            ...FilterAdapter.actions(params),
+            transformProductSelector: async (lastSelector, options) => {
+                const { key, value } = options || {};
+                if (key) {
+                    return {
+                        ...lastSelector,
+                        [key]: value !== undefined ? value : { $exists: true },
+                    };
+                }
+                return lastSelector;
+            },
+        };
+    },
+};
+FilterDirector.registerAdapter(StrictQualFilter);

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

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

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

@@ -1,10 +1,10 @@
-import { PaymentAdapter, PaymentError } from '@unchainedshop/core';
+import { PaymentAdapter, PaymentDirector, 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;
-export const AppleIAP = {
+const AppleIAP = {
     ...PaymentAdapter,
     key: 'shop.unchained.apple-iap',
     label: 'Apple In-App-Purchase',
@@ -111,3 +111,4 @@ export const AppleIAP = {
         return adapterActions;
     },
 };
+PaymentDirector.registerAdapter(AppleIAP);

package/lib/payment/apple-iap/handler-express.d.ts

@@ -0,0 +1,2 @@
+export declare const appleIAPHandler: (req: any, res: any) => Promise<void>;
+export default appleIAPHandler;

package/lib/payment/apple-iap/handler-express.js

@@ -0,0 +1,103 @@
+import {} from '@unchainedshop/api';
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { createLogger } from '@unchainedshop/logger';
+import { fixPeriods } from "./fix-periods.js";
+const logger = createLogger('unchained:apple-iap:handler');
+const { APPLE_IAP_SHARED_SECRET } = process.env;
+const AppleNotificationTypes = {
+    INITIAL_BUY: 'INITIAL_BUY',
+    DID_RECOVER: 'DID_RECOVER',
+    DID_CHANGE_RENEWAL_STATUS: 'DID_CHANGE_RENEWAL_STATUS',
+    DID_FAIL_TO_RENEW: 'DID_FAIL_TO_RENEW',
+    DID_CHANGE_RENEWAL_PREF: 'DID_CHANGE_RENEWAL_PREF',
+};
+export const appleIAPHandler = async (req, res) => {
+    if (req.method === 'POST') {
+        try {
+            const resolvedContext = req.unchainedContext;
+            const { modules, services } = resolvedContext;
+            const responseBody = req.body || {};
+            if (responseBody.password !== APPLE_IAP_SHARED_SECRET) {
+                throw new Error('shared secret not valid');
+            }
+            const transactions = responseBody?.unified_receipt?.latest_receipt_info;
+            const latestTransaction = transactions[0];
+            if (responseBody.notification_type === AppleNotificationTypes.INITIAL_BUY) {
+                const orderPayment = await modules.orders.payments.findOrderPaymentByTransactionId(latestTransaction.transaction_id);
+                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)
+                    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('Could not find any matching enrollment');
+                await fixPeriods({
+                    transactionId: latestTransaction.original_transaction_id,
+                    transactions,
+                    enrollmentId: enrollment._id,
+                    orderId,
+                }, resolvedContext);
+                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)
+                    throw new Error('Could not find any matching order payment');
+                const originalOrder = await modules.orders.findOrder({
+                    orderId: originalOrderPayment.orderId,
+                });
+                const enrollment = originalOrder &&
+                    (await modules.enrollments.findEnrollment({
+                        orderId: originalOrder._id,
+                    }));
+                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,
+                    },
+                    userId: enrollment.userId,
+                });
+                await fixPeriods({
+                    transactionId: latestTransaction.original_transaction_id,
+                    transactions,
+                    enrollmentId: enrollment._id,
+                    orderId: originalOrder._id,
+                }, resolvedContext);
+                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') {
+                        await services.enrollments.terminateEnrollment(enrollment);
+                    }
+                }
+                if (responseBody.notification_type === AppleNotificationTypes.DID_CHANGE_RENEWAL_STATUS) {
+                    if (enrollment.status !== EnrollmentStatus.TERMINATED &&
+                        responseBody.auto_renew_status === 'false') {
+                        await services.enrollments.terminateEnrollment(enrollment);
+                    }
+                }
+                logger.info(`Apple IAP Webhook: Updated enrollment from Apple`);
+            }
+            res.status(200).end();
+            return;
+        }
+        catch (e) {
+            logger.warn(`Apple IAP Webhook: ${e.name} - ${e.message}`);
+            res.status(503).send({ name: e.name, code: e.code, message: e.message });
+            return;
+        }
+    }
+    res.status(404).end();
+};
+export default appleIAPHandler;

package/lib/payment/apple-iap/handler-fastify.d.ts

@@ -0,0 +1,3 @@
+import { type RouteHandlerMethod } from 'fastify';
+export declare const appleIAPHandler: RouteHandlerMethod;
+export default appleIAPHandler;

package/lib/payment/apple-iap/handler-fastify.js

@@ -0,0 +1,102 @@
+import {} from '@unchainedshop/api';
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { createLogger } from '@unchainedshop/logger';
+import { fixPeriods } from "./fix-periods.js";
+import {} from 'fastify';
+import {} from "./module.js";
+const logger = createLogger('unchained:apple-iap:handler');
+const { APPLE_IAP_SHARED_SECRET } = process.env;
+const AppleNotificationTypes = {
+    INITIAL_BUY: 'INITIAL_BUY',
+    DID_RECOVER: 'DID_RECOVER',
+    DID_CHANGE_RENEWAL_STATUS: 'DID_CHANGE_RENEWAL_STATUS',
+    DID_FAIL_TO_RENEW: 'DID_FAIL_TO_RENEW',
+    DID_CHANGE_RENEWAL_PREF: 'DID_CHANGE_RENEWAL_PREF',
+};
+export const appleIAPHandler = async (req, reply) => {
+    try {
+        const resolvedContext = req.unchainedContext;
+        const { modules, services } = resolvedContext;
+        const responseBody = req.body || {};
+        if (responseBody.password !== APPLE_IAP_SHARED_SECRET) {
+            throw new Error('shared secret not valid');
+        }
+        const transactions = responseBody?.unified_receipt?.latest_receipt_info;
+        const latestTransaction = transactions[0];
+        if (responseBody.notification_type === AppleNotificationTypes.INITIAL_BUY) {
+            const orderPayment = await modules.orders.payments.findOrderPaymentByTransactionId(latestTransaction.transaction_id);
+            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)
+                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');
+            await fixPeriods({
+                transactionId: latestTransaction.original_transaction_id,
+                transactions,
+                enrollmentId: enrollment._id,
+                orderId,
+            }, resolvedContext);
+            logger.info(`Webhook confirmed checkout for order ${order.orderNumber}`, {
+                orderId: order._id,
+            });
+        }
+        else {
+            const originalOrderPayment = await modules.orders.payments.findOrderPaymentByTransactionId(latestTransaction.original_transaction_id);
+            if (!originalOrderPayment)
+                throw new Error('Could not find any matching order payment');
+            const originalOrder = await modules.orders.findOrder({
+                orderId: originalOrderPayment.orderId,
+            });
+            const enrollment = originalOrder &&
+                (await modules.enrollments.findEnrollment({
+                    orderId: originalOrder._id,
+                }));
+            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,
+                },
+                userId: enrollment.userId,
+            });
+            await fixPeriods({
+                transactionId: latestTransaction.original_transaction_id,
+                transactions,
+                enrollmentId: enrollment._id,
+                orderId: originalOrder._id,
+            }, resolvedContext);
+            logger.info(`Webhook rocessed 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') {
+                    await services.enrollments.terminateEnrollment(enrollment);
+                }
+            }
+            if (responseBody.notification_type === AppleNotificationTypes.DID_CHANGE_RENEWAL_STATUS) {
+                if (enrollment.status !== EnrollmentStatus.TERMINATED &&
+                    responseBody.auto_renew_status === 'false') {
+                    await services.enrollments.terminateEnrollment(enrollment);
+                }
+            }
+            logger.info(`Apple IAP Webhook: Updated enrollment from Apple`);
+        }
+        reply.status(200);
+        return reply.send();
+    }
+    catch (e) {
+        logger.error(e);
+        reply.status(503);
+        return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
+    }
+};
+export default appleIAPHandler;

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

@@ -1,6 +1,4 @@
-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 };
+export * from './adapter.ts';
+import appleTransactionsModule, { type AppleTransactionsModule } from './module.ts';
+export type { AppleTransactionsModule };
+export default appleTransactionsModule;

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

@@ -1,28 +1,3 @@
-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 {};
+export * from "./adapter.js";
+import appleTransactionsModule, {} from "./module.js";
+export default appleTransactionsModule;

package/lib/payment/braintree.d.ts

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