@unchainedshop/plugins 4.6.1 → 4.7.2

package/lib/files/gridfs/handler-fastify.js

@@ -1,138 +0,0 @@
-import { finished, pipeline } from 'node:stream/promises';
-import { PassThrough } from 'node:stream';
-import {} from 'fastify';
-import { buildHashedFilename } from '@unchainedshop/file-upload';
-import sign from "./sign.js";
-import {} from "./module.js";
-import {} from '@unchainedshop/api';
-import { createLogger } from '@unchainedshop/logger';
-import { getFileAdapter } from '@unchainedshop/core-files';
-import { timingSafeStringEqual } from '@unchainedshop/utils';
-const logger = createLogger('unchained:gridfs');
-const { GRIDFS_PUT_SERVER_PATH = '/gridfs' } = process.env;
-const gridfsHandler = async (req, reply) => {
-    try {
-        const { services, modules } = req.unchainedContext;
-        const { directoryName, fileName } = req.params;
-        reply.header('Access-Control-Allow-Methods', 'GET, PUT');
-        reply.header('Access-Control-Allow-Headers', 'content-type');
-        reply.header('Access-Control-Allow-Origin', '*');
-        if (req.method === 'OPTIONS') {
-            reply.status(200);
-            return reply.send();
-        }
-        if (req.method === 'PUT') {
-            const { s: signature, e: expiryTimestamp } = req.query;
-            const expiryDate = new Date(parseInt(expiryTimestamp, 10));
-            const fileId = await buildHashedFilename(directoryName, fileName, expiryDate);
-            const expectedSignature = await sign(directoryName, fileId, expiryDate.getTime());
-            if (await timingSafeStringEqual(expectedSignature, signature)) {
-                const file = await modules.files.findFile({ fileId });
-                if (!file) {
-                    reply.status(404);
-                    logger.error('File not found', { fileId });
-                    return reply.send({
-                        success: false,
-                        message: 'File not found',
-                        name: 'FILE_NOT_FOUND',
-                    });
-                }
-                if (file.expires === null) {
-                    reply.status(400);
-                    logger.error('File already linked', { fileId });
-                    return reply.send({
-                        success: false,
-                        message: 'File already linked',
-                        name: 'FILE_ALREADY_LINKED',
-                    });
-                }
-                const type = req.headers['content-type'] === 'application/octet-stream'
-                    ? file.type || req.headers['content-type']
-                    : req.headers['content-type'] || file.type;
-                const writeStream = await modules.gridfsFileUploads.createWriteStream(directoryName, fileId, fileName, {
-                    chunkSizeBytes: 1024 * 1024,
-                    metadata: { 'content-type': type },
-                });
-                await pipeline(req.raw, new PassThrough({ highWaterMark: 1024 * 1024 * 4 }), writeStream);
-                await finished(writeStream, { readable: false });
-                const { length } = writeStream;
-                await services.files.linkFile({ fileId, size: length, type });
-                reply.status(200);
-                return reply.send({
-                    success: true,
-                    fileId,
-                    size: length,
-                    type,
-                });
-            }
-            logger.error('Invalid signature', { fileId, expiryDate });
-            reply.status(403);
-            return reply.send({
-                success: false,
-                message: 'Access restricted: Invalid signature.',
-                name: 'INVALID_SIGNATURE',
-            });
-        }
-        if (req.method === 'GET') {
-            const { s: signature, e: expiryTimestamp } = req.query;
-            const fileDocument = await modules.files.findFile({
-                url: `${GRIDFS_PUT_SERVER_PATH}/${directoryName}/${fileName}`,
-            });
-            if (fileDocument?.meta?.isPrivate) {
-                const expiry = parseInt(expiryTimestamp, 10);
-                if (expiry <= Date.now()) {
-                    logger.error('URL Expired', { fileName, expiry });
-                    reply.status(403);
-                    return reply.send({
-                        success: false,
-                        message: 'Access restricted: URL expired.',
-                        name: 'URL_EXPIRED',
-                    });
-                }
-                const fileUploadAdapter = getFileAdapter();
-                const signedUrl = await fileUploadAdapter.createDownloadURL(fileDocument, expiry);
-                const expectedSignature = signedUrl ? new URL(signedUrl, 'file://').searchParams.get('s') : null;
-                if (!signedUrl ||
-                    !expectedSignature ||
-                    !(await timingSafeStringEqual(expectedSignature, signature))) {
-                    reply.status(403);
-                    logger.error('Invalid signature', { fileName, expiry });
-                    return reply.send({
-                        success: false,
-                        message: 'Access restricted: Invalid signature.',
-                        name: 'INVALID_SIGNATURE',
-                    });
-                }
-            }
-            else if (!fileDocument) {
-                logger.error('File not found', { fileName });
-                reply.status(404);
-                return reply.send();
-            }
-            const file = await modules.gridfsFileUploads.getFileInfo(directoryName, fileDocument._id);
-            if (file?.metadata?.['content-type']) {
-                reply.header('content-type', file.metadata['content-type']);
-            }
-            if (file?.length) {
-                reply.header('content-length', file?.length.toString());
-            }
-            const readStream = await modules.gridfsFileUploads.createReadStream(directoryName, fileDocument._id);
-            reply.status(200);
-            return reply.send(readStream);
-        }
-        reply.status(404);
-        return reply.send();
-    }
-    catch (e) {
-        logger.error(e);
-        if (e.code === 'ENOENT') {
-            reply.status(404);
-            return reply.send();
-        }
-        else {
-            reply.status(504);
-            return reply.send({ success: false, name: e.name, code: e.code, message: e.message });
-        }
-    }
-};
-export default gridfsHandler;

