@unchainedshop/plugins 4.8.26 → 4.8.27

package/lib/payment/stripe/adapter.js

@@ -0,0 +1,121 @@
+import { createLogger } from '@unchainedshop/logger';
+import { stripe, createOrderPaymentIntent, createRegistrationIntent } from "./stripe.js";
+import { OrderPricingSheet, PaymentAdapter, PaymentError, } from '@unchainedshop/core';
+const logger = createLogger('unchained:stripe');
+export const Stripe = {
+    ...PaymentAdapter,
+    key: 'shop.unchained.payment.stripe',
+    label: 'Stripe',
+    version: '2.0.0',
+    typeSupported(type) {
+        return type === 'GENERIC';
+    },
+    actions: (config, context) => {
+        const { modules } = context;
+        const descriptorPrefix = config.find(({ key }) => key === 'descriptorPrefix')?.value || '';
+        const assertUserData = async (forcedUserId) => {
+            const userId = forcedUserId || context?.userId;
+            const user = await modules.users.findUserById(userId);
+            if (!user)
+                throw new Error('User not found');
+            const email = modules.users.primaryEmail(user)?.address;
+            const name = user.profile?.displayName || user.username || email;
+            return {
+                email,
+                name,
+                userId,
+            };
+        };
+        const adapterActions = {
+            ...PaymentAdapter.actions(config, context),
+            configurationError() {
+                if (!stripe)
+                    return PaymentError.INCOMPLETE_CONFIGURATION;
+                return null;
+            },
+            isActive: () => {
+                if (adapterActions.configurationError() === null)
+                    return true;
+                return false;
+            },
+            isPayLaterAllowed() {
+                return false;
+            },
+            validate: async ({ token }) => {
+                const paymentMethod = await stripe.paymentMethods.retrieve(token);
+                return !!paymentMethod;
+            },
+            register: async ({ setupIntentId }) => {
+                if (!setupIntentId) {
+                    throw new Error('You have to provide a setupIntentId');
+                }
+                const setupIntent = await stripe.setupIntents.retrieve(setupIntentId);
+                if (setupIntent.status === 'succeeded') {
+                    return {
+                        token: setupIntent.payment_method,
+                        customer: setupIntent.customer,
+                        payment_method_types: setupIntent.payment_method_types,
+                        usage: setupIntent.usage,
+                    };
+                }
+                logger.warn('Registration declined', setupIntentId);
+                return null;
+            },
+            sign: async (transactionContext = {}) => {
+                const { orderPayment, order, paymentProvider } = context;
+                const { userId, name, email } = await assertUserData(order?.userId);
+                if (orderPayment) {
+                    if (!order)
+                        throw new Error('order not found in context');
+                    const pricing = OrderPricingSheet({
+                        calculation: order?.calculation,
+                        currencyCode: order?.currencyCode,
+                    });
+                    const paymentIntent = await createOrderPaymentIntent({ userId, name, email, order, orderPayment, pricing, descriptorPrefix }, transactionContext);
+                    return paymentIntent.client_secret;
+                }
+                const paymentIntent = await createRegistrationIntent({ userId, name, email, paymentProviderId: paymentProvider._id, descriptorPrefix }, transactionContext);
+                return paymentIntent.client_secret;
+            },
+            charge: async ({ paymentIntentId, paymentCredentials }) => {
+                if (!paymentIntentId && !paymentCredentials) {
+                    throw new Error('You have to provide paymentIntentId or paymentCredentials');
+                }
+                const { order, orderPayment } = context;
+                if (!order)
+                    throw new Error('order not found in context');
+                if (!orderPayment)
+                    throw new Error('orderPayment not found in context');
+                const { userId, name, email } = await assertUserData(order?.userId);
+                const pricing = OrderPricingSheet({
+                    calculation: order.calculation,
+                    currencyCode: order.currencyCode,
+                });
+                const paymentIntentObject = paymentIntentId
+                    ? await stripe.paymentIntents.retrieve(paymentIntentId)
+                    : await createOrderPaymentIntent({ userId, name, email, orderPayment, order, pricing, descriptorPrefix }, {
+                        customer: paymentCredentials.meta?.customer,
+                        confirm: true,
+                        payment_method: paymentCredentials.token,
+                        payment_method_types: paymentCredentials.meta?.payment_method_types,
+                    });
+                const { currencyCode, amount } = pricing.total({ useNetPrice: false });
+                if (paymentIntentObject.currency !== currencyCode.toLowerCase() ||
+                    paymentIntentObject.amount !== Math.round(amount)) {
+                    throw new Error('The price has changed since the intent has been created');
+                }
+                if (paymentIntentObject.metadata?.orderPaymentId !== orderPayment?._id) {
+                    throw new Error('The order payment is different from the initiating intent');
+                }
+                if (paymentIntentObject.status === 'succeeded') {
+                    return paymentIntentObject;
+                }
+                logger.info('Charge postponed because paymentIntent has wrong status', {
+                    orderPaymentId: paymentIntentObject.id,
+                });
+                return false;
+            },
+        };
+        return adapterActions;
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+export declare const WebhookEventTypes: {
+    PAYMENT_INTENT_SUCCEEDED: string;
+    SETUP_INTENT_SUCCEEDED: string;
+};
+export declare function stripeWebhookHandler(request: Request, context: UnchainedCore): Promise<Response>;

package/lib/payment/stripe/api.js

@@ -0,0 +1,165 @@
+import { createLogger } from '@unchainedshop/logger';
+import { stripe } from "./stripe.js";
+const logger = createLogger('unchained:stripe:handler');
+export const WebhookEventTypes = {
+    PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
+    SETUP_INTENT_SUCCEEDED: 'setup_intent.succeeded',
+};
+export async function stripeWebhookHandler(request, context) {
+    try {
+        const { modules, services } = context;
+        const sig = request.headers.get('stripe-signature');
+        if (!sig) {
+            logger.error('stripe-signature header was not provided for webhook');
+            return new Response(JSON.stringify({
+                success: false,
+                message: 'stripe-signature header was not provided for webhook',
+                name: 'MISSING_SIGNATURE',
+            }), {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        if (!process.env.STRIPE_ENDPOINT_SECRET) {
+            logger.error('env STRIPE_ENDPOINT_SECRET is required for webhook handling');
+            return new Response(JSON.stringify({
+                success: false,
+                message: 'env STRIPE_ENDPOINT_SECRET is required for webhook handling',
+                name: 'MISSING_ENDPOINT_SECRET',
+            }), {
+                status: 500,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        const rawBody = await request.text();
+        let event;
+        try {
+            event = stripe.webhooks.constructEvent(rawBody, sig, process.env.STRIPE_ENDPOINT_SECRET);
+        }
+        catch (err) {
+            logger.error(`Error constructing event: ${err.message}`);
+            return new Response(JSON.stringify({
+                success: false,
+                message: err.message,
+                name: err.name || 'SIGNATURE_VERIFICATION_FAILED',
+            }), {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        if (!Object.values(WebhookEventTypes).includes(event.type)) {
+            logger.info(`unhandled event type`, {
+                type: event.type,
+            });
+            return new Response(JSON.stringify({
+                success: false,
+                ignored: true,
+                name: 'UNHANDLED_EVENT_TYPE',
+                message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
+            }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        const environmentInMetadata = event.data?.object?.metadata?.environment || '';
+        const environmentInEnv = process.env.STRIPE_WEBHOOK_ENVIRONMENT || '';
+        if (environmentInMetadata !== environmentInEnv) {
+            logger.info(`unhandled event environment`, {
+                type: event.type,
+                environment: environmentInMetadata,
+            });
+            return new Response(JSON.stringify({
+                success: false,
+                ignored: true,
+                name: 'UNHANDLED_EVENT_ENVIRONMENT',
+                message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
+            }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        logger.info(`Processing event`, {
+            type: event.type,
+        });
+        if (event.type === WebhookEventTypes.PAYMENT_INTENT_SUCCEEDED) {
+            const paymentIntent = event.data.object;
+            const { orderPaymentId } = paymentIntent.metadata || {};
+            logger.info(`checkout with orderPaymentId: ${orderPaymentId}`, {
+                type: event.type,
+            });
+            await modules.orders.payments.logEvent(orderPaymentId, event);
+            const orderPayment = await modules.orders.payments.findOrderPayment({
+                orderPaymentId,
+            });
+            if (!orderPayment) {
+                throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
+            }
+            const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+                paymentContext: {
+                    paymentIntentId: paymentIntent.id,
+                },
+            });
+            if (!order)
+                throw new Error(`Order with id ${orderPayment.orderId} not found`);
+            logger.info(`checkout successful`, {
+                orderPaymentId,
+                orderId: order._id,
+                type: event.type,
+            });
+            return new Response(JSON.stringify({
+                success: true,
+                message: 'checkout successful',
+                orderId: order._id,
+            }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        if (event.type === WebhookEventTypes.SETUP_INTENT_SUCCEEDED) {
+            const setupIntent = event.data.object;
+            const { paymentProviderId, userId } = setupIntent.metadata || {};
+            logger.info(`registered payment credential with paymentProviderId: ${paymentProviderId}`, {
+                type: event.type,
+                userId,
+            });
+            const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, {
+                transactionContext: {
+                    setupIntentId: setupIntent.id,
+                },
+                userId,
+            });
+            logger.info(`payment credentials registration successful`, {
+                userId,
+                paymentProviderId,
+                paymentCredentialsId: paymentCredentials?._id,
+                type: event.type,
+            });
+            return new Response(JSON.stringify({
+                success: true,
+                message: 'payment credentials registration successful',
+                paymentCredentialsId: paymentCredentials?._id,
+            }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        return new Response(JSON.stringify({
+            success: false,
+            message: 'Unhandled event type',
+        }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    catch (error) {
+        logger.error(error);
+        return new Response(JSON.stringify({
+            success: false,
+            message: error.message,
+            name: error.name,
+        }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+}

package/lib/pricing/delivery-eu-tax/adapter.d.ts

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

package/lib/pricing/delivery-eu-tax/adapter.js

@@ -0,0 +1,55 @@
+import { DeliveryPricingRowCategory, DeliveryPricingAdapter, } from '@unchainedshop/core';
+import { isEuMemberCountry, resolveEuTaxCategoryFromDeliveryProvider, resolveEuTaxRate, } from "../tax/eu.js";
+import resolveDeliveryLocation from "../utils/resolveDeliveryLocation.js";
+import { applyTaxRateToTaxableRows } from "../tax/applyTaxRateToTaxableRows.js";
+export const DeliveryEuTax = {
+    ...DeliveryPricingAdapter,
+    key: 'shop.unchained.pricing.delivery-eu-tax',
+    version: '1.0.0',
+    label: 'Apply EU VAT on Delivery Fees',
+    orderIndex: 80,
+    isActivatedFor: (context) => {
+        if (!context.order)
+            return false;
+        if (!context.orderDelivery)
+            return false;
+        const { countryCode } = resolveDeliveryLocation({
+            order: context.order,
+            orderDelivery: context.orderDelivery,
+            countryCode: context.countryCode,
+        });
+        return isEuMemberCountry(countryCode);
+    },
+    actions: (params) => {
+        const pricingAdapter = DeliveryPricingAdapter.actions(params);
+        const { context } = params;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const { countryCode } = resolveDeliveryLocation({
+                    order: context.order,
+                    orderDelivery: context.orderDelivery,
+                    countryCode: context.countryCode,
+                });
+                const category = resolveEuTaxCategoryFromDeliveryProvider(context.provider);
+                const taxRate = resolveEuTaxRate({
+                    countryCode,
+                    category,
+                    referenceDate: context.order?.ordered,
+                });
+                if (taxRate === null)
+                    return pricingAdapter.calculate();
+                DeliveryPricingAdapter.log(`DeliveryEuTax -> Tax Multiplicator: ${taxRate}`);
+                applyTaxRateToTaxableRows({
+                    calculationSheet: params.calculationSheet,
+                    resultSheet: pricingAdapter.resultSheet(),
+                    taxRate,
+                    baseCategory: DeliveryPricingRowCategory.Delivery,
+                    adapterKey: DeliveryEuTax.key,
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+export default DeliveryEuTax;

package/lib/pricing/delivery-eu-tax/index.d.ts

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

package/lib/pricing/delivery-eu-tax/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { DeliveryEuTax } from "./adapter.js";
+export const DeliveryEuTaxPlugin = {
+    key: 'shop.unchained.pricing.delivery-eu-tax',
+    label: 'Delivery EU Tax Plugin',
+    version: '1.0.0',
+    adapters: [DeliveryEuTax],
+};
+export default DeliveryEuTaxPlugin;
+export { DeliveryEuTax } from "./adapter.js";

package/lib/pricing/delivery-swiss-tax/adapter.d.ts

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

package/lib/pricing/delivery-swiss-tax/adapter.js

@@ -0,0 +1,43 @@
+import { DeliveryPricingRowCategory, DeliveryPricingAdapter, } from '@unchainedshop/core';
+import { resolveTaxCategoryFromDeliveryProvider, SwissTaxCategories } from "../tax/ch.js";
+import isDeliveryAddressInCountry from "../utils/isDeliveryAddressInCountry.js";
+import { applyTaxRateToTaxableRows } from "../tax/applyTaxRateToTaxableRows.js";
+export const DeliverySwissTax = {
+    ...DeliveryPricingAdapter,
+    key: 'shop.unchained.pricing.delivery-swiss-tax',
+    version: '1.0.0',
+    label: 'Apply Swiss Tax on Delivery Fees',
+    orderIndex: 80,
+    isActivatedFor: (context) => {
+        if (!context.order)
+            return false;
+        if (!context.orderDelivery)
+            return false;
+        return isDeliveryAddressInCountry({
+            order: context.order,
+            orderDelivery: context.orderDelivery,
+            countryCode: context.countryCode,
+        }, ['CH', 'LI']);
+    },
+    actions: (params) => {
+        const pricingAdapter = DeliveryPricingAdapter.actions(params);
+        const { context } = params;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const taxCategory = resolveTaxCategoryFromDeliveryProvider(context.provider) || SwissTaxCategories.DEFAULT;
+                const taxRate = taxCategory.rate(context.order?.ordered);
+                DeliveryPricingAdapter.log(`DeliverySwissTax -> Tax Multiplicator: ${taxRate}`);
+                applyTaxRateToTaxableRows({
+                    calculationSheet: params.calculationSheet,
+                    resultSheet: pricingAdapter.resultSheet(),
+                    taxRate,
+                    baseCategory: DeliveryPricingRowCategory.Delivery,
+                    adapterKey: DeliverySwissTax.key,
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+export default DeliverySwissTax;

package/lib/pricing/delivery-swiss-tax/index.d.ts

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

package/lib/pricing/delivery-swiss-tax/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { DeliverySwissTax } from "./adapter.js";
+export const DeliverySwissTaxPlugin = {
+    key: 'shop.unchained.pricing.delivery-swiss-tax',
+    label: 'Delivery Swiss Tax Plugin',
+    version: '1.0.0',
+    adapters: [DeliverySwissTax],
+};
+export default DeliverySwissTaxPlugin;
+export { DeliverySwissTax } from "./adapter.js";

package/lib/pricing/delivery-uk-tax/adapter.d.ts

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

package/lib/pricing/delivery-uk-tax/adapter.js

@@ -0,0 +1,43 @@
+import { DeliveryPricingRowCategory, DeliveryPricingAdapter, } from '@unchainedshop/core';
+import { resolveUkTaxCategoryFromDeliveryProvider, UkTaxCategories, UK_VAT_COUNTRY_CODES, } from "../tax/uk.js";
+import isDeliveryAddressInCountry from "../utils/isDeliveryAddressInCountry.js";
+import { applyTaxRateToTaxableRows } from "../tax/applyTaxRateToTaxableRows.js";
+export const DeliveryUkTax = {
+    ...DeliveryPricingAdapter,
+    key: 'shop.unchained.pricing.delivery-uk-tax',
+    version: '1.0.0',
+    label: 'Apply UK VAT on Delivery Fees',
+    orderIndex: 80,
+    isActivatedFor: (context) => {
+        if (!context.order)
+            return false;
+        if (!context.orderDelivery)
+            return false;
+        return isDeliveryAddressInCountry({
+            order: context.order,
+            orderDelivery: context.orderDelivery,
+            countryCode: context.countryCode,
+        }, UK_VAT_COUNTRY_CODES);
+    },
+    actions: (params) => {
+        const pricingAdapter = DeliveryPricingAdapter.actions(params);
+        const { context } = params;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                const taxCategory = resolveUkTaxCategoryFromDeliveryProvider(context.provider) || UkTaxCategories.STANDARD;
+                const taxRate = taxCategory.rate(context.order?.ordered);
+                DeliveryPricingAdapter.log(`DeliveryUkTax -> Tax Multiplicator: ${taxRate}`);
+                applyTaxRateToTaxableRows({
+                    calculationSheet: params.calculationSheet,
+                    resultSheet: pricingAdapter.resultSheet(),
+                    taxRate,
+                    baseCategory: DeliveryPricingRowCategory.Delivery,
+                    adapterKey: DeliveryUkTax.key,
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+export default DeliveryUkTax;

package/lib/pricing/delivery-uk-tax/index.d.ts

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

package/lib/pricing/delivery-uk-tax/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { DeliveryUkTax } from "./adapter.js";
+export const DeliveryUkTaxPlugin = {
+    key: 'shop.unchained.pricing.delivery-uk-tax',
+    label: 'Delivery UK Tax Plugin',
+    version: '1.0.0',
+    adapters: [DeliveryUkTax],
+};
+export default DeliveryUkTaxPlugin;
+export { DeliveryUkTax } from "./adapter.js";

package/lib/pricing/delivery-us-sales-tax/adapter.d.ts

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

package/lib/pricing/delivery-us-sales-tax/adapter.js

@@ -0,0 +1,58 @@
+import { DeliveryPricingRowCategory, DeliveryPricingAdapter, } from '@unchainedshop/core';
+import { US_COUNTRY_CODE, isDeliveryExemptFromUsSalesTax, resolveUsSalesTaxRate } from "../tax/us.js";
+import resolveDeliveryLocation from "../utils/resolveDeliveryLocation.js";
+import { applyTaxRateToTaxableRows } from "../tax/applyTaxRateToTaxableRows.js";
+export const DeliveryUsSalesTax = {
+    ...DeliveryPricingAdapter,
+    key: 'shop.unchained.pricing.delivery-us-sales-tax',
+    version: '1.0.0',
+    label: 'Apply US State Sales Tax on Delivery Fees',
+    orderIndex: 80,
+    isActivatedFor: (context) => {
+        if (!context.order)
+            return false;
+        if (!context.orderDelivery)
+            return false;
+        const { countryCode } = resolveDeliveryLocation({
+            order: context.order,
+            orderDelivery: context.orderDelivery,
+            countryCode: context.countryCode,
+        });
+        return countryCode === US_COUNTRY_CODE;
+    },
+    actions: (params) => {
+        const pricingAdapter = DeliveryPricingAdapter.actions(params);
+        const { context } = params;
+        return {
+            ...pricingAdapter,
+            calculate: async () => {
+                if (isDeliveryExemptFromUsSalesTax(context.provider)) {
+                    return pricingAdapter.calculate();
+                }
+                const { regionCode } = resolveDeliveryLocation({
+                    order: context.order,
+                    orderDelivery: context.orderDelivery,
+                    countryCode: context.countryCode,
+                });
+                const taxRate = resolveUsSalesTaxRate({
+                    regionCode,
+                    referenceDate: context.order?.ordered,
+                });
+                if (taxRate === null) {
+                    DeliveryPricingAdapter.log(`DeliveryUsSalesTax -> unknown state '${regionCode}', no sales tax applied`);
+                    return pricingAdapter.calculate();
+                }
+                DeliveryPricingAdapter.log(`DeliveryUsSalesTax -> Tax Multiplicator: ${taxRate}`);
+                applyTaxRateToTaxableRows({
+                    calculationSheet: params.calculationSheet,
+                    resultSheet: pricingAdapter.resultSheet(),
+                    taxRate,
+                    baseCategory: DeliveryPricingRowCategory.Delivery,
+                    adapterKey: DeliveryUsSalesTax.key,
+                });
+                return pricingAdapter.calculate();
+            },
+        };
+    },
+};
+export default DeliveryUsSalesTax;

package/lib/pricing/delivery-us-sales-tax/index.d.ts

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

package/lib/pricing/delivery-us-sales-tax/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { DeliveryUsSalesTax } from "./adapter.js";
+export const DeliveryUsSalesTaxPlugin = {
+    key: 'shop.unchained.pricing.delivery-us-sales-tax',
+    label: 'Delivery US Sales Tax Plugin',
+    version: '1.0.0',
+    adapters: [DeliveryUsSalesTax],
+};
+export default DeliveryUsSalesTaxPlugin;
+export { DeliveryUsSalesTax } from "./adapter.js";

package/lib/pricing/discount-100-off/adapter.d.ts

@@ -0,0 +1,3 @@
+import { type OrderDiscountConfiguration, type IDiscountAdapter } from '@unchainedshop/core';
+export declare const HundredOff: IDiscountAdapter<OrderDiscountConfiguration>;
+export default HundredOff;

package/lib/pricing/discount-100-off/adapter.js

@@ -0,0 +1,30 @@
+import { OrderDiscountAdapter, } from '@unchainedshop/core';
+export const HundredOff = {
+    ...OrderDiscountAdapter,
+    key: 'shop.unchained.discount.100-off',
+    label: '100 Off',
+    version: '1.0.0',
+    orderIndex: 10,
+    isManualAdditionAllowed: async () => {
+        return true;
+    },
+    isManualRemovalAllowed: async () => {
+        return true;
+    },
+    actions: async ({ context }) => ({
+        ...(await OrderDiscountAdapter.actions({ context })),
+        isValidForSystemTriggering: async () => {
+            return false;
+        },
+        isValidForCodeTriggering: async ({ code }) => {
+            return code.toUpperCase() === '100OFF';
+        },
+        discountForPricingAdapterKey: ({ pricingAdapterKey }) => {
+            if (pricingAdapterKey === 'shop.unchained.pricing.order-discount') {
+                return { fixedRate: 10000 };
+            }
+            return null;
+        },
+    }),
+};
+export default HundredOff;

package/lib/pricing/discount-100-off/index.d.ts

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

package/lib/pricing/discount-100-off/index.js

@@ -0,0 +1,10 @@
+import {} from '@unchainedshop/core';
+import { HundredOff } from "./adapter.js";
+export const HundredOffPlugin = {
+    key: 'shop.unchained.discount.100-off',
+    label: '100 Off Discount Plugin',
+    version: '1.0.0',
+    adapters: [HundredOff],
+};
+export default HundredOffPlugin;
+export { HundredOff } from "./adapter.js";

package/lib/pricing/discount-half-price-manual/adapter.d.ts

@@ -0,0 +1,3 @@
+import { type ProductDiscountConfiguration, type IDiscountAdapter } from '@unchainedshop/core';
+export declare const HalfPriceManual: IDiscountAdapter<ProductDiscountConfiguration>;
+export default HalfPriceManual;