@vandenberghinc/volt 1.2.5 → 1.2.6

package/frontend/dist/backend/src/payments/paddle.js

@@ -1,2276 +0,0 @@
-// @ts-nocheck
-/**
- * @author Daan van den Bergh
- * @copyright © 2022 - 2025 Daan van den Bergh. All rights reserved
- */
-// Imports.
-import * as https from "https";
-import * as PDFDocument from "pdfkit";
-import * as libcrypto from "crypto";
-import * as vlib from "@vandenberghinc/vlib";
-import { ExternalError } from "../errors/index.js";
-import { Status } from "../status.js";
-import { Collection } from "../database/collection.js";
-import { Utils } from "../utils.js";
-/** Nested types for the {@link LineItem} interface. */
-export var LineItem;
-(function (LineItem) {
-    /** Validation schema. */
-    LineItem.Schema = {
-        product: "string",
-        item_id: "string",
-        paddle_prod_id: "string",
-        quantity: "number",
-        tax_rate: "number",
-        tax: "number",
-        discount: "number",
-        subtotal: "number",
-        total: "number",
-        status: { type: "string", enum: ["paid", "refunded", "refunding"] },
-    };
-})(LineItem || (LineItem = {}));
-export const PaymentStatusValues = ['open', 'paid', 'past_due', 'unknown'];
-/** Nested types for the {@link Payment} interface. */
-export var Payment;
-(function (Payment) {
-    /**
-     * Check if a payment should be anonymized,
-     * if so return a public version of the payment.
-     */
-    function anonymize(payment) {
-        if (!payment.uid || payment.uid === "unauth") {
-            const { billing_details, ...rest } = payment;
-            return {
-                ...rest,
-                billing_details: undefined,
-            };
-        }
-        return payment;
-    }
-    Payment.anonymize = anonymize;
-})(Payment || (Payment = {}));
-// The paddle payments class.
-// @todo check if a user can subscribe twice to a sub, should not be allowed for system logic.
-// @todo still need to manage the reactivation of a subscription after a chargeback has been reversed.
-// @todo still check if a subscription is automatically cancelled by paddle when it is refunded.
-/**
- * The paddle payments class.
- *
- * Sandbox env: https://sandbox-vendors.paddle.com
- *
- * @nav Payments
- * @docs
- * @deprecated Using stripe from now on.
- */
-export class Paddle {
-    type = "paddle";
-    client_key;
-    sandbox;
-    inclusive_tax;
-    products;
-    server;
-    _host;
-    _headers;
-    webhook_key;
-    _has_create_products_permission;
-    _last_products_db;
-    _webhook_conf_db;
-    _sub_db;
-    _active_sub_db;
-    _pay_db;
-    // private _inv_db: Collection;
-    performance;
-    constructor({ api_key, client_key, sandbox = false, products = [], inclusive_tax = false, _server, }) {
-        // Original constructor implementation remains the same
-        // Verify args.
-        vlib.schema.validate(arguments[0], {
-            unknown: false,
-            throw: true,
-            parent: "payments",
-            schema: {
-                type: { type: "string", default: "paddle" },
-                api_key: "string",
-                client_key: "string",
-                sandbox: { type: "boolean", default: false },
-                inclusive_tax: { type: "boolean", default: false },
-                products: "array",
-                _server: "object",
-            }
-        });
-        // Attributes.
-        this.client_key = client_key;
-        this.sandbox = sandbox;
-        this.inclusive_tax = inclusive_tax;
-        this.products = products;
-        this.server = _server;
-        // Request headers.
-        this._host = this.sandbox ? "sandbox-api.paddle.com" : "api.paddle.com";
-        this._headers = {
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-            "Authorization": "Bearer " + api_key,
-        };
-        // Extend the csp.
-        this.server.csp["default-src"] += " https://*.paddle.com/";
-        this.server.csp["script-src"] += " https://*.paddle.com/ https://*.payments-amazon.com https://*.paypal.com https://*.google.com";
-        this.server.csp["style-src"] += " https://*.paddle.com/ https://*.media-amazon.com https://*.paypal.com https://*.google.com";
-        this.server.csp["img-src"] += " https://*.paddle.com/ https://*.media-amazon.com https://*.paypal.com https://*.google.com";
-        // Create database collections.
-        this._last_products_db = this.server.db.collection({
-            name: "Volt.Paddle.LastProducts",
-            indexes: ["production", "version"],
-        });
-        this._webhook_conf_db = this.server.db.collection({
-            name: "Volt.Paddle.WebhookConfig",
-            indexes: ["production", "version"],
-        });
-        this._sub_db = this.server.db.collection({
-            name: "Volt.Paddle.Subscriptions",
-            indexes: ["uid", "id"],
-        });
-        this._active_sub_db = this.server.db.collection({
-            name: "Volt.Paddle.ActiveSubscriptions",
-            indexes: ["uid", "prod_id"],
-        });
-        this._pay_db = this.server.db.collection({
-            name: "Volt.Paddle.Payments",
-            indexes: ["uid", "id", "tran_id"],
-        });
-        // this._inv_db = this.server.db.collection({
-        //     name: "Volt.Paddle.Invoices",
-        //     indexes: ["uid", "id", "tran_id" ],
-        // });
-        /* @performance */ this.performance = new vlib.Performance("Payments performance");
-    }
-    // ---------------------------------------------------------
-    // Products and prices (private).
-    // ---------------------------------------------------------
-    // Utils (private).
-    async _req(method, endpoint, params = null) {
-        const promise = new Promise((resolve, reject) => {
-            // Build hostname + path for both relative and absolute endpoints.
-            const is_get_like = method === "GET" || method === "HEAD";
-            let hostname = this._host;
-            let path = endpoint;
-            try {
-                if (/^https?:\/\//i.test(endpoint)) {
-                    const u = new URL(endpoint);
-                    hostname = u.hostname;
-                    path = u.pathname + u.search;
-                }
-                else if (is_get_like && params != null) {
-                    path = `${endpoint}?${new URLSearchParams(params).toString()}`;
-                }
-            }
-            catch {
-                // fall back to original host + endpoint
-            }
-            // Options.
-            const options = {
-                method: method,
-                hostname,
-                path,
-                port: 443,
-                headers: this._headers,
-            };
-            // Make the HTTP request
-            const request = https.request(options, (response) => {
-                let data = '';
-                response.on('data', (chunk) => {
-                    data += chunk;
-                });
-                response.on('end', () => {
-                    if (response?.statusCode >= 200 && response?.statusCode < 300) {
-                        try {
-                            resolve(data ? JSON.parse(data) : {});
-                        }
-                        catch (error) {
-                            reject(new Error('Failed to parse response data'));
-                        }
-                    }
-                    else {
-                        if (data == null || data === "") {
-                            return reject(new Paddle.RequestError(`${method}:${endpoint}: Request failed [${response.statusCode}].`, response.statusCode));
-                        }
-                        try {
-                            data = JSON.parse(data);
-                        }
-                        catch (e) {
-                            return reject(new Paddle.RequestError(`${method}:${endpoint}: Request failed [${response.statusCode}].`, response.statusCode));
-                        }
-                        if (data.error == null) {
-                            return reject(new Paddle.RequestError(`${method}:${endpoint}: Request failed [${response.statusCode}].`, response.statusCode));
-                        }
-                        data = data.error;
-                        let errs = "";
-                        if (data.errors) {
-                            errs += ". ";
-                            data.errors.iterate((item) => {
-                                errs += `Field: "${item.field}" ${item.message}. `;
-                            });
-                            errs = errs.substr(0, errs.length - 2);
-                        }
-                        return reject(new Paddle.RequestError(`${method}:${endpoint}: ${data.detail} [${response.statusCode}]${errs}.`, response.statusCode));
-                    }
-                });
-            });
-            // Write body params.
-            if (!is_get_like && params != null) {
-                // request.write(JSON.stringify(params));
-                const requestBody = JSON.stringify(params);
-                request.setHeader('Content-Length', Buffer.byteLength(requestBody));
-                request.write(requestBody);
-            }
-            // On error.
-            request.on('error', (error) => {
-                reject(error);
-            });
-            // End.
-            request.end();
-        });
-        // So the traceback still includes the call function of _req.
-        try {
-            return await promise;
-        }
-        catch (e) {
-            if (e instanceof Error || e instanceof Paddle.RequestError) {
-                throw e;
-            }
-            throw new Error(e);
-        }
-    }
-    // ---------------------------------------------------------
-    // Database (private).
-    // Add or remove a subscription to the user's active subscriptions.
-    async _add_subscription(uid, prod_id, sub_id) {
-        await this._active_sub_db.set({ uid, prod_id }, { prod_id, sub_id });
-    }
-    async _delete_subscription(uid, prod_id) {
-        await this._active_sub_db.delete({ uid, prod_id });
-    }
-    async _check_subscription(uid, prod_id, load_data = false) {
-        try {
-            const doc = await this._active_sub_db.load({ uid, prod_id });
-            return load_data ? { exists: true, sub_id: doc.sub_id } : true;
-        }
-        catch (err) {
-            if (err instanceof Collection.NotFoundError) {
-                return load_data ? { exists: false, sub_id: undefined } : false;
-            }
-            throw err;
-        }
-    }
-    async _get_active_subscriptions(uid, detailed = false) {
-        const list = await this._active_sub_db.list({ uid: uid });
-        if (detailed) {
-            return list;
-        }
-        const products = [];
-        for (const doc of list) {
-            products.push(doc.prod_id);
-        }
-        return products;
-    }
-    async _save_subscription(subscription) {
-        await this._sub_db.set({
-            uid: subscription.uid == null ? "unauth" : subscription.uid,
-            id: subscription.id,
-        }, subscription);
-    }
-    async _load_subscription(id) {
-        return await this._sub_db.load({ id: id }, { retry: 3 });
-    }
-    async _get_subscriptions(uid) {
-        if (uid === "unauth" || uid == null) {
-            return [];
-        }
-        const list = await this._sub_db.list({ uid: uid });
-        return list;
-    }
-    // Save and delete payments, all failed payments should be deleted from the database.
-    async _save_payment(payment) {
-        await this._pay_db.set({
-            uid: payment.uid == null ? "unauth" : payment.uid,
-            id: payment.id,
-        }, payment);
-    }
-    async _load_payment(id) {
-        const uid = id.split("_")[1];
-        return await this._pay_db.load({ uid, id });
-    }
-    async _load_payment_for_public(id) {
-        return Payment.anonymize(await this._load_payment(id));
-    }
-    async _load_payment_by_transaction(tran_id) {
-        return await this._pay_db.load({ tran_id: tran_id }, { retry: 3 });
-    }
-    async _load_payment_by_transaction_for_public(tran_id) {
-        return Payment.anonymize(await this._load_payment_by_transaction(tran_id));
-    }
-    async _delete_payment(id) {
-        const uid = id.split("_")[1];
-        await this._pay_db.delete({ uid, id });
-    }
-    // Delete all info of a user.
-    async _delete_user(uid) {
-        await this._sub_db.delete_many({ uid });
-        await this._active_sub_db.delete_many({ uid });
-        await this._pay_db.delete_many({ uid });
-        // await this._inv_db.delete_all({ uid });
-    }
-    // List all active subscriptions.
-    async _get_all_active_subscriptions() {
-        return await this._active_sub_db.list_all();
-    }
-    // ---------------------------------------------------------
-    // Overall (private).
-    // Get product by paddle product id.
-    _get_product_by_paddle_prod_id(id, throw_err = false) {
-        let product = null;
-        for (const p of this.products) {
-            if (p.is_subscription) {
-                if (p.plans == null) {
-                    throw Error(`Invalid project "${p.id}" subscription is activated yet no plans are defined.`);
-                }
-                for (const plan of p.plans) {
-                    if (plan.paddle_prod_id === id) {
-                        product = plan;
-                    }
-                }
-                if (product != null)
-                    break;
-            }
-            else if (p.paddle_prod_id === id) {
-                product = p;
-                break;
-            }
-        }
-        if (product == null && throw_err) {
-            throw Error(`Unable to find product "${id}".`);
-        }
-        return product;
-    }
-    // Get all active products.
-    async _get_products() {
-        let response, next = null;
-        let items = [];
-        while (true) {
-            if (next == null) {
-                response = await this._req("GET", "/products", { status: ["active"], per_page: 100 });
-            }
-            else {
-                response = await this._req("GET", next);
-            }
-            items = items.concat(response.data);
-            if (response.meta.has_more) {
-                next = response.meta.next;
-            }
-            else {
-                break;
-            }
-        }
-        return items;
-    }
-    // Get all active prices.
-    async _get_prices() {
-        let response, next = null;
-        let items = [];
-        while (true) {
-            if (next == null) {
-                response = await this._req("GET", "/prices", { status: ["active"], per_page: 100 });
-            }
-            else {
-                response = await this._req("GET", next);
-            }
-            items = items.concat(response.data);
-            if (response.meta.has_more) {
-                next = response.meta.next;
-            }
-            else {
-                break;
-            }
-        }
-        return items;
-    }
-    // Create or update a product, when existing product is undefined a new product and price will be created.
-    async _check_product(product, existing_products = [], existing_prices = []) {
-        // Check create product permission.
-        const has_create_products_permission = async () => {
-            if (process.argv.includes("--no-payment-edits")) {
-                return false;
-            }
-            if (this._has_create_products_permission != null) {
-                return this._has_create_products_permission;
-            }
-            const input = await vlib.logging.prompt("Some paddle products have to be edited, do you wish to make these changes? [y/n]: ");
-            if (["y", "yes", "ok"].includes(input.toLowerCase())) {
-                this._has_create_products_permission = true;
-            }
-            else {
-                this._has_create_products_permission = false;
-            }
-            return this._has_create_products_permission;
-        };
-        // Find existing product.
-        let existing_product = null;
-        for (const item of existing_products) {
-            if (item.custom_data.id === product.id) {
-                existing_product = item;
-                break;
-            }
-        }
-        // No existing product so create.
-        if (existing_product == null) {
-            // Check permission.
-            if (!await has_create_products_permission()) {
-                return;
-            }
-            // Create product.
-            this.server.log(0, `Creating product ${product.name}.`);
-            const created_product = await this._req("POST", "/products", {
-                name: product.name,
-                description: product.description,
-                image_url: product.icon,
-                tax_category: product.tax_category,
-                custom_data: { id: product.id },
-            });
-            product.paddle_prod_id = created_product.data.id;
-            // Create price.
-            this.server.log(0, `Creating a price for product ${product.name}.`);
-            const created_price = await this._req("POST", "/prices", {
-                product_id: product.paddle_prod_id,
-                name: product.name,
-                description: product.description,
-                unit_price: { amount: Math.floor(product.price * 100).toString(), currency_code: product.currency },
-                billing_cycle: product.is_subscription ? { interval: product.interval, frequency: product.frequency } : null,
-                trial_period: product.is_subscription ? product.trial : null,
-                tax_mode: this.inclusive_tax ? "internal" : "external",
-            });
-            product.price_id = created_price.data.id;
-        }
-        // Passed an existing product so check.
-        else {
-            // Vars.
-            product.paddle_prod_id = existing_product.id;
-            const has_trial = product.is_subscription && product.trial != null;
-            // Check if the product should be updated.
-            const update_product = (existing_product.name !== product.name ||
-                existing_product.description !== product.description ||
-                existing_product.image_url !== product.icon ||
-                existing_product.tax_category !== product.tax_category ||
-                existing_product.status !== "active");
-            // Update product.
-            if (update_product) {
-                if (!await has_create_products_permission()) {
-                    return;
-                }
-                this.server.log(0, `Updating product ${product.name}.`);
-                await this._req("PATCH", `/products/${product.paddle_prod_id}`, {
-                    name: product.name,
-                    description: product.description,
-                    image_url: product.icon,
-                    tax_category: product.tax_category,
-                    custom_data: { id: product.id },
-                    status: "active",
-                });
-            }
-            // Fetch the attached price.
-            let existing_price = null;
-            for (const item of existing_prices) {
-                if (item.product_id === product.paddle_prod_id) {
-                    existing_price = item;
-                    break;
-                }
-            }
-            // Create price.
-            if (existing_price == null) {
-                if (!await has_create_products_permission()) {
-                    return;
-                }
-                this.server.log(0, `Creating a price for product ${product.name}.`);
-                const price = await this._req("POST", "/prices", {
-                    product_id: product.paddle_prod_id,
-                    name: product.name,
-                    description: product.description,
-                    unit_price: { amount: Math.floor(product.price * 100).toString(), currency_code: product.currency },
-                    billing_cycle: product.is_subscription ? { interval: product.interval, frequency: product.frequency } : null,
-                    trial_period: product.is_subscription ? product.trial : null,
-                    tax_mode: this.inclusive_tax ? "internal" : "external",
-                });
-                product.price_id = price.data.id;
-            }
-            // Update price.
-            else {
-                // Set id.
-                product.price_id = existing_price.id;
-                // Update price.
-                const update_price = (existing_price.product_id !== product.paddle_prod_id ||
-                    existing_price.name !== product.name ||
-                    existing_price.description !== product.description ||
-                    existing_price.tax_mode !== (this.inclusive_tax ? "internal" : "external") ||
-                    existing_price.unit_price == null ||
-                    existing_price.unit_price.amount !== Math.floor(product.price * 100).toString() ||
-                    existing_price.unit_price.currency_code !== product.currency ||
-                    (product.is_subscription && (existing_price.billing_cycle == null ||
-                        existing_price.billing_cycle.interval !== product.interval ||
-                        existing_price.billing_cycle.frequency !== product.frequency)) ||
-                    (has_trial && (existing_price.trial_period == null ||
-                        existing_price.trial_period.interval !== product.trial?.interval ||
-                        existing_price.trial_period.frequency !== product.trial?.frequency)) ||
-                    existing_price.status !== "active");
-                // Update price.
-                if (update_price) {
-                    if (!await has_create_products_permission()) {
-                        return;
-                    }
-                    this.server.log(0, `Updating the price of product ${product.name}.`);
-                    await this._req("PATCH", `/prices/${product.price_id}`, {
-                        // product_id: product.id, // not allowed.
-                        name: product.name,
-                        description: product.description,
-                        unit_price: { amount: Math.floor(product.price * 100).toString(), currency_code: product.currency },
-                        billing_cycle: product.is_subscription ? { interval: product.interval, frequency: product.frequency } : null,
-                        trial_period: product.is_subscription ? product.trial : null,
-                        tax_mode: this.inclusive_tax ? "internal" : "external",
-                        status: "active",
-                    });
-                }
-            }
-        }
-    }
-    // Cancel subscription by subscription id.
-    async _cancel_subscription(id, immediate = false) {
-        if (id == null) {
-            throw Error(`Define parameter \"id\".`);
-        }
-        // Load subscription object.
-        const subscription = await this._load_subscription(id);
-        if (subscription == null) {
-            throw Error(`Unable to find subscription "${id}".`);
-        }
-        // Cancel.
-        if (subscription.status !== "active") {
-            throw new ExternalError({
-                type: "NoActiveSubscriptionError",
-                message: `This subscription is already cancelled and will become inactive at the end of the billing period.`,
-                status: Status.bad_request,
-            });
-        }
-        await this._req("POST", `/subscriptions/${subscription.id}/cancel`, {
-            effective_from: immediate ? "immediately" : null,
-        });
-        // Update subscription.
-        subscription.status = "cancelling";
-        await this._save_subscription(subscription);
-    }
-    // async _cancel_subscription(payment) {
-    //     if (typeof payment === "string") {
-    //         payment = await this._load_payment(payment);
-    //     }
-    //     if (payment.cus_id == null) {
-    //         throw Error(`Payment "${payment.id}" does not have an assigned customer id attribute.`);
-    //     }
-    //     if (payment.sub_id == null) {
-    //         throw Error(`Payment "${payment.id}" does not have an assigned subscription id attribute, it may not be a subscription payment.`);
-    //     }
-    //     if (payment.line_items.length == 0) {
-    //         throw Error(`Payment "${payment.id}" does not contain any line items.`);
-    //     }
-    //     // Cancel.
-    //     const cancellable = [];
-    //     let all_cancelled = null;
-    //     payment.line_items.iterate((item) => {
-    //         const product = this.get_product_sync(item.product);
-    //         if (product.is_subscription) {
-    //             if (item.status === "cancelled" || item.status === "cancelling") {
-    //                 if (all_cancelled == null) {
-    //                     all_cancelled = true;
-    //                 }
-    //             } else if (item.status === "paid" || item.status === "refunding" || item.status === "refunded") {
-    //                 all_cancelled = false;
-    //                 cancellable.push(item);
-    //             }
-    //         }
-    //     })
-    //     if (all_cancelled) {
-    //         throw new FrontendError(`This subscription is already cancelled and will become inactive at the end of the billing period.`, Status.bad_request);
-    //     }
-    //     if (cancellable.length === 0) {
-    //         throw new FrontendError(`This subscription does not contain any cancellable items, the subscription is likely already cancelled or refunded.`, Status.bad_request);
-    //     }
-    //     await this._req("POST", `/subscriptions/${payment.sub_id}/cancel`, {
-    //         // effective_from: "immediately",
-    //     });
-    //     // Update payment.
-    //     cancellable.iterate((item) => {
-    //         if (item.status === "paid") {
-    //             item.status = "cancelling";
-    //         }
-    //     })
-    //     await this._save_payment(payment);
-    //     /* V1 cancel per product but since the webhook subscription event does not show which sub items are cancelled, this is not possible.
-    //     // Update the subscription items.
-    //     const sub = await this._req("GET", `/subscriptions/${payment.sub_id}`);
-    //     const items = [];
-    //     const cancelled_line_items = [];
-    //     let edits = 0;
-    //     sub.data.items.iterate((sub_item) => {
-    //         // Only for active subscription items.
-    //         if (sub_item.recurring && (sub_item.status === "active" || sub_item.status === "trailing")) {
-    //             // Recurring items.
-    //             const item = payment.line_items.iterate((item) => {
-    //                 if (item.paddle_prod_id === sub_item.price.product_id) {
-    //                     return item;
-    //                 }
-    //             })
-    //             // Item not found, so cancel but do not update status since it is not found.
-    //             if (item == null) {
-    //                 console.error(`Unable to find subscription item "${sub_item.price.product_id}" while cancelling. Items: ${JSON.stringify(payment.line_items)}`)
-    //                 ++edits;
-    //             }
-    //             // Already cancelling.
-    //             // else if (item.status === "cancelling") {
-    //             //     items.push({
-    //             //         price_id: sub_item.price.id,
-    //             //         quantity: sub_item.quantity,
-    //             //     })
-    //             // }
-    //             // Cancel item.
-    //             else if (products == null || products.includes(item.id)) {
-    //                 item.status = "cancelling";
-    //                 ++edits;
-    //                 cancelled_line_items.push(item);
-    //             }
-    //             // Keep item.
-    //             else {
-    //                 items.push({
-    //                     price_id: sub_item.price.id,
-    //                     quantity: sub_item.quantity,
-    //                 })
-    //             }
-    //         }
-    //         // Keep all non recurring.
-    //         else if (sub_item.recurring === false) {
-    //             items.push({
-    //                 price_id: sub_item.price.id,
-    //                 quantity: sub_item.quantity,
-    //             })
-    //         }
-    //     })
-    //     // No edits.
-    //     if (edits === 0) {
-    //         throw Error("This payment does not contain any cancellable subscriptions.");
-    //     }
-    //     // Catch certain error.
-    //     try {
-    //         // Delete the subscription.
-    //         if (items.length === 0) {
-    //             await this._req("POST", `/subscriptions/${payment.sub_id}/cancel`, {});
-    //         }
-    //         // Update the subscription.
-    //         else {
-    //             await this._req("PATCH", `/subscriptions/${payment.sub_id}`, {
-    //                 items: items,
-    //                 scheduled_change: null,
-    //                 proration_billing_mode: "full_next_billing_period",
-    //             });
-    //         }
-    //     } catch (error) {
-    //         if (error.message.indexOf("cannot update subscription, pending scheduled changes") === -1) {
-    //             throw error;
-    //         }
-    //     }
-    //     // Update payment.
-    //     cancelled_line_items.iterate((item) => {
-    //         item.status = "cancelling";
-    //     })
-    //     await this._save_payment(payment);
-    //     */
-    // }
-    // Initialize all products.
-    async _initialize_products({ worker = false, } = {}) {
-        /* @performance */ let now = this.performance.start();
-        // Extend and initialize all products.
-        // Check a payment product / plan product.
-        const product_ids = [];
-        let product_index = 0;
-        const initialize_product = (product) => {
-            ++product_index;
-            // Check if the product has a name.
-            if (product.id == null || product.id === "") {
-                throw Error(`Product ${product_index} does not have an assigned "id" attribute (string).`);
-            }
-            else if (product_ids.includes(product.id)) {
-                throw Error(`Product ${product_index} has a non unique name "${product.id}".`);
-            }
-            product_ids.push(product.id);
-            // Set the icon absolute url.
-            if (typeof product.icon === "string" && product.icon.charAt(0) === "/") {
-                product.icon = `${this.server.full_domain}/${product.icon}`;
-            }
-            // Check attributes.
-            if (typeof product.id !== "string" || product.id === "") {
-                throw Error(`Product "${product_index}" does not have an assigned "id" attribute (string).`);
-            }
-            if (typeof product.name !== "string" || product.name === "") {
-                throw Error(`Product "${product.id}" does not have an assigned "name" attribute (string).`);
-            }
-            if (typeof product.description !== "string" || product.description === "") {
-                throw Error(`Product "${product.id}" does not have an assigned "description" attribute (string).`);
-            }
-            if (typeof product.currency !== "string" || product.currency === "") {
-                throw Error(`Product "${product.id}" does not have an assigned "currency" attribute (string).`);
-            }
-            if (typeof product.price !== "number") {
-                throw Error(`Product "${product.id}" does not have an assigned "price" attribute (number).`);
-            }
-            if (typeof product.tax_category !== "string") {
-                throw Error(`Product "${product.id}" does not have an assigned "tax_category" attribute (number).`);
-            }
-            if (product.is_subscription && typeof product.frequency !== "number") {
-                throw Error(`Product "${product.id}" does not have an assigned "frequency" attribute (number).`);
-            }
-            if (product.is_subscription && typeof product.interval !== "string") {
-                throw Error(`Product "${product.id}" does not have an assigned "interval" attribute (string).`);
-            }
-        };
-        // Expand the payment products.
-        let sub_products = 0;
-        for (const product of this.products) {
-            if (product.is_subscription) {
-                // Check plans.
-                if (!product.plans || !Array.isArray(product.plans)) {
-                    throw Error(`Product "${product_index}" has an incorrect value type for attribute "plans", the valid type is "array".`);
-                }
-                // Generate sub id.
-                product.id = `sub_${sub_products}`;
-                if (product_ids.includes(product.id)) {
-                    throw Error(`Another product has a reserved name "${product.id}".`);
-                }
-                product_ids.push(product.id);
-                ++sub_products;
-                // Attributes.
-                product.is_subscription = true;
-                // Expand plan attributes.
-                for (const plan of product.plans) {
-                    plan.is_subscription = true;
-                    plan.subscription_id = product.id;
-                    if (plan.description == null) {
-                        plan.description = product.description;
-                    }
-                    if (plan.currency == null) {
-                        plan.currency = product.currency;
-                    }
-                    if (plan.frequency == null) {
-                        plan.frequency = product.frequency;
-                    }
-                    if (plan.interval == null) {
-                        plan.interval = product.interval;
-                    }
-                    if (plan.tax_category == null) {
-                        plan.tax_category = product.tax_category;
-                    }
-                    if (plan.icon == null) {
-                        plan.icon = product.icon;
-                    }
-                    initialize_product(plan);
-                }
-            }
-            else {
-                product.is_subscription = false;
-                initialize_product(product);
-            }
-        }
-        /* @performance */ now = this.performance.end("init-products", now);
-        // Check registered products.
-        const last_products = await this._last_products_db.load({ production: this.server.production, version: 1 }, { throw: false });
-        if (last_products instanceof Error && !(last_products instanceof Collection.NotFoundError))
-            throw last_products;
-        if (!(last_products instanceof Collection.NotFoundError) && vlib.Object.deep_eq(last_products.last_products, this.products)) {
-            for (const item of last_products.product_ids) {
-                const product = this.get_product_sync(item.id);
-                if (product != null) {
-                    product.paddle_prod_id = item.paddle_prod_id;
-                    product.price_id = item.price_id;
-                }
-            }
-            /* @performance */ now = this.performance.end("assign-product-ids", now);
-        }
-        else if (this.server.offline === false) {
-            // Get all products and prices.
-            const existing_products = await this._get_products();
-            const existing_prices = await this._get_prices();
-            /* @performance */ now = this.performance.end("get-prices-and-products", now);
-            // Check all products.
-            const product_ids = [];
-            for (const product of this.products) {
-                if (product.is_subscription) {
-                    for (const plan of product.plans) {
-                        await this._check_product(plan, existing_products, existing_prices);
-                        product_ids.append({
-                            id: plan.id,
-                            paddle_prod_id: plan.paddle_prod_id,
-                            price_id: plan.price_id,
-                        });
-                    }
-                    ;
-                }
-                else {
-                    await this._check_product(product, existing_products, existing_prices);
-                    product_ids.append({
-                        id: product.id,
-                        paddle_prod_id: product.paddle_prod_id,
-                        price_id: product.price_id,
-                    });
-                }
-            }
-            ;
-            /* @performance */ now = this.performance.end("check-products", now);
-            // Save last products.
-            await this._last_products_db.set({ production: this.server.production, version: 1 }, {
-                last_products: vlib.Object.delete_recursively(vlib.Object.deep_copy(this.products), ["paddle_prod_id", "price_id"]),
-                product_ids: product_ids,
-            });
-            /* @performance */ now = this.performance.end("save-products-to-db", now);
-        }
-    }
-    // Initialize the payments.
-    async _initialize({ worker = false, } = {}) {
-        // Initialize products.
-        await this._initialize_products({ worker });
-        /* @performance */ let now = this.performance.start();
-        if (!worker) {
-            // Initialize and verify an order, check if the user is authenticated when subscriptions are present and check if the user is not already subscribed to the same item.
-            this.server.endpoint({
-                method: "POST",
-                endpoint: "/volt/api/v1/payments/init",
-                content_type: "application/json",
-                rate_limit: "global",
-                params: {
-                    items: { type: "array", required: true, value_schema: "object" }, // add schema for items
-                },
-                callback: async (stream, params) => {
-                    // Check items.
-                    if (params.items.length === 0) {
-                        return stream.error({ status: Status.bad_request, message: "Shopping cart is empty." });
-                    }
-                    let sub_plan_count = {};
-                    let error = undefined;
-                    for (const item of params.items) {
-                        if (item.product.is_subscription) {
-                            if (stream.uid == null) {
-                                error = "You must be signed-in to purchase a subscription.";
-                                break;
-                            }
-                            if (item.quantity != null && item.quantity > 1) {
-                                error = "Subscriptions have a max quantity of 1.";
-                                break;
-                            }
-                            if (sub_plan_count[item.product.subscription_id] == null) {
-                                sub_plan_count[item.product.subscription_id] = 1;
-                            }
-                            else {
-                                error = "You can not charge two different subscription plans from the same subscription product.";
-                                break;
-                            }
-                            if (await this._check_subscription(stream.uid, item.product.id, false)) {
-                                error = `You are already subscribed to product "${item.product.name}".`;
-                                break;
-                            }
-                        }
-                    }
-                    if (error) {
-                        return stream.error({ status: Status.bad_request, message: error });
-                    }
-                    // Success.
-                    return stream.success({ data: { message: "Successfully initialized the order." } });
-                }
-            });
-            // Get products.
-            this.server.endpoint({
-                method: "GET",
-                endpoint: "/volt/api/v1/payments/products",
-                content_type: "application/json",
-                rate_limit: "global",
-                callback: (stream) => {
-                    return stream.success({ data: this.products });
-                }
-            });
-            // Get payment by id.
-            this.server.endpoint({
-                method: "GET",
-                endpoint: "/volt/api/v1/payments/payment",
-                content_type: "application/json",
-                rate_limit: "global",
-                params: {
-                    id: "string",
-                },
-                callback: async (stream, params) => {
-                    return stream.success({
-                        data: await this._load_payment_for_public(params.id),
-                    });
-                }
-            });
-            // Get payments.
-            this.server.endpoint({
-                method: "GET",
-                endpoint: "/volt/api/v1/payments/payments",
-                content_type: "application/json",
-                authenticated: true,
-                rate_limit: "global",
-                params: {
-                    days: { type: "number", default: 30 },
-                    limit: { type: "number", required: false },
-                    status: { type: "string", required: false, enum: PaymentStatusValues },
-                },
-                callback: async (stream, params) => {
-                    return stream.success({
-                        data: await this.get_payments({
-                            uid: stream.uid,
-                            days: params.days,
-                            limit: params.limit,
-                            status: params.status,
-                        })
-                    });
-                }
-            });
-            // Get refundable payments.
-            this.server.endpoint({
-                method: "GET",
-                endpoint: "/volt/api/v1/payments/payments/refundable",
-                content_type: "application/json",
-                authenticated: true,
-                rate_limit: "global",
-                params: {
-                    days: { type: "number", default: 30 },
-                    limit: { type: "number", required: false },
-                },
-                callback: async (stream, params) => {
-                    return stream.success({
-                        data: await this.get_refundable_payments({
-                            uid: stream.uid,
-                            days: params.days,
-                            limit: params.limit,
-                            for_public: true,
-                        })
-                    });
-                }
-            });
-            // Get refunded payments.
-            this.server.endpoint({
-                method: "GET",
-                endpoint: "/volt/api/v1/payments/payments/refunded",
-                content_type: "application/json",
-                authenticated: true,
-                rate_limit: "global",
-                params: {
-                    days: { type: "number", default: 30 },
-                    limit: { type: "number", required: false },
-                },
-                callback: async (stream, params) => {
-                    return stream.success({
-                        data: await this.get_refunded_payments({
-                            uid: stream.uid,
-                            days: params.days,
-                            limit: params.limit,
-                            for_public: true,
-                        })
-                    });
-                }
-            });
-            // Get refunding payments.
-            this.server.endpoint({
-                method: "GET",
-                endpoint: "/volt/api/v1/payments/payments/refunding",
-                content_type: "application/json",
-                authenticated: true,
-                rate_limit: "global",
-                params: {
-                    days: { type: "number", default: 30 },
-                    limit: { type: "number", required: false },
-                },
-                callback: async (stream, params) => {
-                    return stream.success({
-                        data: await this.get_refunding_payments({
-                            uid: stream.uid,
-                            days: params.days,
-                            limit: params.limit,
-                            for_public: true,
-                        })
-                    });
-                }
-            });
-            // Create a refund.
-            this.server.endpoint({
-                method: "POST",
-                endpoint: "/volt/api/v1/payments/refund",
-                content_type: "application/json",
-                authenticated: true,
-                rate_limit: "global",
-                params: {
-                    payment: { type: ["string", "object"], schema: { id: "string" } },
-                    line_items: { type: "array", required: false, value_schema: {
-                            type: "object", schema: LineItem.Schema
-                        } },
-                    reason: { type: "string", default: "refund" },
-                },
-                callback: async (stream, params) => {
-                    await this.create_refund(typeof params.payment === "string" ? params.payment : params.payment.id, params.line_items, params.reason);
-                    return stream.success();
-                }
-            });
-            // Cancel a subscription.
-            this.server.endpoint({
-                method: "DELETE",
-                endpoint: "/volt/api/v1/payments/subscription",
-                content_type: "application/json",
-                authenticated: true,
-                rate_limit: "global",
-                params: {
-                    product: "string",
-                },
-                callback: async (stream, params) => {
-                    await this.cancel_subscription(stream.uid, params.product);
-                    return stream.success();
-                }
-            });
-            // Cancel a subscription by payment.
-            // {
-            //     method: "DELETE",
-            //     endpoint: "/volt/api/v1/payments/subscription_by_payment",
-            //     content_type: "application/json",
-            //     authenticated: true,
-            //     rate_limit: "global",
-            //     params: {
-            //         payment: {type: ["string", "object"]},
-            //     },
-            //     callback: async (stream, params) => {
-            //         await this.cancel_subscription_by_payment(params.payment);
-            //         return stream.success();
-            //     }
-            // },
-            // Get active subscriptions.
-            this.server.endpoint({
-                method: "GET",
-                endpoint: "/volt/api/v1/payments/active_subscriptions",
-                content_type: "application/json",
-                authenticated: true,
-                rate_limit: "global",
-                callback: async (stream) => {
-                    return stream.success({
-                        data: {
-                            subscriptions: await this.get_active_subscriptions(stream.uid)
-                        },
-                    });
-                }
-            });
-            // Is subscribed
-            this.server.endpoint({
-                method: "GET",
-                endpoint: "/volt/api/v1/payments/subscribed",
-                content_type: "application/json",
-                authenticated: true,
-                rate_limit: "global",
-                params: {
-                    product: "string",
-                },
-                callback: async (stream, params) => {
-                    return stream.success({
-                        data: {
-                            is_subscribed: (await this.is_subscribed(stream.uid, params.product))
-                        }
-                    });
-                }
-            });
-            // Webhook.
-            if (!this.server.offline) {
-                this.server.endpoint(await this._create_webhook());
-            }
-        }
-        /* @performance */ now = this.performance.end("init-endpoints", now);
-        // /* @performance */ this.performance.dump();
-    }
-    // ---------------------------------------------------------
-    // Webhook (private).
-    // Execute a webhook user defined callback.
-    async _exec_user_callback(callback, args) {
-        if (callback != null) {
-            try {
-                let res = callback(args);
-                if (res instanceof Promise) {
-                    res = await res;
-                }
-            }
-            catch (error) {
-                console.error(error);
-            }
-        }
-    }
-    // Send a payment mail.
-    // async _send_payment_mail({payment, subject, attachments = [], mail}) {
-    //     await this.server.send_mail({
-    //         recipients: [payment.billing_details.name == null ? payment.billing_details.email : [payment.billing_details.name, payment.billing_details.email]],
-    //         subject,
-    //         body: mail.html(),
-    //         attachments,
-    //     })
-    // }
-    // On a successfull payment webhook event.
-    async _payment_webhook(data) {
-        // ---------------------------------------------------------
-        // Get the transaction.
-        // Only used in the paid webhook, other parts use the saved payment object.
-        // This is required to manage the statuses of payments.
-        // Make request.
-        let obj = (await this._req("GET", `/transactions/${data.id}`, { include: ["address", "adjustments", "business", "customer"] })).data;
-        // Initialize.
-        const id = `pay_${obj.custom_data.uid == null ? "unauth" : obj.custom_data.uid}_${vlib.String.random(4)}${Date.now()}`;
-        const payment = {
-            id: id, // payment id.
-            uid: obj.custom_data.uid, // user id,
-            cus_id: obj.customer_id, // customer id.
-            tran_id: obj.id, // transaction id.
-            timestamp: Date.now(),
-            status: "unknown", // payment status, possible values are "open" or "paid".
-            line_items: [], // cart line items as {quantity: 1, product: "prod_xxx"}.
-            billing_details: {
-                name: undefined,
-                email: undefined,
-                business: undefined,
-                vat_id: undefined,
-                address: undefined,
-                city: undefined,
-                postal_code: undefined,
-                province: undefined,
-                country: undefined,
-                tax_identifier: undefined,
-            },
-        };
-        // Set business details.
-        if (obj.business != null) {
-            const b = obj.business;
-            if (b != null && b.name != null && b.name.length > 0) {
-                payment.billing_details.business = b.name;
-            }
-            if (b.tax_identifier != null && b.tax_identifier.length > 0) {
-                payment.billing_details.tax_identifier = b.tax_identifier;
-            }
-            if (b.contacts.length > 0) {
-                const contact = b.contacts[0];
-                payment.billing_details.name = contact.name;
-                payment.billing_details.email = contact.email;
-            }
-        }
-        // Set email when not already set.
-        if (payment.billing_details.email == null && obj.customer != null && obj.customer.email != null && obj.customer.email.length > 0) {
-            payment.billing_details.email = obj.customer.email;
-        }
-        // Set name when not already set.
-        if (payment.billing_details.name == null && obj.custom_data.customer_name != null && obj.custom_data.customer_name != null && obj.custom_data.customer_name.length > 0) {
-            payment.billing_details.name = obj.custom_data.customer_name;
-        }
-        // Set address details.
-        if (obj.address != null) {
-            const a = obj.address;
-            if (a.first_line != null && a.first_line.length > 0) {
-                payment.billing_details.address = a.first_line;
-            }
-            if (a.city != null && a.city.length > 0) {
-                payment.billing_details.city = a.city;
-            }
-            if (a.postal_code != null && a.postal_code.length > 0) {
-                payment.billing_details.postal_code = a.postal_code;
-            }
-            if (a.region != null && a.region.length > 0) {
-                payment.billing_details.province = a.region;
-            }
-            if (a.country_code != null && a.country_code.length > 0) {
-                payment.billing_details.country = a.country_code;
-            }
-        }
-        // Set the status.
-        switch (obj.status) {
-            case "draft":
-            case "ready":
-                payment.status = "open";
-                break;
-            case "billed":
-            case "paid":
-            case "completed":
-                payment.status = "paid";
-                break;
-            case "past_due":
-                payment.status = "past_due";
-                break;
-            default:
-                this.server.log.error(`Payment Webhook: Unknown payment status "${obj.status}".`);
-                payment.status = "unknown";
-                break;
-        }
-        // Set line items.
-        obj.details.line_items.iterate((item) => {
-            payment.line_items.push({
-                product: item.product.custom_data.id, // product id, keep as id since we do not want to save the product object to the database since this can change.
-                item_id: item.id, // transaction item id.
-                paddle_prod_id: item.product.id, // paddle product id.
-                quantity: item.quantity,
-                tax_rate: parseFloat(item.tax_rate),
-                tax: item.totals.tax / 100, // should not be changed to unit totals, since mails and invoices depend on this behaviour, just divide by quantity.
-                discount: item.totals.discount / 100, // should not be changed to unit totals, since mails and invoices depend on this behaviour, just divide by quantity.
-                subtotal: item.totals.subtotal / 100, // should not be changed to unit totals, since mails and invoices depend on this behaviour, just divide by quantity.
-                total: item.totals.total / 100, // should not be changed to unit totals, since mails and invoices depend on this behaviour, just divide by quantity.
-                status: "paid", // can be "paid", "refunded", "refunding".
-            });
-        });
-        // Parse refunds.
-        if (obj.adustments != null) {
-            obj.adustments.iterate((adj) => {
-                switch (adj.action) {
-                    case "refund":
-                    case "chargeback":
-                        // case "chargeback_warning":
-                        for (const adj_item of adj.items) {
-                            for (const item of payment.line_items) {
-                                if (adj_item.item_id === item.item_id) {
-                                    item.status = "refunded";
-                                    break;
-                                }
-                            }
-                        }
-                        break;
-                    case "chargeback_reversal":
-                        for (const adj_item of adj.items) {
-                            for (const item of payment.line_items) {
-                                if (adj_item.item_id === item.item_id) {
-                                    item.status = "paid";
-                                    break;
-                                }
-                            }
-                        }
-                        break;
-                    default:
-                        break;
-                }
-            });
-        }
-        // Save the payment object in the database.
-        await this._save_payment(payment);
-        // ---------------------------------------------------------
-        // Process the payment.
-        const { uid } = payment;
-        // Check the payment line items.
-        for (const item of payment.line_items) {
-            const product = this.get_product_sync(item.product, false);
-            // @todo REFUND PAYMENT SINCE PRODUCT WAS NOT FOUND SO NO WAY OF DELIVERY.
-            // Refund the payment since there is no way of delivery.
-            // 1) Product not found.
-            // 2) No subscription id found from the webhook data.
-            if (product == null) {
-                continue;
-            }
-            // Subscription.
-            else if (product.is_subscription) {
-                // No need to activate the sub, this is already handled by the sub activated webhook.
-                //
-                // Cancel the other subscriptions plans that are part of this product.
-                // The `create_payment()` function makes sure there are not multiple subscription plans of the same subscription product charged in a single request.
-                const subscription = await this.get_product(product.subscription_id, true);
-                for (const plan of subscription?.plans ?? []) {
-                    if (plan.id != product.id) {
-                        const { exists, sub_id } = await this._check_subscription(uid, plan.id);
-                        if (exists) {
-                            this.server.log(0, `Cancelling subscription "${plan.id}" due too downgrade/upgrade to "${product.id}" of user "${payment.uid}".`);
-                            // @todo cancel sub by sub id.
-                            await this._cancel_subscription(sub_id);
-                        }
-                    }
-                }
-                // No need to execute the callback, this is already handled by the sub activated webhook.
-                //
-            }
-            // One time payment.
-            else {
-                // Execute callback.
-                await this._exec_user_callback(this.server.on_payment, { product, payment });
-            }
-        }
-        // Send an email to the user.
-        // try {
-        //     await this._send_payment_mail({
-        //         payment, 
-        //         subject: "Payment Successful",
-        //         mail: this.server.on_payment_mail({payment}),
-        //         attachments: [this.generate_invoice_sync(payment)],
-        //     });
-        // } catch (error) {
-        //     console.error(error);
-        // }
-    }
-    // On subscription activated webhook event.
-    // Even though the payment webhook could take care of this, still keep it seperated for customization, and possibly a new activation in certain scenerario's perhaps past due invoice, not sure just in case.
-    async _subscription_webhook(data) {
-        // Vars.
-        const uid = data.custom_data.uid;
-        const subscription = {
-            uid,
-            id: data.id,
-            cus_id: data.customer_id, // customer id.
-            status: "active", // can be "active", "cancelling", "cancelled".
-            plans: [],
-        };
-        // Check the subscription line items.
-        for (const item of data.items) {
-            const product = this._get_product_by_paddle_prod_id(item.price.product_id, false);
-            // Product not found or no sub id found, nothing to do here, the payment webhook already handles this scenario.
-            if (product == null) {
-                this.server.log.error(`Subscription webhook [#sub1]: Unable to find product with id ${item.price.product_id}. This is a serious error which causes a non activated subscription for a paid transaction. You should manually cancel the subscription. Event: ${JSON.stringify(data, null, 4)}.`);
-                continue;
-            }
-            // Subscription.
-            else if (product.is_subscription) {
-                // Add to plans.
-                subscription.plans.append(product.id);
-                // Active the user's subscription in the database.
-                this.server.log(0, `Activating subscription "${product.id}" of user "${subscription.uid}".`);
-                await this._add_subscription(uid, product.id, subscription.id);
-                // No need to cancel other subs, this is already handled by the payment webhook.
-                // Execute callback.
-                await this._exec_user_callback(this.server.on_subscription, { product, subscription });
-            }
-        }
-        // Save subscription.
-        await this._save_subscription(subscription);
-        // No need to send mail, payment webhook already handles this.
-    }
-    // On a subscription cancelled webhook event.
-    async _subscription_cancelled_webhook(data) {
-        // Vars.
-        const subscription = await this._load_subscription(data.id);
-        // Delete subscriptions made by this subscription.
-        for (const plan_id of subscription.plans) {
-            await this._delete_subscription(subscription.uid, plan_id);
-            this.server.log(0, `Deactivating subscription "${plan_id}" of user "${subscription.uid}".`);
-        }
-        // Update database.
-        subscription.status = "cancelled";
-        await this._save_subscription(subscription);
-        // Execute callback.
-        await this._exec_user_callback(this.server.on_cancellation, { subscription });
-        // Send an email to the user.
-        // try {
-        //     await this._send_payment_mail({
-        //         payment, 
-        //         subject: "Cancellation Successful",
-        //         mail: this.server.on_cancellation_mail({payment, line_items}),
-        //     });
-        // } catch (error) {
-        //     console.error(error);
-        // }
-    }
-    // On a adjustment (refunds) updated webhook event.
-    async _adjustment_webhook(data) {
-        // Refund or chageback.
-        const is_refund = data.action === "refund";
-        const is_chargeback = data.action === "chargeback";
-        if (is_refund || is_chargeback) {
-            if (data.status === "pending_approval") {
-                return;
-            }
-            const is_approved = data.status === "approved";
-            // Vars.
-            const payment = await this._load_payment_by_transaction(data.transaction_id);
-            // Get and update line items.
-            const line_items = [], cancel_products = [];
-            for (const adj_item of data.items) {
-                for (const item of payment.line_items) {
-                    if (item.item_id === adj_item.item_id) {
-                        item.status = is_approved ? "refunded" : "paid";
-                        cancel_products.push(item.product);
-                        line_items.push(item);
-                        break;
-                    }
-                }
-            }
-            // Manage subscriptions.
-            if (payment.sub_id != null && is_approved) {
-                await this._cancel_subscription(payment.sub_id, true);
-            }
-            // Update database.
-            if (line_items.length > 0) {
-                await this._save_payment(payment);
-            }
-            // Execute callback.
-            if (is_approved) {
-                this.server.log(0, `Refunded items of payment "${payment.id}" of user "${payment.uid}".`);
-                await this._exec_user_callback(is_refund ? this.server.on_refund : this.server.on_chargeback, { payment, line_items });
-                // try {
-                //     await this._send_payment_mail({
-                //         payment, 
-                //         subject: "Successful " + (is_refund ? "Refund" : "Chargeback"),
-                //         mail: is_refund ? this.server.on_refund_mail({payment, line_items}) : this.server.on_chargeback_mail({payment, line_items}),
-                //     });
-                // } catch (error) {
-                //     console.error(error);
-                // }
-            }
-            else {
-                this.server.log(0, `Refund denied for items of payment ${payment.id} of user "${payment.uid}".`);
-                await this._exec_user_callback(is_refund ? this.server.on_failed_refund : this.server.on_failed_chargeback, { payment, line_items });
-                // try {
-                //     await this._send_payment_mail({
-                //         payment, 
-                //         subject: "Failed " + (is_refund ? "Refund" : "Chargeback"),
-                //         mail: is_refund ? this.server.on_failed_refund_mail({payment, line_items}) : this.server.on_failed_chargeback_mail({payment, line_items}),
-                //     });
-                // } catch (error) {
-                //     console.error(error);
-                // }
-            }
-        }
-        // Chargeback reversal.
-        else if (data.action === "chargeback_reverse" && data.status === "reversed") {
-            // Vars.
-            const payment = await this._load_payment_by_transaction(data.transaction_id);
-            // Log reactivation subscriptions on chargeback reverse.
-            if (payment.sub_id != null) {
-                this.server.log(0, `Chargeback reversed for payment ${payment.id} from user "${payment.uid}".`);
-                // @todo.
-            }
-            // Get and update line items.
-            let line_items = [];
-            for (const adj_item of data.items) {
-                for (const item of payment.line_items) {
-                    if (item.item_id === adj_item.item_id) {
-                        item.status = "paid";
-                        line_items.push(item);
-                    }
-                }
-            }
-            // Update database.
-            if (line_items.length > 0) {
-                await this._save_payment(payment);
-            }
-        }
-    }
-    // Create and register the webhook endpoint.
-    async _create_webhook() {
-        /* @performance */ const now = this.performance.start();
-        // Register the webhook.
-        const webhook_settings = {
-            description: "volt webhook",
-            destination: `${this.server.full_domain}/volt/payments/webhook`,
-            type: "url",
-            subscribed_events: [
-                // "transaction.billed",
-                // "transaction.canceled",
-                // "transaction.completed",
-                // "transaction.created",
-                "transaction.paid",
-                // "transaction.past_due",
-                // "transaction.payment_failed",
-                // "transaction.ready",
-                // "transaction.updated",
-                "subscription.activated",
-                "subscription.canceled",
-                // "subscription.created",
-                // "subscription.imported",
-                // "subscription.past_due",
-                "subscription.paused",
-                "subscription.resumed",
-                "subscription.trialing",
-                // "subscription.updated",
-                "adjustment.updated",
-            ],
-        };
-        const hashed_webhook_settings = this.server.hash(webhook_settings);
-        // Register webhook.
-        const register_webhook = async () => {
-            this.server.log(0, "Registering payments webhook.");
-            const response = await this._req("POST", "/notification-settings", webhook_settings);
-            this.webhook_key = response.data.endpoint_secret_key;
-            await this._webhook_conf_db.set({ production: this.server.production, version: 1 }, {
-                id: response.data.id,
-                key: this.webhook_key,
-                hash: this.server.hash(webhook_settings),
-            });
-        };
-        // For speeding up the restart process we store the hash of the previous webhook under a temporary document.
-        const home_dir = vlib.Path.home().join(".volt/cache");
-        if (!home_dir.exists()) {
-            home_dir.mkdir({ recursive: true });
-        }
-        const cached_local_hash_file = home_dir.join(`paddle_webhook_${this.server.production ? "live" : "sandbox"}.hash`);
-        const cached_local_hash = cached_local_hash_file.exists() ? (await cached_local_hash_file.load()) : null;
-        if (cached_local_hash !== hashed_webhook_settings) {
-            // Load webhook doc.
-            const webhook_doc = await this._webhook_conf_db.load({ production: this.server.production, version: 1 }, { throw: false });
-            if (webhook_doc instanceof Error && !(webhook_doc instanceof Collection.NotFoundError)) {
-                throw webhook_doc;
-            }
-            // Webhook registered.
-            if (!(webhook_doc instanceof Collection.NotFoundError)) {
-                this.webhook_key = webhook_doc.key;
-                // Check update required.
-                if (webhook_doc.hash !== hashed_webhook_settings) {
-                    this.server.log(0, `Checking payments webhook.`);
-                    // Check update required.
-                    const webhook_id = webhook_doc.id;
-                    let registered;
-                    try {
-                        registered = await this._req("GET", `/notification-settings/${webhook_id}`);
-                    }
-                    catch (error) {
-                        if (error.status === 404 || error.status_code === 404) {
-                            registered = undefined;
-                            await register_webhook();
-                        }
-                        else {
-                            throw error;
-                        }
-                    }
-                    if (registered) {
-                        const item = registered.data;
-                        const patch = (() => {
-                            if (item.active !== true ||
-                                item.destination !== webhook_settings.destination ||
-                                item.type !== webhook_settings.type ||
-                                item.description !== webhook_settings.description ||
-                                item.subscribed_events.length != webhook_settings.subscribed_events.length) {
-                                return true;
-                            }
-                            let has_subscribed_event_missing = false;
-                            for (const x of webhook_settings.subscribed_events) {
-                                let found = false;
-                                for (const y of item.subscribed_events) {
-                                    if (x === y.name) {
-                                        found = true;
-                                        break;
-                                    }
-                                }
-                                if (found === false) {
-                                    has_subscribed_event_missing = true;
-                                    break;
-                                }
-                            }
-                            return has_subscribed_event_missing;
-                        })();
-                        // Update.
-                        if (patch === true) {
-                            this.server.log(0, "Updating payments webhook.");
-                            await this._req("PATCH", `/notification-settings/${webhook_id}`, { ...webhook_settings, active: true });
-                        }
-                        // Save new hash.
-                        await this._webhook_conf_db.set({ production: this.server.production, version: 1 }, { hash: this.server.hash(webhook_settings) });
-                    }
-                }
-            }
-            // Register webhook.
-            else {
-                await register_webhook();
-            }
-            // Save the new hash.
-            await cached_local_hash_file.save(hashed_webhook_settings);
-        }
-        // Ip whitelist.
-        const ip_whitelist = [
-            // Live.
-            "34.232.58.13",
-            "34.195.105.136",
-            "34.237.3.244",
-            "35.155.119.135",
-            "52.11.166.252",
-            "34.212.5.7",
-            // Sandbox.
-            "34.194.127.46",
-            "54.234.237.108",
-            "3.208.120.145",
-            "44.226.236.210",
-            "44.241.183.62",
-            "100.20.172.113",
-        ];
-        /* @performance */ this.server.performance.end("create-payments-webhook", now);
-        // Create the endpoint.
-        return {
-            method: "POST",
-            endpoint: "/volt/api/v1/payments/webhook",
-            content_type: "application/json",
-            rate_limit: undefined,
-            callback: async (stream) => {
-                // Ip whitelist.
-                if (ip_whitelist.includes(stream.ip) === false) {
-                    this.server.log(0, `POST:/volt/payments/webhook: Warning: Blocking non whitelisted ip "${stream.ip}".`);
-                    return stream.error({ status: Status.unauthorized });
-                }
-                // Verify.
-                const full_signature = stream.headers["paddle-signature"];
-                if (full_signature == null) {
-                    this.server.log(0, "POST:/volt/payments/webhook: Error: No paddle signature found in the request headers.");
-                    return stream.error({ status: Status.unauthorized, data: { error: "Webhook signature verification failed." } });
-                }
-                const ts_index = full_signature.indexOf(";");
-                const ts = full_signature.substr(3, ts_index - 3);
-                const signature = full_signature.substr(ts_index + 4);
-                const digest = libcrypto.createHmac("sha256", this.webhook_key).update(`${ts}:${stream.body}`).digest("hex");
-                if (libcrypto.timingSafeEqual(Buffer.from(digest, "hex"), Buffer.from(signature, "hex")) !== true) {
-                    this.server.log(0, "POST:/volt/payments/webhook: Error: Webhook signature verification failed.");
-                    return stream.error({ status: Status.unauthorized, data: { error: "Webhook signature verification failed." } });
-                }
-                // Process items.
-                const event = JSON.parse(stream.body);
-                switch (event.event_type) {
-                    // Paid transaction.
-                    // https://developer.paddle.com/webhooks/transactions/transaction-paid
-                    case "transaction.paid":
-                        await this._payment_webhook(event.data);
-                        break;
-                    // Subscription activated.
-                    // https://developer.paddle.com/webhooks/subscriptions/subscription-activated
-                    case "subscription.activated":
-                    case "subscription.trialing":
-                    case "subscription.resumed":
-                        await this._subscription_webhook(event.data);
-                        break;
-                    // Subscription canceled.
-                    // https://developer.paddle.com/webhooks/subscriptions/subscription-canceled
-                    case "subscription.canceled":
-                    case "subscription.paused":
-                        await this._subscription_cancelled_webhook(event.data);
-                        break;
-                    // Adjustment updated (refunds).
-                    // https://developer.paddle.com/webhooks/subscriptions/subscription-canceled
-                    case "adjustment.updated":
-                        await this._adjustment_webhook(event.data);
-                        break;
-                    // Default.
-                    default: break;
-                }
-                // Success.
-                stream.success({ data: { message: "OK" } });
-            },
-        };
-    }
-    async get_product(id, throw_err = false) {
-        return this.get_product_sync(id, throw_err);
-    }
-    get_product_sync(id, throw_err = false) {
-        let product = null;
-        for (const p of this.products) {
-            if (p.is_subscription) {
-                if (p.id === id) {
-                    product = p;
-                    break;
-                }
-                for (const plan of p.plans) {
-                    if (plan.id === id) {
-                        product = plan;
-                        break;
-                    }
-                }
-            }
-            else if (p.id === id) {
-                product = p;
-                break;
-            }
-        }
-        if (product == null && throw_err) {
-            throw Error(`Unable to find product "${id}".`);
-        }
-        return product;
-    }
-    /*  @docs:
-        @title: Get Payment.
-        @desc: Get a payment by id.
-        @param:
-            @name: id
-            @required: true
-            @type: string
-            @desc: The id of the payment.
-    */
-    async get_payment(id, opts) {
-        if (opts?.for_public) {
-            return await this._load_payment_for_public(id);
-        }
-        return await this._load_payment(id);
-    }
-    /*  @docs:
-        @title: Get Refunded Payments.
-        @desc:
-            Get all payments.
-
-            All failed payments are no longer stored in the database.
-        @param:
-            @name: uid
-            @cached: Users:uid:param
-        @param:
-            @name: days
-            @type: number
-            @desc: Retrieve payments from the last amount of days.
-        @param:
-            @name: limit
-            @type: number
-            @desc: Limit the amount of response payment objects.
-        @param:
-            @name: status
-            @type: string, array[string]
-            @desc: Filter the payments by status. Be aware that the line items of a payment also have a status with possible values of `open`, `cancelled`, `refunding` or `refunded.`
-            @enum:
-                @value: "open"
-                @desc: Payments that are still open and unpaid.
-            @enum:
-                @value: "paid"
-                @desc: Payments that are paid.
-    */
-    async get_payments({ uid, days = 30, limit = 10_000, status = undefined, for_public, }) {
-        // Get path.
-        const query = {
-            uid,
-        };
-        if (days != null) {
-            const since = new Date();
-            since.setHours(0, 0, 0, 0);
-            query.timestamp = { $gte: Math.floor(since.getTime() - (3600 * 24 * 1000 * days)) };
-        }
-        if (Array.isArray(status)) {
-            query.status = { $in: status };
-        }
-        else if (typeof status === "string") {
-            query.status = status;
-        }
-        const payments = await this._pay_db.list(query, { limit });
-        // Sort.
-        payments.sort((a, b) => b.timestamp - a.timestamp);
-        // Response.
-        return (for_public
-            ? payments.map(p => Payment.anonymize(p))
-            : payments);
-    }
-    /*  @docs:
-        @title: Get Refundable Payments.
-        @desc: Get all payments that are refundable.
-        @param:
-            @name: uid
-            @cached: Users:uid:param
-        @param:
-            @name: days
-            @type: number
-            @desc: Retrieve payments from the last amount of days.
-        @param:
-            @name: limit
-            @type: number
-            @desc: Limit the amount of response payment objects.
-    */
-    async get_refundable_payments({ uid, days = 30, limit = undefined, for_public, }) {
-        const out = [];
-        const all_payments = await this.get_payments({ uid, days, limit, status: "paid", for_public });
-        for (const pmt of all_payments) {
-            const refundable = pmt.line_items.filter((li) => li.status === "paid" && li.total > 0);
-            if (refundable.length > 0) {
-                out.push({ ...pmt, line_items: refundable });
-            }
-        }
-        return out;
-    }
-    /*  @docs:
-        @title: Get Refunded Payments.
-        @desc: Get all payments that are successfully refunded.
-        @param:
-            @name: uid
-            @cached: Users:uid:param
-        @param:
-            @name: days
-            @type: number
-            @desc: Retrieve payments from the last amount of days.
-        @param:
-            @name: limit
-            @type: number
-            @desc: Limit the amount of response payment objects.
-    */
-    async get_refunded_payments({ uid, days = 30, limit = undefined, for_public, }) {
-        const out = [];
-        const all_payments = await this.get_payments({ uid, days, limit, status: "paid", for_public });
-        for (const pmt of all_payments) {
-            const refundable = pmt.line_items.filter((li) => li.status === "refunded" && li.total > 0);
-            if (refundable.length > 0) {
-                out.push({ ...pmt, line_items: refundable });
-            }
-        }
-        return out;
-    }
-    /*  @docs:
-        @title: Get Refunding Payments.
-        @desc: Get all payments that are currently in the refunding process.
-        @param:
-            @name: uid
-            @cached: Users:uid:param
-        @param:
-            @name: days
-            @type: number
-            @desc: Retrieve payments from the last amount of days.
-        @param:
-            @name: limit
-            @type: number
-            @desc: Limit the amount of response payment objects.
-    */
-    async get_refunding_payments({ uid, days = undefined, limit = undefined, for_public, }) {
-        const out = [];
-        const all_payments = await this.get_payments({ uid, days, limit, status: "paid", for_public });
-        for (const pmt of all_payments) {
-            const refundable = pmt.line_items.filter((li) => li.status === "refunding" && li.total > 0);
-            if (refundable.length > 0) {
-                out.push({ ...pmt, line_items: refundable });
-            }
-        }
-        return out;
-    }
-    /*  @docs:
-        @title: Refund Payment.
-        @desc: Refund a payment based on the payment id.
-        @warning: Refunding a subscription will also cancel all other subscriptions that were created by the same payment request.
-        @param:
-            @name: payment
-            @required: true
-            @type: number
-            @desc: The id of the payment object or the payment object itself.
-        @param:
-            @name: line_items
-            @type: array[object]
-            @desc: The line items to refund, these must be retrieved from the original payment line items otherwise it may cause undefined behaviour. When undefined the entire payment will be refunded.
-        @param:
-            @name: reason
-            @type: string
-            @desc: The refund reason for internal analytics.
-    */
-    async create_refund(payment, line_items = undefined, reason = "refund") {
-        // Load payment.
-        // The payment must be loaded from the database in case the line items or anything were edited by the user, such as dropping all non refundable line items.
-        if (typeof payment === "string") {
-            payment = await this._load_payment(payment);
-        }
-        else {
-            payment = await this._load_payment(payment.id);
-        }
-        // When no line items are defined than refund everything.
-        if (line_items == null) {
-            line_items = payment.line_items;
-        }
-        // Check empty line items.
-        if (line_items.length === 0) {
-            throw Error("No refund line items array is empty.");
-        }
-        // Parse line items.
-        const items = [];
-        const item_ids = [];
-        for (const item of line_items) {
-            // Skip when the item is already being refunded.
-            if (item.status === "refunded" || item.status === "refunding") { //  || item.status === "cancelled" || item.status === "cancelling"
-                continue;
-            }
-            // Add to structured line items.
-            item_ids.push(item.item_id);
-            items.push({
-                item_id: item.item_id,
-                type: "full", // partial refudings are not supported per line item since there is no convenient way to keep track of how much is refunded.
-            });
-        }
-        // Check empty line items.
-        if (items.length === 0) {
-            throw Error("This payment no longer has any refundable line items.");
-        }
-        // Make request.
-        const response = await this._req("POST", `/adjustments`, {
-            action: "refund",
-            transaction_id: payment.tran_id,
-            reason,
-            items,
-            custom_data: {
-                uid: payment.uid,
-            }
-        });
-        if (response.data.status === "rejected") {
-            throw Error("This payment is no longer refundable.");
-        }
-        else if (response.data.status === "approved") {
-            for (const item of payment.line_items) {
-                if (line_items.find((i) => i.item_id === item.item_id)) {
-                    item.status = "refunded";
-                }
-            }
-        }
-        else {
-            for (const item of payment.line_items) {
-                if (line_items.find((i) => i.item_id === item.item_id)) {
-                    item.status = "refunding";
-                }
-            }
-        }
-        // Update the payment object.
-        await this._save_payment(payment);
-    }
-    /*  @docs:
-        @title: Cancel Subscription.
-        @desc: Cancel a subscription based on the retrieved payment object or id.
-        @warning: Cancelling a subscription will also cancel all other subscriptions that were created by the same payment request.
-        @param:
-            @name: uid
-            @cached: Users:uid:param
-        @param:
-            @name: products
-            @required: true
-            @type: string, array[string, object]
-            @desc: The product to cancel, the product ids to cancel or the product objects to cancel.
-    */
-    async cancel_subscription(uid, products, _throw_no_cancelled_err = true) {
-        if (products == null) {
-            throw new Error("Parameter \"products\" should be a defined value of type \"array[string, object]\".");
-        }
-        if (typeof products === "string") {
-            products = [products];
-        }
-        let cancelled = [];
-        for (let product of products) {
-            if (typeof product === "object") {
-                product = product.id;
-            }
-            const { exists, sub_id } = await this._check_subscription(uid, product);
-            if (exists && cancelled.includes(sub_id) === false) {
-                await this._cancel_subscription(sub_id);
-                cancelled.push(sub_id);
-            }
-        }
-        ;
-        if (_throw_no_cancelled_err && cancelled.length === 0) {
-            throw new ExternalError({
-                type: "NoCancellableSubscriptions",
-                message: "No cancellable subscriptions found.",
-                status: Status.bad_request,
-            });
-        }
-    }
-    /*  @docs:
-        @title: Cancel subscription by subscription id.
-        @desc: Cancel a subscription based on the retrieved subscription object or id.
-        @warning: Cancelling a subscription will also cancel all other subscriptions that were created by the same payment request.
-        @param:
-            @name: subscription
-            @required: true
-            @type: string, object
-            @desc: The retrieved subscription object or the subscription's id.
-        @param:
-            @name: immediate
-            @type: boolean
-            @desc: Immediately cancel the subscription, or wait till the end of the billing cycle.
-    */
-    async cancel_subscription_by_id(subscription, immediate = false) {
-        if (typeof subscription === "object") {
-            subscription = subscription.id;
-        }
-        return await this._cancel_subscription(subscription, immediate);
-    }
-    /*  @docs:
-        @title: Get active subscriptions
-        @desc: Get the active subscriptions of a user.
-        @param:
-            @name: uid
-            @cached: Users:uid:param
-    */
-    async get_active_subscriptions(uid) {
-        return await this._get_active_subscriptions(uid);
-    }
-    /*  @docs:
-        @title: Get all subscriptions
-        @desc: Get all subscriptions of a user, active and inactive.
-        @param:
-            @name: uid
-            @cached: Users:uid:param
-    */
-    async get_subscriptions(uid) {
-        return await this._get_subscriptions(uid);
-    }
-    /*  @docs:
-        @title: Is Subscribed
-        @desc: Check if a user is subscribed to a product.
-        @param:
-            @name: uid
-            @cached: Users:uid:param
-        @param:
-            @name: product
-            @required: true
-            @type: string
-            @desc: The product id.
-    */
-    async is_subscribed(uid, product) {
-        return await this._check_subscription(uid, product, false);
-    }
-    /*  @docs:
-        @title: Generate Invoice
-        @desc:
-            Generate an invoice for a paid payment.
-
-            By default an invoice is already generated when a payment has been paid.
-        @param:
-            @name: payment
-            @required: true
-            @type: object
-            @desc: The payment object.
-        @return:
-            @type: Promise
-            @desc: This function returns a promise to the invoice pdf in bytes.
-    */
-    async generate_invoice(payment) {
-        // Check arg..
-        if (payment == null || typeof payment !== "object") {
-            throw Error(`Parameter "payment" should be a defined value of type "object".`);
-        }
-        // Vars.
-        let currency;
-        let subtotal = 0;
-        let subtotal_tax = 0;
-        let total = 0;
-        for (const item of payment.line_items) {
-            if (typeof item.product === "string") {
-                item.product = this.get_product_sync(item.product, true);
-            }
-            if (currency == null) {
-                const c = Utils.get_currency_symbol(item.product.currency);
-                if (c == null) {
-                    throw new Error(`Unable to determine the currency symbol for "${item.product.currency}".`);
-                }
-                currency = c;
-            }
-            subtotal += item.subtotal;
-            subtotal_tax += item.tax;
-            total += item.total;
-        }
-        let total_due = payment.status === "open" ? total : 0;
-        let doc = new PDFDocument({ size: "A4", margin: 50 });
-        let expanded_payment = payment;
-        /* Doc vars. */
-        let top_offset = 57;
-        let spacing = 10;
-        // Wrapper func.
-        const gen_text = (text, x, y = null, opts = null, _spacing = null) => {
-            if (y == null) {
-                y = top_offset;
-            }
-            else {
-                top_offset = y;
-            }
-            if (_spacing == null) {
-                _spacing = spacing;
-            }
-            doc.text(text, x, y, opts);
-            top_offset += doc.heightOfString(text, x, y, opts) + (_spacing == null ? spacing : _spacing);
-        };
-        const gen_col_text = (text, x, opts = null, is_last = false, _spacing = 2) => {
-            doc.text(text, x, top_offset, opts);
-            if (is_last) {
-                top_offset += doc.heightOfString(text, x, top_offset, opts) + (_spacing == null ? spacing : _spacing);
-            }
-            else {
-                return doc.heightOfString(text, x, top_offset, opts);
-            }
-        };
-        const gen_divider = (_spacing = null) => {
-            doc
-                .strokeColor("#aaaaaa")
-                .lineWidth(1)
-                .moveTo(50, top_offset)
-                .lineTo(550, top_offset)
-                .stroke();
-            top_offset += 1 + (_spacing == null ? spacing : _spacing);
-        };
-        const gen_line_item = ({ name = "", desc = "", unit_cost = "", quantity = "", total_cost = "" }) => {
-            const items = [
-                [0.25, name],
-                [0.35, desc],
-                [0.4 / 3, unit_cost],
-                [0.4 / 3, quantity],
-                [0.4 / 3, total_cost],
-            ];
-            let x = 50;
-            let max_height = 0;
-            const full_width = (550 - 50) - (10 * 4);
-            // Get max height.
-            for (const item of items) {
-                max_height = Math.max(max_height, doc.heightOfString(item[1], x, top_offset, { width: full_width * item[0], align: "left" }));
-                x += (full_width * item[0]) + 10;
-            }
-            // Check if a new page should be added.
-            if (top_offset + max_height + 10 > doc.page.height - 50) {
-                doc.addPage();
-                top_offset = 50;
-            }
-            // Add items.
-            x = 50;
-            for (const item of items) {
-                gen_col_text(item[1], x, { width: full_width * item[0], align: "left" });
-                x += (full_width * item[0]) + 10;
-            }
-            // Add top offset.
-            top_offset += max_height + spacing;
-        };
-        const format_date = (date) => {
-            return `${date.getDate()}/${date.getMonth() + 1}/${date.getFullYear()}`;
-        };
-        // Header.
-        doc.fillColor("#444444");
-        doc.fontSize(20);
-        if (this.server.company.stroke_icon_path != null) {
-            doc.image(this.server.company.stroke_icon_path, 50, top_offset - 2, { width: 60 });
-        }
-        else {
-            if (this.server.company.icon_path != null) {
-                doc.image(this.server.company.icon_path, 50, top_offset - 2, { width: 18 });
-            }
-            gen_text(this.server.company.legal_name, 50 + 18 + 10);
-        }
-        top_offset += 15;
-        // From (left).
-        const start_top_offset = top_offset;
-        doc.fillColor("#444444");
-        doc.fontSize(10);
-        doc.font("Helvetica-Bold");
-        gen_text("From", 50, null, null, 3);
-        doc.font("Helvetica");
-        gen_text(this.server.company.legal_name, 50, null, { align: "left" }, 2);
-        gen_text(`${this.server.company.street}, ${this.server.company.postal_code}`, 50, null, { align: "left" }, 2);
-        gen_text(`${this.server.company.city}, ${this.server.company.province}, ${this.server.company.country}`, 50, null, { align: "left" }, 2);
-        gen_text(`VAT ID: ${this.server.company.tax_id}`, 50, null, { align: "left" }, 2);
-        const left_top_offset = top_offset;
-        // Invoice details (right).
-        top_offset = start_top_offset;
-        doc.fillColor("#444444");
-        doc.fontSize(10);
-        doc.font("Helvetica-Bold");
-        gen_text("Invoice details", 550 - (150 + 10 + 80), null, null, 3);
-        doc.font("Helvetica");
-        for (const item of [
-            ["Invoice:", expanded_payment.id],
-            ["Date of issue:", format_date(new Date())],
-        ]) {
-            gen_col_text(item[0], 550 - (150 + 10 + 80), { width: 80 });
-            gen_col_text(item[1], 550 - 150, { width: 150 }, true);
-        }
-        // Go down.
-        top_offset = Math.max(top_offset, left_top_offset) + 25;
-        // Billing details.
-        doc.fillColor("#444444");
-        doc.fontSize(10);
-        doc.font("Helvetica-Bold");
-        gen_text("Billing Details", 50, null, null, 3);
-        doc.font("Helvetica");
-        if (expanded_payment.billing_details.business != null) {
-            gen_text(`${expanded_payment.billing_details.business}`, 50, null, { align: "left" }, 2);
-        }
-        else {
-            gen_text(`${expanded_payment.billing_details.name}`, 50, null, { align: "left" }, 2);
-        }
-        gen_text(expanded_payment.billing_details.email, 50, null, { align: "left" }, 2);
-        gen_text(`${expanded_payment.billing_details.address}`, 50, null, { align: "left" }, 2);
-        gen_text(`${expanded_payment.billing_details.city}, ${expanded_payment.billing_details.province}, ${expanded_payment.billing_details.country}`, 50, null, { align: "left" }, 2);
-        if (expanded_payment.billing_details.vat_id != null) {
-            gen_text(`${expanded_payment.billing_details.vat_id}`, 50, null, { align: "left" }, 2);
-        }
-        // Go down.
-        top_offset += 35;
-        // Line items.
-        doc.font("Helvetica-Bold");
-        gen_line_item({
-            name: "Item",
-            desc: "Description",
-            unit_cost: "Unit Cost",
-            quantity: "Quantity",
-            total_cost: "Line Total",
-        });
-        top_offset -= spacing * 0.5;
-        doc.font("Helvetica");
-        gen_divider();
-        for (const item of expanded_payment.line_items) {
-            gen_line_item({
-                name: item.product.name,
-                desc: item.product.description,
-                unit_cost: `${currency} ${(item.subtotal / item.quantity).toFixed(2)}`,
-                quantity: item.quantity.toString(),
-                total_cost: `${currency} ${item.total.toFixed(2)}`,
-            });
-            top_offset += 10;
-            gen_divider();
-        }
-        ;
-        gen_line_item({ unit_cost: "Subtotal:", total_cost: `${currency} ${subtotal.toFixed(2)}` });
-        top_offset -= (spacing - 3);
-        gen_line_item({ unit_cost: "Taxes:", total_cost: `${currency} ${subtotal_tax.toFixed(2)}` });
-        top_offset -= (spacing - 3);
-        gen_line_item({ unit_cost: "Total:", total_cost: `${currency} ${total.toFixed(2)}` });
-        top_offset -= (spacing - 3);
-        doc.font("Helvetica-Bold");
-        gen_line_item({ unit_cost: "Total Due:", total_cost: `${currency} ${total_due.toFixed(2)}` });
-        top_offset -= (spacing - 3);
-        // Write to file.
-        // doc.end();
-        // doc.pipe(fs.createWriteStream(path.str()));
-        // return path;
-        // Get as bytes.
-        const chunks = [];
-        return await new Promise((resolve, reject) => {
-            doc.on("data", (chunk) => chunks.push(chunk));
-            doc.on("end", () => resolve(Buffer.concat(chunks)));
-            doc.on("error", (err) => reject(err));
-            doc.end();
-        });
-        // const stream = doc.pipe(blobstream());
-        // doc.end();
-        // return new Promise((resolve, reject) => {
-        //     stream.on('finish', () => {
-        //         const bytes = stream.toBuffer();
-        //         resolve(bytes);
-        //     });
-        //     stream.on('error', (error) => {
-        //         reject(error);
-        //     });
-        // });
-    }
-    // ---------------------------------------------------------
-    // Development.
-    // Cancel all subscriptions to clear development environment.
-    async dev_cancel_all_subscriptions() {
-        if (!this.sandbox) {
-            throw new Error("This function is only for a sandbox environment.");
-        }
-        // Fetch.
-        let subs = [], after = null;
-        while (true) {
-            const response = await this._req("GET", "/subscriptions", after == null ? { per_page: 100 } : { per_page: 100, after });
-            subs = subs.concat(response.data);
-            if (!response.meta.has_more) {
-                break;
-            }
-            after = subs.last().id;
-        }
-        // Cancel.
-        for (const sub of subs) {
-            if (sub.status === "active") {
-                this.server.log("Cancelling subscription ", sub.id);
-                await this._req("POST", `/subscriptions/${sub.id}/cancel`, {
-                    effective_from: "immediately",
-                });
-            }
-        }
-    }
-}
-/** Nested types for the {@link Paddle} class */
-(function (Paddle) {
-    /** Paddle api request error. */
-    class RequestError extends Error {
-        status_code;
-        constructor(err, status_code) {
-            super(err);
-            this.status_code = status_code;
-        }
-    }
-    Paddle.RequestError = RequestError;
-})(Paddle || (Paddle = {}));
-// APPLY_FIX
-/**
- * @todo if undeprecate: ASK claude to audit.
- */