package/lib/files/minio/handler-express.d.ts

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

package/lib/files/minio/handler-express.js

@@ -1,36 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { timingSafeStringEqual } from '@unchainedshop/utils';
-const logger = createLogger('unchained:minio');
-const { MINIO_WEBHOOK_AUTH_TOKEN } = process.env;
-const isAuthorized = async ({ authorization = '' }) => {
-    if (!MINIO_WEBHOOK_AUTH_TOKEN)
-        return false;
-    const [type, token] = authorization.split(' ');
-    if (type !== 'Bearer' || !token)
-        return false;
-    return timingSafeStringEqual(token, MINIO_WEBHOOK_AUTH_TOKEN);
-};
-const minioHandler = async (req, res) => {
-    try {
-        if (req.method === 'POST' && req.body) {
-            const { headers } = req;
-            const { Records = [], EventName } = req.body;
-            if (EventName === 's3:ObjectCreated:Put' && (await isAuthorized(headers))) {
-                const [{ s3 }] = Records;
-                const { object } = s3;
-                const { size, contentType: type } = object;
-                const [fileId] = object.key.split('.');
-                const { services } = req.unchainedContext;
-                await services.files.linkFile({ fileId, type, size });
-                res.status(200).end();
-                return;
-            }
-        }
-        res.status(404).end();
-    }
-    catch (e) {
-        logger.error(e);
-        res.status(503).send({ name: e.name, code: e.code, message: e.message });
-    }
-};
-export default minioHandler;

package/lib/files/minio/handler-fastify.d.ts

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

package/lib/files/minio/handler-fastify.js

@@ -1,40 +0,0 @@
-import {} from '@unchainedshop/api';
-import { createLogger } from '@unchainedshop/logger';
-import {} from 'fastify';
-import { timingSafeStringEqual } from '@unchainedshop/utils';
-const logger = createLogger('unchained:minio');
-const { MINIO_WEBHOOK_AUTH_TOKEN } = process.env;
-const isAuthorized = async ({ authorization = '' }) => {
-    if (!MINIO_WEBHOOK_AUTH_TOKEN)
-        return false;
-    const [type, token] = authorization.split(' ');
-    if (type !== 'Bearer' || !token)
-        return false;
-    return timingSafeStringEqual(token, MINIO_WEBHOOK_AUTH_TOKEN);
-};
-const minioHandler = async (req, res) => {
-    try {
-        if (req.body) {
-            const { headers } = req;
-            const { Records = [], EventName } = req.body;
-            if (EventName === 's3:ObjectCreated:Put' && (await isAuthorized(headers))) {
-                const [{ s3 }] = Records;
-                const { object } = s3;
-                const { size, contentType: type } = object;
-                const [fileId] = object.key.split('.');
-                const { services } = req.unchainedContext;
-                await services.files.linkFile({ fileId, type, size });
-                res.status(200);
-                return res.send();
-            }
-        }
-        res.status(404);
-        return res.send();
-    }
-    catch (e) {
-        logger.error(e);
-        res.status(503);
-        return res.send({ name: e.name, code: e.code, message: e.message });
-    }
-};
-export default minioHandler;

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

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

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

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

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

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

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

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

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

package/lib/payment/braintree.d.ts

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

package/lib/payment/braintree.js

