@vandenberghinc/volt 1.1.26 → 1.1.28

package/backend/dist/esm/{payments → backend/src/payments}/paddle.js

@@ -1,143 +1,66 @@
-/*
- * Author: Daan van den Bergh
- * Copyright: © 2022 - 2024 Daan van den Bergh.
+/**
+ * @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 blobstream from 'blob-stream';
 import * as vlib from "@vandenberghinc/vlib";
-import { Utils, ExternalError } from "../utils.js";
-import { logger } from "../logger.js";
+import { ExternalError } from "../errors/index.js";
 import { Status } from "../status.js";
-const { log, error } = logger;
-// Request error.
-class RequestError extends Error {
-    status_code;
-    constructor(err, status_code) {
-        super(err);
-        this.status_code = status_code;
+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.
-/*  @docs:
-    @nav: Backend
-    @chapter: Payments
-    @title: Paddle
-    @description:
-        The paddle payments class.
-
-        Sandbox env: https://sandbox-vendors.paddle.com
-    @param:
-        @name: api_key
-        @type: string
-        @description: Your paddle api key.
-        @required: true
-    @param:
-        @name: client_key
-        @type: string
-        @description: Your paddle client key.
-        @required: true
-    @param:
-        @name: sandbox
-        @type: boolean
-        @description: Enable the sandbox environment.
-    @param:
-        @name: inclusive_tax
-        @type: boolean
-        @description: Enable when prices are inclusive tax.
-    @param:
-        @name: products
-        @type: object
-        @warning: The payment product objects are accessable by anyone through the backend rest api so they should not contain any sensitive data.
-        @attributes_type: ProductObject
-        @attribute:
-            @name: id
-            @type: string
-            @required: true
-            @desc: The id of product
-            @warning: The id can not be changed
-            @warning: The id must be unique across all your products.
-        @attribute:
-            @name: name
-            @type: string
-            @required: true
-            @desc: The name of the product.
-        @attribute:
-            @name: price
-            @type: number
-            @required: true
-            @desc: The price of the product, digits after the decimal are the minor units (e.g. cents).
-        @attribute:
-            @name: currency
-            @type: string
-            @required: true
-            @desc: The ISO currency code of the price.
-        @attribute:
-            @name: tax_category
-            @type: string
-            @required: true
-            @desc: The tax category https://developer.paddle.com/api-reference/products/create-product.
-        @attribute:
-            @name: icon
-            @type: string
-            @desc: The icon url of the product, may also be an endpoint url of your website.
-        @attribute:
-            @name: frequency
-            @type: number
-            @desc: The recurring frequency, when this is defined a product will become a subscription product.
-        @attribute:
-            @name: interval
-            @type: string
-            @desc: The recurring interval, when this is defined a product will become a subscription product.
-            @enum:
-                @value: "day"
-                @desc: Use this value to create a subscription product that renews at a daily interval.
-            @enum:
-                @value: "week"
-                @desc: Use this value to create a subscription product that renews at a weekly interval.
-            @enum:
-                @value: "month"
-                @desc: Use this value to create a subscription product that renews at a monthly interval.
-            @enum:
-                @value: "year"
-                @desc: Use this value to create a subscription product that renews at a yearly interval.
-        @attribute:
-            @name: trial
-            @type: null, object
-            @desc: The trial settings for this product. Leave undefined to disable a trialing period. This attribute will be ignored for one-time payments.
-            @attribute:
-                @name: frequency
-                @type: number
-                @desc: The trial frequency.
-            @attribute:
-                @name: interval
-                @type: string
-                @desc: The trial interval.
-                @enum:
-                    @value: "day"
-                    @desc: Daily interval.
-                @enum:
-                    @value: "week"
-                    @desc: Weekly interval.
-                @enum:
-                    @value: "month"
-                    @desc: Monthly interval.
-                @enum:
-                    @value: "year"
-                    @desc: Yearly interval.
-        @attribute:
-            @name: plans
-            @type: array[ProductObject]
-            @desc: The plans for this subscription product. Every item is a product object. However, attributes `currency`, `frequency`, `interval`, `tax_category` and `icon` can either be defined in the subscription product or on each individual plan.
-    @parameter:
-        @name: _server
-        @ignore: true
-*/
+/**
+ * The paddle payments class.
+ *
+ * Sandbox env: https://sandbox-vendors.paddle.com
+ *
+ * @nav Backend/Payments
+ * @docs
+ * @deprecated Using stripe from now on.
+ */
 export class Paddle {
     type;
     client_key;
@@ -149,16 +72,21 @@ export class Paddle {
     _headers;
     webhook_key;
     _has_create_products_permission;
-    _settings_db;
+    _last_products_db;
+    _webhook_conf_db;
     _sub_db;
     _active_sub_db;
     _pay_db;
-    // private _inv_db?: Collection;
+    // private _inv_db: Collection;
     performance;
-    constructor({ api_key, client_key, sandbox = false, products = [], inclusive_tax = false, _server = null, }) {
+    constructor({ api_key, client_key, sandbox = false, products = [], inclusive_tax = false, _server, }) {
         // Original constructor implementation remains the same
         // Verify args.
-        vlib.Scheme.validate(arguments[0], { strict: true, parent: "payments", scheme: {
+        vlib.schema.validate(arguments[0], {
+            unknown: false,
+            throw: true,
+            parent: "payments",
+            schema: {
                 type: { type: "string", default: "paddle" },
                 api_key: "string",
                 client_key: "string",
@@ -166,7 +94,8 @@ export class Paddle {
                 inclusive_tax: { type: "boolean", default: false },
                 products: "array",
                 _server: "object",
-            } });
+            }
+        });
         // Attributes.
         this.type = "paddle";
         this.client_key = client_key;
@@ -186,6 +115,31 @@ export class Paddle {
         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");
     }
     // ---------------------------------------------------------
@@ -194,11 +148,28 @@ export class Paddle {
     // 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: this._host,
-                path: method === "GET" && params != null ? `${endpoint}?${new URLSearchParams(params).toString()}` : endpoint,
+                hostname,
+                path,
                 port: 443,
                 headers: this._headers,
             };
@@ -211,7 +182,7 @@ export class Paddle {
                 response.on('end', () => {
                     if (response?.statusCode >= 200 && response?.statusCode < 300) {
                         try {
-                            resolve(JSON.parse(data));
+                            resolve(data ? JSON.parse(data) : {});
                         }
                         catch (error) {
                             reject(new Error('Failed to parse response data'));
@@ -219,16 +190,16 @@ export class Paddle {
                     }
                     else {
                         if (data == null || data === "") {
-                            return reject(new RequestError(`${method}:${endpoint}: Request failed [${response.statusCode}].`, response.statusCode));
+                            return reject(new Paddle.RequestError(`${method}:${endpoint}: Request failed [${response.statusCode}].`, response.statusCode));
                         }
                         try {
                             data = JSON.parse(data);
                         }
                         catch (e) {
-                            return reject(new RequestError(`${method}:${endpoint}: Request failed [${response.statusCode}].`, response.statusCode));
+                            return reject(new Paddle.RequestError(`${method}:${endpoint}: Request failed [${response.statusCode}].`, response.statusCode));
                         }
                         if (data.error == null) {
-                            return reject(new RequestError(`${method}:${endpoint}: Request failed [${response.statusCode}].`, response.statusCode));
+                            return reject(new Paddle.RequestError(`${method}:${endpoint}: Request failed [${response.statusCode}].`, response.statusCode));
                         }
                         data = data.error;
                         let errs = "";
@@ -239,12 +210,12 @@ export class Paddle {
                             });
                             errs = errs.substr(0, errs.length - 2);
                         }
-                        return reject(new RequestError(`${method}:${endpoint}: ${data.detail} [${response.statusCode}]${errs}.`, response.statusCode));
+                        return reject(new Paddle.RequestError(`${method}:${endpoint}: ${data.detail} [${response.statusCode}]${errs}.`, response.statusCode));
                     }
                 });
             });
             // Write body params.
-            if (params != null) {
+            if (!is_get_like && params != null) {
                 // request.write(JSON.stringify(params));
                 const requestBody = JSON.stringify(params);
                 request.setHeader('Content-Length', Buffer.byteLength(requestBody));
@@ -262,7 +233,7 @@ export class Paddle {
             return await promise;
         }
         catch (e) {
-            if (e instanceof Error || e instanceof RequestError) {
+            if (e instanceof Error || e instanceof Paddle.RequestError) {
                 throw e;
             }
             throw new Error(e);
@@ -272,33 +243,25 @@ export class Paddle {
     // 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.save({ uid, prod_id }, { 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) {
-        const doc = await this._active_sub_db.load({ uid, prod_id });
-        let exists = false, sub_id;
-        if (doc == null) {
-            if (load_data) {
-                return { exists, sub_id };
-            }
-            else {
-                return exists;
-            }
-        }
-        exists = true;
-        sub_id = doc.sub_id;
-        if (load_data) {
-            return { exists, sub_id };
+        try {
+            const doc = await this._active_sub_db.load({ uid, prod_id });
+            return load_data ? { exists: true, sub_id: doc.sub_id } : true;
         }
-        else {
-            return exists;
+        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_query({ uid: uid });
+        const list = await this._active_sub_db.list({ uid: uid });
         if (detailed) {
             return list;
         }
@@ -309,52 +272,40 @@ export class Paddle {
         return products;
     }
     async _save_subscription(subscription) {
-        await this._sub_db.save({
+        await this._sub_db.set({
             uid: subscription.uid == null ? "unauth" : subscription.uid,
             id: subscription.id,
         }, subscription);
     }
     async _load_subscription(id) {
-        const subscription = await this._sub_db.find({ id: id });
-        if (subscription == null) {
-            throw Error(`Unable to find subscription "${id}".`);
-        }
-        return subscription;
+        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_query({ uid: uid });
+        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.save({
+        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];
-        const payment = await this._pay_db.load({ uid, id });
-        if (payment == null) {
-            throw Error(`Unable to find payment "${id}".`);
-        }
-        if (uid == null || uid == "unauth") {
-            delete payment.billing_details;
-        }
-        return payment;
+        return await this._pay_db.load({ uid, id });
     }
-    async _load_payment_by_transaction(id) {
-        const payment = await this._pay_db.find({ tran_id: id });
-        if (payment == null) {
-            throw Error(`Unable to find the payment by transaction id "${id}".`);
-        }
-        if (payment.uid == null || payment.uid == "unauth") {
-            delete payment.billing_details;
-        }
-        return payment;
+    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];
@@ -362,14 +313,14 @@ export class Paddle {
     }
     // Delete all info of a user.
     async _delete_user(uid) {
-        await this._sub_db.delete_all({ uid });
-        await this._active_sub_db.delete_all({ uid });
-        await this._pay_db.delete_all({ 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_query({});
+        return await this._active_sub_db.list_all();
     }
     // ---------------------------------------------------------
     // Overall (private).
@@ -444,8 +395,8 @@ export class Paddle {
             if (process.argv.includes("--no-payment-edits")) {
                 return false;
             }
-            if (this._has_create_products_permission) {
-                return true;
+            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())) {
@@ -469,7 +420,7 @@ export class Paddle {
                 return;
             }
             // Create product.
-            log(0, `Creating product ${product.name}.`);
+            this.server.log(0, `Creating product ${product.name}.`);
             const created_product = await this._req("POST", "/products", {
                 name: product.name,
                 description: product.description,
@@ -479,14 +430,14 @@ export class Paddle {
             });
             product.paddle_prod_id = created_product.data.id;
             // Create price.
-            log(0, `Creating a price for product ${product.name}.`);
+            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.trial,
+                trial_period: product.is_subscription ? product.trial : null,
                 tax_mode: this.inclusive_tax ? "internal" : "external",
             });
             product.price_id = created_price.data.id;
@@ -495,7 +446,7 @@ export class Paddle {
         else {
             // Vars.
             product.paddle_prod_id = existing_product.id;
-            const has_trial = product.trial != null;
+            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 ||
@@ -507,7 +458,7 @@ export class Paddle {
                 if (!await has_create_products_permission()) {
                     return;
                 }
-                log(0, `Updating product ${product.name}.`);
+                this.server.log(0, `Updating product ${product.name}.`);
                 await this._req("PATCH", `/products/${product.paddle_prod_id}`, {
                     name: product.name,
                     description: product.description,
@@ -528,14 +479,14 @@ export class Paddle {
                 if (!await has_create_products_permission()) {
                     return;
                 }
-                log(0, `Creating a price for product ${product.name}.`);
+                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.trial,
+                    trial_period: product.is_subscription ? product.trial : null,
                     tax_mode: this.inclusive_tax ? "internal" : "external",
                 });
                 product.price_id = price.data.id;
@@ -564,14 +515,14 @@ export class Paddle {
                     if (!await has_create_products_permission()) {
                         return;
                     }
-                    log(0, `Updating the price of product ${product.name}.`);
+                    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.trial,
+                        trial_period: product.is_subscription ? product.trial : null,
                         tax_mode: this.inclusive_tax ? "internal" : "external",
                         status: "active",
                     });
@@ -778,9 +729,9 @@ export class Paddle {
         // Expand the payment products.
         let sub_products = 0;
         this.products.iterate((product) => {
-            if (product.plans != null) {
+            if (product.is_subscription) {
                 // Check plans.
-                if (product.plans != null && Array.isArray(product.plans) === false) {
+                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.
@@ -817,9 +768,6 @@ export class Paddle {
                     initialize_product(plan);
                 });
             }
-            else if (product.frequency != null || product.interval != null) {
-                throw Error(`Subscription products should be nested as plans of a subscription "{... plans: [...]}". Not as a direct product without a subscription parent.`);
-            }
             else {
                 product.is_subscription = false;
                 initialize_product(product);
@@ -827,10 +775,11 @@ export class Paddle {
         });
         /* @performance */ now = this.performance.end("init-products", now);
         // Check registered products.
-        const last_products = await this._settings_db.load(`last_products${this.server.production ? "" : "_demo"}`);
-        if (vlib.Object.eq(last_products, this.products)) {
-            const product_ids = await this._settings_db.load(`product_ids${this.server.production ? "" : "_demo"}`);
-            product_ids.iterate((item) => {
+        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.eq(last_products.last_products, this.products)) {
+            last_products.product_ids.iterate((item) => {
                 const product = this.get_product_sync(item.id);
                 if (product != null) {
                     product.paddle_prod_id = item.paddle_prod_id;
@@ -847,7 +796,7 @@ export class Paddle {
             // Check all products.
             const product_ids = [];
             for (const product of this.products) {
-                if (product.plans != null) {
+                if (product.is_subscription) {
                     for (const plan of product.plans) {
                         await this._check_product(plan, existing_products, existing_prices);
                         product_ids.append({
@@ -870,76 +819,59 @@ export class Paddle {
             ;
             /* @performance */ now = this.performance.end("check-products", now);
             // Save last products.
-            await this._settings_db.save(`last_products${this.server.production ? "" : "_demo"}`, vlib.Object.delete_recursively(vlib.Object.deep_copy(this.products), ["paddle_prod_id", "price_id"]));
-            // Save price ids.
-            await this._settings_db.save(`product_ids${this.server.production ? "" : "_demo"}`, product_ids);
+            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() {
-        /* @performance */ this.performance.start();
-        // Create database collections.
-        this._settings_db = await this.server.db.collection({
-            name: "Volt.Paddle.Settings",
-            indexes: ["_path"],
-        });
-        this._sub_db = await this.server.db.collection({
-            name: "Volt.Paddle.Subscriptions",
-            indexes: ["uid", "id"],
-        });
-        this._active_sub_db = await this.server.db.collection({
-            name: "Volt.Paddle.ActiveSubscriptions",
-            indexes: ["uid", "prod_id"],
-        });
-        this._pay_db = await this.server.db.collection({
-            name: "Volt.Paddle.Payments",
-            indexes: ["uid", "id", "tran_id"],
-        });
-        // this._inv_db = await this.server.db.collection({
-        //     name: "Volt.Paddle.Invoices",
-        //     indexes: ["uid", "id", "tran_id" ],
-        // });
-        /* @performance */ this.performance.end("init-db");
         // Initialize products.
         await this._initialize_products();
         /* @performance */ let now = this.performance.start();
         // 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/payments/init",
+            endpoint: "/volt/api/v1/payments/init",
             content_type: "application/json",
             rate_limit: "global",
             params: {
-                items: "array",
+                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, data: { error: "Shopping cart is empty." } });
+                    return stream.error({ status: Status.bad_request, message: "Shopping cart is empty." });
                 }
                 let sub_plan_count = {};
-                const error = await params.items.iterate_async_await(async (item) => {
+                let error = undefined;
+                for (const item of params.items) {
                     if (item.product.is_subscription) {
                         if (stream.uid == null) {
-                            return "You must be signed-in to purchase a subscription.";
+                            error = "You must be signed-in to purchase a subscription.";
+                            break;
                         }
                         if (item.quantity != null && item.quantity > 1) {
-                            return "Subscriptions have a max quantity of 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 {
-                            return "You can not charge two different subscription plans from the same subscription product.";
+                            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)) {
-                            return `You are already subscribed to product "${item.product.name}".`;
+                            error = `You are already subscribed to product "${item.product.name}".`;
+                            break;
                         }
                     }
-                });
+                }
                 if (error) {
-                    return stream.error({ status: Status.bad_request, data: { error } });
+                    return stream.error({ status: Status.bad_request, message: error });
                 }
                 // Success.
                 return stream.success({ data: { message: "Successfully initialized the order." } });
@@ -948,7 +880,7 @@ export class Paddle {
         // Get products.
         this.server.endpoint({
             method: "GET",
-            endpoint: "/volt/payments/products",
+            endpoint: "/volt/api/v1/payments/products",
             content_type: "application/json",
             rate_limit: "global",
             callback: (stream) => {
@@ -958,119 +890,130 @@ export class Paddle {
         // Get payment by id.
         this.server.endpoint({
             method: "GET",
-            endpoint: "/volt/payments/payment",
+            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(params.id)) });
+                return stream.success({
+                    data: await this._load_payment_for_public(params.id),
+                });
             }
         });
         // Get payments.
         this.server.endpoint({
             method: "GET",
-            endpoint: "/volt/payments/payments",
+            endpoint: "/volt/api/v1/payments/payments",
             content_type: "application/json",
             authenticated: true,
             rate_limit: "global",
             params: {
                 days: { type: "number", default: 30 },
-                limit: { type: "number", default: null },
-                status: { type: "string", default: null },
+                limit: { type: "number", required: false },
+                status: { type: "string", required: false, enum: PaymentStatusValues },
             },
             callback: async (stream, params) => {
-                const result = await this.get_payments({
-                    uid: stream.uid,
-                    days: params.days,
-                    limit: params.limit,
-                    status: params.status,
+                return stream.success({
+                    data: await this.get_payments({
+                        uid: stream.uid,
+                        days: params.days,
+                        limit: params.limit,
+                        status: params.status,
+                    })
                 });
-                return stream.success({ data: result });
             }
         });
         // Get refundable payments.
         this.server.endpoint({
             method: "GET",
-            endpoint: "/volt/payments/payments/refundable",
+            endpoint: "/volt/api/v1/payments/payments/refundable",
             content_type: "application/json",
             authenticated: true,
             rate_limit: "global",
             params: {
                 days: { type: "number", default: 30 },
-                limit: { type: ["null", "number"], default: null },
-                status: { type: ["null", "string"], default: null },
+                limit: { type: "number", required: false },
             },
             callback: async (stream, params) => {
-                const result = await this.get_refundable_payments({
-                    uid: stream.uid,
-                    days: params.days,
-                    limit: params.limit,
+                return stream.success({
+                    data: await this.get_refundable_payments({
+                        uid: stream.uid,
+                        days: params.days,
+                        limit: params.limit,
+                        for_public: true,
+                    })
                 });
-                return stream.success({ data: result });
             }
         });
         // Get refunded payments.
         this.server.endpoint({
             method: "GET",
-            endpoint: "/volt/payments/payments/refunded",
+            endpoint: "/volt/api/v1/payments/payments/refunded",
             content_type: "application/json",
             authenticated: true,
             rate_limit: "global",
             params: {
                 days: { type: "number", default: 30 },
-                limit: { type: ["null", "number"], default: null },
+                limit: { type: "number", required: false },
             },
             callback: async (stream, params) => {
-                const result = await this.get_refunded_payments({
-                    uid: stream.uid,
-                    days: params.days,
-                    limit: params.limit,
+                return stream.success({
+                    data: await this.get_refunded_payments({
+                        uid: stream.uid,
+                        days: params.days,
+                        limit: params.limit,
+                        for_public: true,
+                    })
                 });
-                return stream.success({ data: result });
             }
         });
         // Get refunding payments.
         this.server.endpoint({
             method: "GET",
-            endpoint: "/volt/payments/payments/refunding",
+            endpoint: "/volt/api/v1/payments/payments/refunding",
             content_type: "application/json",
             authenticated: true,
             rate_limit: "global",
             params: {
-                days: { type: ["null", "number"], default: null },
-                limit: { type: ["null", "number"], default: null },
+                days: { type: "number", default: 30 },
+                limit: { type: "number", required: false },
             },
             callback: async (stream, params) => {
-                const result = await this.get_refunding_payments({
-                    uid: stream.uid,
-                    days: params.days,
-                    limit: params.limit,
+                return stream.success({
+                    data: await this.get_refunding_payments({
+                        uid: stream.uid,
+                        days: params.days,
+                        limit: params.limit,
+                        for_public: true,
+                    })
                 });
-                return stream.success({ data: result });
             }
         });
         // Create a refund.
         this.server.endpoint({
             method: "POST",
-            endpoint: "/volt/payments/refund",
+            endpoint: "/volt/api/v1/payments/refund",
             content_type: "application/json",
+            authenticated: true,
             rate_limit: "global",
             params: {
-                payment: { type: ["string", "object"] },
-                line_items: { type: ["array", "null"], default: null },
+                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(params.payment, params.line_items, params.reason);
+                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/payments/subscription",
+            endpoint: "/volt/api/v1/payments/subscription",
             content_type: "application/json",
             authenticated: true,
             rate_limit: "global",
@@ -1085,7 +1028,7 @@ export class Paddle {
         // Cancel a subscription by payment.
         // {
         //     method: "DELETE",
-        //     endpoint: "/volt/payments/subscription_by_payment",
+        //     endpoint: "/volt/api/v1/payments/subscription_by_payment",
         //     content_type: "application/json",
         //     authenticated: true,
         //     rate_limit: "global",
@@ -1100,20 +1043,22 @@ export class Paddle {
         // Get active subscriptions.
         this.server.endpoint({
             method: "GET",
-            endpoint: "/volt/payments/active_subscriptions",
+            endpoint: "/volt/api/v1/payments/active_subscriptions",
             content_type: "application/json",
             authenticated: true,
             rate_limit: "global",
-            callback: async (stream, params) => {
+            callback: async (stream) => {
                 return stream.success({
-                    data: { subscriptions: (await this.get_active_subscriptions(stream.uid)) },
+                    data: {
+                        subscriptions: await this.get_active_subscriptions(stream.uid)
+                    },
                 });
             }
         });
         // Is subscribed
         this.server.endpoint({
             method: "GET",
-            endpoint: "/volt/payments/subscribed",
+            endpoint: "/volt/api/v1/payments/subscribed",
             content_type: "application/json",
             authenticated: true,
             rate_limit: "global",
@@ -1122,7 +1067,9 @@ export class Paddle {
             },
             callback: async (stream, params) => {
                 return stream.success({
-                    data: { is_subscribed: (await this.is_subscribed(stream.uid, params.product)) }
+                    data: {
+                        is_subscribed: (await this.is_subscribed(stream.uid, params.product))
+                    }
                 });
             }
         });
@@ -1165,7 +1112,7 @@ export class Paddle {
         // 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", "adjustment", "business", "customer"] })).data;
+        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 = {
@@ -1246,7 +1193,7 @@ export class Paddle {
                 payment.status = "past_due";
                 break;
             default:
-                error(`Payment Webhook: Unknown payment status "${obj.status}".`);
+                this.server.log.error(`Payment Webhook: Unknown payment status "${obj.status}".`);
                 payment.status = "unknown";
                 break;
         }
@@ -1258,10 +1205,10 @@ export class Paddle {
                 paddle_prod_id: item.product.id, // paddle product id.
                 quantity: item.quantity,
                 tax_rate: parseFloat(item.tax_rate),
-                tax: parseFloat(item.totals.tax / 100), // should not be changed to unit totals, since mails and invoices depend on this behaviour, just divide by quantity.
-                discount: parseFloat(item.totals.discount / 100), // should not be changed to unit totals, since mails and invoices depend on this behaviour, just divide by quantity.
-                subtotal: parseFloat(item.totals.subtotal / 100), // should not be changed to unit totals, since mails and invoices depend on this behaviour, just divide by quantity.
-                total: parseFloat(item.totals.total / 100), // should not be changed to unit totals, since mails and invoices depend on this behaviour, just divide by quantity.
+                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".
             });
         });
@@ -1270,8 +1217,8 @@ export class Paddle {
             obj.adustments.iterate((adj) => {
                 switch (adj.action) {
                     case "refund":
-                    case "cargeback":
-                    case "cargeback_warning":
+                    case "chargeback":
+                        // case "chargeback_warning":
                         adj.items.iterate((adj_item) => {
                             payment.line_items.iterate((item) => {
                                 if (adj_item.item_id === item.item_id) {
@@ -1281,6 +1228,16 @@ export class Paddle {
                             });
                         });
                         break;
+                    case "chargeback_reversal":
+                        adj.items.iterate((adj_item) => {
+                            payment.line_items.iterate((item) => {
+                                if (adj_item.item_id === item.item_id) {
+                                    item.status = "paid";
+                                    return false;
+                                }
+                            });
+                        });
+                        break;
                     default:
                         break;
                 }
@@ -1290,9 +1247,9 @@ export class Paddle {
         await this._save_payment(payment);
         // ---------------------------------------------------------
         // Process the payment.
-        const { uid, cus_id } = payment;
+        const { uid } = payment;
         // Check the payment line items.
-        for (const item of await 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.
@@ -1308,11 +1265,11 @@ export class Paddle {
                 // 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 ?? []) {
+                for (const plan of subscription?.plans ?? []) {
                     if (plan.id != product.id) {
                         const { exists, sub_id } = await this._check_subscription(uid, plan.id);
                         if (exists) {
-                            log(0, `Cancelling subscription "${plan.id}" due too downgrade/upgrade to "${product.id}" of user "${payment.uid}".`);
+                            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);
                         }
@@ -1356,7 +1313,7 @@ export class Paddle {
             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) {
-                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)}.`);
+                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.
@@ -1364,7 +1321,7 @@ export class Paddle {
                 // Add to plans.
                 subscription.plans.append(product.id);
                 // Active the user's subscription in the database.
-                log(0, `Activating subscription "${product.id}" of user "${subscription.uid}".`);
+                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.
@@ -1382,7 +1339,7 @@ export class Paddle {
         // Delete subscriptions made by this subscription.
         for (const plan_id of subscription.plans) {
             await this._delete_subscription(subscription.uid, plan_id);
-            log(0, `Deactivating subscription "${plan_id}" of user "${subscription.uid}".`);
+            this.server.log(0, `Deactivating subscription "${plan_id}" of user "${subscription.uid}".`);
         }
         // Update database.
         subscription.status = "cancelled";
@@ -1434,7 +1391,7 @@ export class Paddle {
             }
             // Execute callback.
             if (is_approved) {
-                log(0, `Refunded items of payment "${payment.id}" of user "${payment.uid}".`);
+                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({
@@ -1447,7 +1404,7 @@ export class Paddle {
                 // }
             }
             else {
-                log(0, `Refund denied for items of payment ${payment.id} of user "${payment.uid}".`);
+                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({
@@ -1466,7 +1423,7 @@ export class Paddle {
             const payment = await this._load_payment_by_transaction(data.transaction_id);
             // Log reactivation subscriptions on chargeback reverse.
             if (payment.sub_id != null) {
-                log(0, `Chargeback reversed for payment ${payment.id} from user "${payment.uid}".`);
+                this.server.log(0, `Chargeback reversed for payment ${payment.id} from user "${payment.uid}".`);
                 // @todo.
             }
             // Get and update line items.
@@ -1487,8 +1444,8 @@ export class Paddle {
     }
     // Create and register the webhook endpoint.
     async _create_webhook() {
+        /* @performance */ const now = this.performance.start();
         // Register the webhook.
-        const webhook_doc = await this._settings_db.load(`webhook${this.server.production ? "" : "_demo"}`);
         const webhook_settings = {
             description: "volt webhook",
             destination: `${this.server.full_domain}/volt/payments/webhook`,
@@ -1515,72 +1472,89 @@ export class Paddle {
                 "adjustment.updated",
             ],
         };
+        const hashed_webhook_settings = this.server.hash(webhook_settings);
         // Register webhook.
         const register_webhook = async () => {
-            log(0, "Registering payments webhook.");
+            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._settings_db.save(`webhook${this.server.production ? "" : "_demo"}`, {
+            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),
             });
         };
-        // Webhook registered.
-        if (webhook_doc != null) {
-            this.webhook_key = webhook_doc.key;
-            // Check update required.
-            const last_webhook = await this._settings_db.load(`last_webhook${this.server.production ? "" : "_demo"}`);
-            if (last_webhook !== this.server.hash(webhook_settings)) {
-                log(0, `Checking payments webhook.`);
+        // 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.
-                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 (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}`);
                     }
-                }
-                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;
+                    catch (error) {
+                        if (error.status === 404 || error.status_code === 404) {
+                            registered = undefined;
+                            await register_webhook();
+                        }
+                        else {
+                            throw error;
                         }
-                        return webhook_settings.subscribed_events.iterate((x) => {
-                            const found = item.subscribed_events.iterate((y) => {
-                                if (x === y.name) {
+                    }
+                    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;
+                            }
+                            return webhook_settings.subscribed_events.iterate((x) => {
+                                const found = item.subscribed_events.iterate((y) => {
+                                    if (x === y.name) {
+                                        return true;
+                                    }
+                                });
+                                if (found === false) {
                                     return true;
                                 }
                             });
-                            if (found === false) {
-                                return true;
-                            }
-                        });
-                    })();
-                    // Update.
-                    if (patch === true) {
-                        log(0, "Updating payments webhook.");
-                        await this._req("PATCH", `/notification-settings/${webhook_id}`, { ...webhook_settings, active: true });
+                        })();
+                        // 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) });
                     }
-                    // Save.
-                    await this._settings_db.save(`last_webhook${this.server.production ? "" : "_demo"}`, this.server.hash(webhook_settings));
                 }
             }
-        }
-        // Register webhook.
-        else {
-            await register_webhook();
+            // Register webhook.
+            else {
+                await register_webhook();
+            }
+            // Save the new hash.
+            await cached_local_hash_file.save(hashed_webhook_settings);
         }
         // Ip whitelist.
         const ip_whitelist = [
@@ -1599,22 +1573,23 @@ export class Paddle {
             "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/payments/webhook",
+            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) {
-                    log(0, `POST:/volt/payments/webhook: Warning: Blocking non whitelisted ip "${stream.ip}".`);
+                    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) {
-                    log(0, "POST:/volt/payments/webhook: Error: No paddle signature found in the request headers.");
+                    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(";");
@@ -1622,7 +1597,7 @@ export class Paddle {
                 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) {
-                    log(0, "POST:/volt/payments/webhook: Error: Webhook signature verification failed.");
+                    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.
@@ -1683,7 +1658,6 @@ export class Paddle {
         }
         return product;
     }
-    // Get a payment by id.
     /*  @docs:
         @title: Get Payment.
         @desc: Get a payment by id.
@@ -1693,10 +1667,12 @@ export class Paddle {
             @type: string
             @desc: The id of the payment.
     */
-    async get_payment(id) {
+    async get_payment(id, opts) {
+        if (opts?.for_public) {
+            return await this._load_payment_for_public(id);
+        }
         return await this._load_payment(id);
     }
-    // Get payments.
     /*  @docs:
         @title: Get Refunded Payments.
         @desc:
@@ -1725,37 +1701,30 @@ export class Paddle {
                 @value: "paid"
                 @desc: Payments that are paid.
     */
-    async get_payments({ uid, days = 30, limit = undefined, status = undefined, }) {
+    async get_payments({ uid, days = 30, limit = 10_000, status = undefined, for_public, }) {
         // Get path.
-        const list = await this._pay_db.list_query({ uid: uid });
-        // Get the since time.
-        let since = null;
+        const query = {
+            uid,
+        };
         if (days != null) {
-            since = new Date();
+            const since = new Date();
             since.setHours(0, 0, 0, 0);
-            since = Math.floor(since.getTime() - (3600 * 24 * 1000 * days));
+            query.timestamp = { $gte: Math.floor(since.getTime() - (3600 * 24 * 1000 * days)) };
         }
-        // Iterate list.
-        const payments = [];
-        const status_is_array = Array.isArray(status);
-        list.iterate((payment) => {
-            if ((since == null || payment.timestamp >= since)) {
-                if (status == null ||
-                    (status_is_array === false && status === payment.status) ||
-                    (status_is_array && status.includes(payment.status))) {
-                    payments.append(payment);
-                }
-            }
-            if (limit != null && limit != -1 && payments.length >= limit) {
-                return false;
-            }
-        });
+        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 payments;
+        return (for_public
+            ? payments.map(p => Payment.anonymize(p))
+            : payments);
     }
-    // Get all refundable payments.
     /*  @docs:
         @title: Get Refundable Payments.
         @desc: Get all payments that are refundable.
@@ -1771,24 +1740,17 @@ export class Paddle {
             @type: number
             @desc: Limit the amount of response payment objects.
     */
-    async get_refundable_payments({ uid, days = 30, limit = undefined, }) {
-        const payments = [];
-        const all_payments = await this.get_payments({ uid, days, limit, status: "paid" });
-        all_payments.iterate((payment) => {
-            const line_items = [];
-            payment.line_items.iterate((item) => {
-                if (item.status === "paid" && item.total > 0) { // skip total 0 for free trial.
-                    line_items.push(item);
-                }
-            });
-            if (line_items.length > 0) {
-                payment.line_items = line_items;
-                payments.push(payment);
+    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 });
+        all_payments.iterate((pmt) => {
+            const refundable = pmt.line_items.filter((li) => li.status === "paid" && li.total > 0);
+            if (refundable.length > 0) {
+                out.push({ ...pmt, line_items: refundable });
             }
         });
-        return payments;
+        return out;
     }
-    // Get all refunded payments.
     /*  @docs:
         @title: Get Refunded Payments.
         @desc: Get all payments that are successfully refunded.
@@ -1804,24 +1766,17 @@ export class Paddle {
             @type: number
             @desc: Limit the amount of response payment objects.
     */
-    async get_refunded_payments({ uid, days = 30, limit = undefined, }) {
-        const payments = [];
-        const all_payments = await this.get_payments({ uid, days, limit, status: "paid" });
-        all_payments.iterate((payment) => {
-            const line_items = [];
-            payment.line_items.iterate((item) => {
-                if (item.status === "refunded") {
-                    line_items.push(item);
-                }
-            });
-            if (line_items.length > 0) {
-                payment.line_items = line_items;
-                payments.push(payment);
+    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 });
+        all_payments.iterate((pmt) => {
+            const refundable = pmt.line_items.filter((li) => li.status === "refunded" && li.total > 0);
+            if (refundable.length > 0) {
+                out.push({ ...pmt, line_items: refundable });
             }
         });
-        return payments;
+        return out;
     }
-    // Get all payments that are currently in the refunding process.
     /*  @docs:
         @title: Get Refunding Payments.
         @desc: Get all payments that are currently in the refunding process.
@@ -1837,24 +1792,17 @@ export class Paddle {
             @type: number
             @desc: Limit the amount of response payment objects.
     */
-    async get_refunding_payments({ uid, days = undefined, limit = undefined, }) {
-        const payments = [];
-        const all_payments = await this.get_payments({ uid, days, limit, status: "paid" });
-        all_payments.iterate((payment) => {
-            const line_items = [];
-            payment.line_items.iterate((item) => {
-                if (item.status === "refunding") {
-                    line_items.push(item);
-                }
-            });
-            if (line_items.length > 0) {
-                payment.line_items = line_items;
-                payments.push(payment);
+    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 });
+        all_payments.iterate((pmt) => {
+            const refundable = pmt.line_items.filter((li) => li.status === "refunding" && li.total > 0);
+            if (refundable.length > 0) {
+                out.push({ ...pmt, line_items: refundable });
             }
         });
-        return payments;
+        return out;
     }
-    // Refund a payment.
     /*  @docs:
         @title: Refund Payment.
         @desc: Refund a payment based on the payment id.
@@ -1939,7 +1887,6 @@ export class Paddle {
         // Update the payment object.
         await this._save_payment(payment);
     }
-    // Cancel a subscription.
     /*  @docs:
         @title: Cancel Subscription.
         @desc: Cancel a subscription based on the retrieved payment object or id.
@@ -1980,7 +1927,6 @@ export class Paddle {
             });
         }
     }
-    // Cancel subscription by subscription id.
     /*  @docs:
         @title: Cancel subscription by subscription id.
         @desc: Cancel a subscription based on the retrieved subscription object or id.
@@ -2001,7 +1947,6 @@ export class Paddle {
         }
         return await this._cancel_subscription(subscription, immediate);
     }
-    // Get subscriptioms.
     /*  @docs:
         @title: Get active subscriptions
         @desc: Get the active subscriptions of a user.
@@ -2022,7 +1967,6 @@ export class Paddle {
     async get_subscriptions(uid) {
         return await this._get_subscriptions(uid);
     }
-    // Is subscribed.
     /*  @docs:
         @title: Is Subscribed
         @desc: Check if a user is subscribed to a product.
@@ -2038,7 +1982,6 @@ export class Paddle {
     async is_subscribed(uid, product) {
         return await this._check_subscription(uid, product, false);
     }
-    // Generate an invoice.
     /*  @docs:
         @title: Generate Invoice
         @desc:
@@ -2248,17 +2191,24 @@ export class Paddle {
         // doc.pipe(fs.createWriteStream(path.str()));
         // return path;
         // Get as bytes.
-        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);
-            });
+        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.
@@ -2280,7 +2230,7 @@ export class Paddle {
         // Cancel.
         for (const sub of subs) {
             if (sub.status === "active") {
-                console.log("Cancelling subscription", sub.id);
+                this.server.log("Cancelling subscription ", sub.id);
                 await this._req("POST", `/subscriptions/${sub.id}/cancel`, {
                     effective_from: "immediately",
                 });
@@ -2288,4 +2238,19 @@ export class Paddle {
         }
     }
 }
-export default Paddle;
+/** 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.
+ */