@unchainedshop/plugins 4.6.1 → 4.6.2

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/adapter.js

@@ -0,0 +1,56 @@
+import { FilterAdapter } from '@unchainedshop/core';
+export 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;
+            },
+        };
+    },
+};

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/adapter.js

@@ -0,0 +1,23 @@
+import { FilterAdapter } from '@unchainedshop/core';
+export 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;
+            },
+        };
+    },
+};

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/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/api.js

@@ -0,0 +1,119 @@
+import { createLogger } from '@unchainedshop/logger';
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { fixPeriods } from "./fix-periods.js";
+const logger = createLogger('unchained:apple-iap');
+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 async function appleIAPWebhookHandler(request, context) {
+    try {
+        const { modules, services } = context;
+        const responseBody = await request.json();
+        if (responseBody.password !== APPLE_IAP_SHARED_SECRET) {
+            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];
+        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) {
+                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,
+            }, 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) {
+                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,
+            }, 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') {
+                    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');
+        }
+        return new Response(null, { status: 200 });
+    }
+    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' },
+        });
+    }
+}

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/adapter.js

@@ -0,0 +1,157 @@
+import { PaymentAdapter, PaymentError, OrderPricingSheet, } from '@unchainedshop/core';
+import { createLogger } from '@unchainedshop/logger';
+import {} from "./module.js";
+import deriveBtcAddress from "./derive-btc-address.js";
+import deriveEthAddress from "./derive-eth-address.js";
+import denoteAmount from "./denote-amount.js";
+const logger = createLogger('unchained:cryptopay');
+const { CRYPTOPAY_SECRET, CRYPTOPAY_BTC_XPUB, CRYPTOPAY_ETH_XPUB } = process.env;
+const CryptopayCurrencies = {
+    BTC: 'BTC',
+    ETH: 'ETH',
+};
+export const Cryptopay = {
+    ...PaymentAdapter,
+    key: 'shop.unchained.payment.cryptopay',
+    label: 'Cryptopay',
+    version: '1.0.0',
+    typeSupported(type) {
+        return type === 'GENERIC';
+    },
+    actions: (config, context) => {
+        const { modules } = context;
+        const setConversionRates = async (currencyCode, existingAddresses) => {
+            const originCurrencyObj = await modules.currencies.findCurrency({ isoCode: currencyCode });
+            if (!originCurrencyObj?.isActive)
+                throw new Error('Origin currency is not supported');
+            const updatedAddresses = await Promise.all(existingAddresses.map(async (addressData) => {
+                const targetCurrencyObj = await modules.currencies.findCurrency({
+                    isoCode: addressData.currencyCode,
+                });
+                if (!targetCurrencyObj?.isActive)
+                    return null;
+                const rateData = await modules.products.prices.rates.getRate(originCurrencyObj, targetCurrencyObj);
+                return {
+                    ...addressData,
+                    currencyConversionRate: rateData?.rate,
+                    currencyConversionExpiryDate: rateData?.expiresAt,
+                };
+            }));
+            return updatedAddresses.filter(Boolean);
+        };
+        const updateTransactionsWithOrderPaymentId = async (orderPaymentId, cryptoAddresses) => {
+            for (const cryptoAddress of cryptoAddresses) {
+                const { address, currencyCode } = cryptoAddress;
+                await modules.cryptopay.mapOrderPaymentToWalletAddress({
+                    address,
+                    currencyCode,
+                    orderPaymentId,
+                });
+            }
+        };
+        const adapterActions = {
+            ...PaymentAdapter.actions(config, context),
+            configurationError() {
+                if (!CRYPTOPAY_SECRET) {
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                }
+                if (!CRYPTOPAY_BTC_XPUB && !CRYPTOPAY_ETH_XPUB) {
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                }
+                return null;
+            },
+            isActive() {
+                if (adapterActions.configurationError() !== null)
+                    return false;
+                if (!context.order)
+                    return true;
+                return true;
+            },
+            isPayLaterAllowed() {
+                return false;
+            },
+            sign: async () => {
+                const { orderPayment, order } = context;
+                if (!orderPayment)
+                    throw new Error('Payment Credential Registration is not yet supported for Cryptopay');
+                if (!order)
+                    throw new Error('Order context is required for signing with Cryptopay');
+                const existingAddresses = await modules.cryptopay.getWalletAddressesByOrderPaymentId(orderPayment._id);
+                if (existingAddresses.length) {
+                    const existingAddressesWithNewExpiration = await setConversionRates(order.currencyCode, existingAddresses.map(({ _id, currencyCode }) => ({
+                        address: _id,
+                        currencyCode,
+                    })));
+                    return JSON.stringify(existingAddressesWithNewExpiration);
+                }
+                const cryptoAddresses = [];
+                if (CRYPTOPAY_BTC_XPUB) {
+                    const btcDerivationNumber = await modules.cryptopay.getNextDerivationNumber(CryptopayCurrencies.BTC);
+                    const address = deriveBtcAddress(CRYPTOPAY_BTC_XPUB, btcDerivationNumber);
+                    cryptoAddresses.push({
+                        currencyCode: CryptopayCurrencies.BTC,
+                        address,
+                    });
+                }
+                if (CRYPTOPAY_ETH_XPUB) {
+                    const ethDerivationNumber = await modules.cryptopay.getNextDerivationNumber(CryptopayCurrencies.ETH);
+                    const address = deriveEthAddress(CRYPTOPAY_ETH_XPUB, ethDerivationNumber);
+                    cryptoAddresses.push({
+                        currencyCode: CryptopayCurrencies.ETH,
+                        address,
+                    });
+                }
+                const cryptoAddressesWithExpiration = await setConversionRates(order.currencyCode, cryptoAddresses);
+                await updateTransactionsWithOrderPaymentId(orderPayment._id, cryptoAddresses);
+                return JSON.stringify(cryptoAddressesWithExpiration);
+            },
+            charge: async () => {
+                const { order, orderPayment } = context;
+                if (!orderPayment)
+                    throw new Error('Order Payment context is required for charging with Cryptopay');
+                if (!order)
+                    throw new Error('Order context is required for charging with Cryptopay');
+                const foundWalletsWithBalances = await modules.cryptopay.getWalletAddressesByOrderPaymentId(orderPayment._id);
+                const walletForOrderPayment = foundWalletsWithBalances.find((wallet) => BigInt(wallet.amount.toString()) > 0n);
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const totalAmount = BigInt(pricing?.total({ useNetPrice: false }).amount);
+                if (walletForOrderPayment && walletForOrderPayment.currencyCode !== order.currencyCode) {
+                    const baseCurrency = await modules.currencies.findCurrency({
+                        isoCode: walletForOrderPayment.currencyCode,
+                    });
+                    if (!baseCurrency)
+                        throw new Error('Base currency not found');
+                    const quoteCurrency = await modules.currencies.findCurrency({ isoCode: order.currencyCode });
+                    if (!quoteCurrency)
+                        throw new Error('Quote currency not found');
+                    const rate = await modules.products.prices.rates.getRateRange(baseCurrency, quoteCurrency, order.confirmed || new Date());
+                    if (!rate)
+                        throw new Error('No conversion rate found');
+                    const convertedAmount = denoteAmount(walletForOrderPayment.amount.toString(), walletForOrderPayment.decimals);
+                    const maxAmount = parseFloat(convertedAmount.toString()) * rate.max * 1.001;
+                    if (maxAmount && maxAmount >= totalAmount) {
+                        return {
+                            transactionId: walletForOrderPayment._id,
+                        };
+                    }
+                    logger.info(`Cryptopay Plugin: Wallet ${walletForOrderPayment._id} balance too low (yet): ${maxAmount} < ${totalAmount}`);
+                }
+                if (walletForOrderPayment) {
+                    const convertedAmount = denoteAmount(walletForOrderPayment.amount.toString(), walletForOrderPayment.decimals);
+                    if (convertedAmount && convertedAmount >= totalAmount) {
+                        return {
+                            transactionId: walletForOrderPayment._id,
+                        };
+                    }
+                    logger.info(`Cryptopay Plugin: Wallet ${walletForOrderPayment._id} balance too low (yet): ${convertedAmount} < ${totalAmount}`);
+                }
+                logger.info(`Cryptopay Plugin: No confirmed payments found for currency ${order.currencyCode} and addresses ${JSON.stringify(foundWalletsWithBalances)}`);
+                return false;
+            },
+        };
+        return adapterActions;
+    },
+};

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/datatrans-v2/adapter.d.ts

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