@@ -1,138 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { PaymentAdapter, PaymentDirector, PaymentError, OrderPricingSheet, } from '@unchainedshop/core';
-const logger = createLogger('unchained:braintree');
-const { BRAINTREE_SANDBOX_TOKEN, BRAINTREE_PRIVATE_KEY } = process.env;
-let braintree;
-try {
-    const braintreePackage = await import('braintree');
-    braintree = braintreePackage.default;
-}
-catch {
-    logger.warn("npm dependency 'braintree' is not installed, paypal adapter will not work");
-}
-const BraintreeDirect = {
-    ...PaymentAdapter,
-    key: 'shop.unchained.braintree-direct',
-    label: 'Braintree Direct',
-    version: '1.0.0',
-    initialConfiguration: [
-        {
-            key: 'publicKey',
-            value: null,
-        },
-        {
-            key: 'merchantId',
-            value: null,
-        },
-    ],
-    typeSupported: (type) => {
-        return type === 'GENERIC';
-    },
-    actions: (config, context) => {
-        const getPublicKey = () => {
-            return config.reduce((current, item) => {
-                if (item.key === 'publicKey')
-                    return item.value;
-                return current;
-            }, null);
-        };
-        const getMerchantId = () => {
-            return config.reduce((current, item) => {
-                if (item.key === 'merchantId')
-                    return item.value;
-                return current;
-            }, null);
-        };
-        const getAccessToken = () => {
-            return BRAINTREE_SANDBOX_TOKEN;
-        };
-        const getPrivateKey = () => {
-            return BRAINTREE_PRIVATE_KEY;
-        };
-        const getGateway = (braintree) => {
-            const accessToken = getAccessToken();
-            if (accessToken) {
-                return braintree.connect({
-                    accessToken,
-                });
-            }
-            return braintree.connect({
-                environment: braintree.Environment.Production,
-                merchantId: getMerchantId(),
-                publicKey: getPublicKey(),
-                privateKey: getPrivateKey(),
-            });
-        };
-        const adapter = {
-            ...PaymentAdapter.actions(config, context),
-            configurationError: () => {
-                const publicCredentialsValid = getAccessToken() || (getMerchantId() && getPublicKey() && getPrivateKey());
-                if (!publicCredentialsValid) {
-                    return PaymentError.WRONG_CREDENTIALS;
-                }
-                return null;
-            },
-            isActive: () => {
-                if (adapter.configurationError() === null)
-                    return true;
-                return false;
-            },
-            isPayLaterAllowed: () => {
-                return false;
-            },
-            sign: async () => {
-                const gateway = getGateway(braintree);
-                const result = await gateway.clientToken.generate({});
-                if (result.success) {
-                    return result.clientToken;
-                }
-                throw new Error('Could not retrieve the client token');
-            },
-            charge: async ({ paypalPaymentMethodNonce }) => {
-                const { order } = context;
-                if (!order)
-                    throw new Error('Order is missing in payment context');
-                if (!paypalPaymentMethodNonce)
-                    throw new Error('You have to provide paypalPaymentMethodNonce in paymentContext');
-                const gateway = getGateway(braintree);
-                const address = order.billingAddress;
-                const pricing = OrderPricingSheet({
-                    calculation: order.calculation,
-                    currencyCode: order.currencyCode,
-                });
-                const rounded = Math.round(pricing.total({ useNetPrice: false }).amount / 10 || 0) * 10;
-                const saleRequest = {
-                    amount: rounded / 100,
-                    merchantAccountId: order.currencyCode,
-                    paymentMethodNonce: paypalPaymentMethodNonce,
-                    orderId: order.orderNumber || order._id,
-                    shipping: address
-                        ? {
-                            firstName: address.firstName,
-                            lastName: address.lastName,
-                            company: address.company,
-                            streetAddress: address.addressLine,
-                            extendedAddress: address.addressLine2,
-                            locality: address.city,
-                            region: address.regionCode,
-                            postalCode: address.postalCode,
-                            countryCodeAlpha2: address.countryCode,
-                        }
-                        : undefined,
-                    options: {
-                        submitForSettlement: true,
-                    },
-                };
-                const result = await gateway.transaction.sale(saleRequest);
-                if (result.success) {
-                    logger.info(`Braintree Plugin: ${result.message}`, saleRequest);
-                    return result;
-                }
-                logger.warn(`Braintree Plugin: ${result.message}`, saleRequest);
-                throw new Error(result.message);
-            },
-        };
-        return adapter;
-    },
-};
-PaymentDirector.registerAdapter(BraintreeDirect);

package/lib/payment/cryptopay/handler-express.d.ts

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

package/lib/payment/cryptopay/handler-express.js

@@ -1,19 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import handleWebhook from "./handle-webhook.js";
-const logger = createLogger('unchained:cryptopay:handler');
-const cryptopayHandler = async (req, res) => {
-    if (req.method === 'POST') {
-        try {
-            await handleWebhook(req.body, req.unchainedContext);
-            res.status(200).send({ success: true });
-            return;
-        }
-        catch (e) {
-            logger.error(e);
-            res.status(500).send({ success: false, error: e.message });
-            return;
-        }
-    }
-    res.status(404).send();
-};
-export default cryptopayHandler;

package/lib/payment/cryptopay/handler-fastify.d.ts

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

package/lib/payment/cryptopay/handler-fastify.js

@@ -1,17 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import handleWebhook from "./handle-webhook.js";
-import {} from 'fastify';
-const logger = createLogger('unchained:cryptopay:handler');
-const cryptopayHandler = async (req, reply) => {
-    try {
-        await handleWebhook(req.body, req.unchainedContext);
-        reply.status(200);
-        return reply.send({ success: true });
-    }
-    catch (e) {
-        logger.error(e);
-        reply.status(500);
-        return reply.send({ success: false, error: e.message });
-    }
-};
-export default cryptopayHandler;

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

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

package/lib/payment/datatrans-v2/handler-express.d.ts

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

package/lib/payment/datatrans-v2/handler-express.js

@@ -1,71 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import generateSignature, { Security } from "./generateSignature.js";
-const { DATATRANS_SIGN_KEY, DATATRANS_SIGN2_KEY, DATATRANS_SECURITY = Security.DYNAMIC_SIGN, } = process.env;
-const logger = createLogger('unchained:datatrans:handler');
-export const datatransHandler = async (req, res) => {
-    const resolvedContext = req.unchainedContext;
-    const { modules, services } = resolvedContext;
-    const signature = req.headers['datatrans-signature'];
-    if (!DATATRANS_SIGN_KEY && !DATATRANS_SIGN2_KEY) {
-        logger.warn('No sign key configured');
-        res.status(404).end();
-        return;
-    }
-    if (req.method === 'POST' && signature) {
-        const [rawTimestamp, rawHash] = signature.split(',');
-        const [, hash] = rawHash.split('=');
-        const [, timestamp] = rawTimestamp.split('=');
-        const comparableSignature = await generateSignature({
-            security: DATATRANS_SECURITY,
-            signKey: DATATRANS_SIGN2_KEY || DATATRANS_SIGN_KEY,
-        })(timestamp, req.body);
-        if (hash !== comparableSignature) {
-            logger.error(`hash mismatch: ${signature} / ${comparableSignature}`);
-            res.status(403).send('Hash mismatch');
-            return;
-        }
-        const transaction = JSON.parse(req.body);
-        logger.info(`received request`, {
-            type: transaction.type,
-        });
-        if (transaction.status === 'authorized') {
-            const userId = transaction.refno2;
-            const referenceId = Buffer.from(transaction.refno, 'base64').toString('hex');
-            try {
-                if (transaction.type === 'card_check') {
-                    const paymentProviderId = referenceId;
-                    const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, { userId, transactionContext: { transactionId: transaction.transactionId } });
-                    logger.info(`registered payment credentials for ${userId}`, {
-                        userId,
-                    });
-                    res.status(200).send(paymentCredentials);
-                    return;
-                }
-                if (transaction.type === 'payment') {
-                    const orderPaymentId = referenceId;
-                    const orderPayment = await modules.orders.payments.findOrderPayment({
-                        orderPaymentId,
-                    });
-                    if (!orderPayment)
-                        throw new Error(`Order Payment with id ${orderPaymentId} not found`);
-                    const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-                        paymentContext: { userId, transactionId: transaction.transactionId },
-                    });
-                    if (!order)
-                        throw new Error(`Order with id ${orderPayment.orderId} not found`);
-                    logger.info(`confirmed checkout for order ${order.orderNumber}`, {
-                        orderId: order._id,
-                    });
-                    res.status(200).send(order);
-                    return;
-                }
-            }
-            catch (e) {
-                logger.error(`rejected to checkout: ${e.name} - ${e.message}`);
-                res.status(500).send({ name: e.name, code: e.code, message: e.message });
-                return;
-            }
-        }
-    }
-    res.status(404).end();
-};

package/lib/payment/datatrans-v2/handler-fastify.d.ts

@@ -1,2 +0,0 @@
-import type { RouteHandlerMethod } from 'fastify';
-export declare const datatransHandler: RouteHandlerMethod;