@vandenberghinc/volt 1.2.4 → 1.2.6

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

@@ -1,1996 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var stdin_exports = {};
-__export(stdin_exports, {
-  LineItem: () => LineItem,
-  Paddle: () => Paddle,
-  Payment: () => Payment,
-  PaymentStatusValues: () => PaymentStatusValues
-});
-module.exports = __toCommonJS(stdin_exports);
-var https = __toESM(require("https"));
-var PDFDocument = __toESM(require("pdfkit"));
-var libcrypto = __toESM(require("crypto"));
-var vlib = __toESM(require("@vandenberghinc/vlib"));
-var import_errors = require("../errors/index.js");
-var import_status = require("../status.js");
-var import_collection = require("../database/collection.js");
-var import_utils = require("../utils.js");
-var LineItem;
-(function(LineItem2) {
-  LineItem2.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 = {}));
-const PaymentStatusValues = ["open", "paid", "past_due", "unknown"];
-var Payment;
-(function(Payment2) {
-  function anonymize(payment) {
-    if (!payment.uid || payment.uid === "unauth") {
-      const { billing_details, ...rest } = payment;
-      return {
-        ...rest,
-        billing_details: void 0
-      };
-    }
-    return payment;
-  }
-  Payment2.anonymize = anonymize;
-})(Payment || (Payment = {}));
-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 }) {
-    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"
-      }
-    });
-    this.client_key = client_key;
-    this.sandbox = sandbox;
-    this.inclusive_tax = inclusive_tax;
-    this.products = products;
-    this.server = _server;
-    this._host = this.sandbox ? "sandbox-api.paddle.com" : "api.paddle.com";
-    this._headers = {
-      "Content-Type": "application/json",
-      "Accept": "application/json",
-      "Authorization": "Bearer " + api_key
-    };
-    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";
-    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.performance = new vlib.Performance("Payments performance");
-  }
-  // ---------------------------------------------------------
-  // Products and prices (private).
-  // ---------------------------------------------------------
-  // Utils (private).
-  async _req(method, endpoint, params = null) {
-    const promise = new Promise((resolve, reject) => {
-      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 {
-      }
-      const options = {
-        method,
-        hostname,
-        path,
-        port: 443,
-        headers: this._headers
-      };
-      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));
-          }
-        });
-      });
-      if (!is_get_like && params != null) {
-        const requestBody = JSON.stringify(params);
-        request.setHeader("Content-Length", Buffer.byteLength(requestBody));
-        request.write(requestBody);
-      }
-      request.on("error", (error) => {
-        reject(error);
-      });
-      request.end();
-    });
-    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 import_collection.Collection.NotFoundError) {
-        return load_data ? { exists: false, sub_id: void 0 } : false;
-      }
-      throw err;
-    }
-  }
-  async _get_active_subscriptions(uid, detailed = false) {
-    const list = await this._active_sub_db.list({ 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 }, { retry: 3 });
-  }
-  async _get_subscriptions(uid) {
-    if (uid === "unauth" || uid == null) {
-      return [];
-    }
-    const list = await this._sub_db.list({ 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 }, { 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 });
-  }
-  // 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 = []) {
-    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;
-    };
-    let existing_product = null;
-    for (const item of existing_products) {
-      if (item.custom_data.id === product.id) {
-        existing_product = item;
-        break;
-      }
-    }
-    if (existing_product == null) {
-      if (!await has_create_products_permission()) {
-        return;
-      }
-      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;
-      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;
-    } else {
-      product.paddle_prod_id = existing_product.id;
-      const has_trial = product.is_subscription && product.trial != null;
-      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";
-      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"
-        });
-      }
-      let existing_price = null;
-      for (const item of existing_prices) {
-        if (item.product_id === product.paddle_prod_id) {
-          existing_price = item;
-          break;
-        }
-      }
-      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;
-      } else {
-        product.price_id = existing_price.id;
-        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";
-        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".`);
-    }
-    const subscription = await this._load_subscription(id);
-    if (subscription == null) {
-      throw Error(`Unable to find subscription "${id}".`);
-    }
-    if (subscription.status !== "active") {
-      throw new import_errors.ExternalError({
-        type: "NoActiveSubscriptionError",
-        message: `This subscription is already cancelled and will become inactive at the end of the billing period.`,
-        status: import_status.Status.bad_request
-      });
-    }
-    await this._req("POST", `/subscriptions/${subscription.id}/cancel`, {
-      effective_from: immediate ? "immediately" : null
-    });
-    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 } = {}) {
-    let now = this.performance.start();
-    const product_ids = [];
-    let product_index = 0;
-    const initialize_product = (product) => {
-      ++product_index;
-      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);
-      if (typeof product.icon === "string" && product.icon.charAt(0) === "/") {
-        product.icon = `${this.server.full_domain}/${product.icon}`;
-      }
-      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).`);
-      }
-    };
-    let sub_products = 0;
-    for (const product of this.products) {
-      if (product.is_subscription) {
-        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".`);
-        }
-        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;
-        product.is_subscription = true;
-        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);
-      }
-    }
-    now = this.performance.end("init-products", now);
-    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 import_collection.Collection.NotFoundError))
-      throw last_products;
-    if (!(last_products instanceof import_collection.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;
-        }
-      }
-      now = this.performance.end("assign-product-ids", now);
-    } else if (this.server.offline === false) {
-      const existing_products = await this._get_products();
-      const existing_prices = await this._get_prices();
-      now = this.performance.end("get-prices-and-products", now);
-      const product_ids2 = [];
-      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_ids2.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_ids2.append({
-            id: product.id,
-            paddle_prod_id: product.paddle_prod_id,
-            price_id: product.price_id
-          });
-        }
-      }
-      ;
-      now = this.performance.end("check-products", now);
-      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_ids2
-      });
-      now = this.performance.end("save-products-to-db", now);
-    }
-  }
-  // Initialize the payments.
-  async _initialize({ worker = false } = {}) {
-    await this._initialize_products({ worker });
-    let now = this.performance.start();
-    if (!worker) {
-      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) => {
-          if (params.items.length === 0) {
-            return stream.error({ status: import_status.Status.bad_request, message: "Shopping cart is empty." });
-          }
-          let sub_plan_count = {};
-          let error = void 0;
-          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: import_status.Status.bad_request, message: error });
-          }
-          return stream.success({ data: { message: "Successfully initialized the order." } });
-        }
-      });
-      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 });
-        }
-      });
-      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)
-          });
-        }
-      });
-      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
-            })
-          });
-        }
-      });
-      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
-            })
-          });
-        }
-      });
-      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
-            })
-          });
-        }
-      });
-      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
-            })
-          });
-        }
-      });
-      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();
-        }
-      });
-      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();
-        }
-      });
-      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)
-            }
-          });
-        }
-      });
-      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)
-            }
-          });
-        }
-      });
-      if (!this.server.offline) {
-        this.server.endpoint(await this._create_webhook());
-      }
-    }
-    now = this.performance.end("init-endpoints", now);
-  }
-  // ---------------------------------------------------------
-  // 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) {
-    let obj = (await this._req("GET", `/transactions/${data.id}`, { include: ["address", "adjustments", "business", "customer"] })).data;
-    const id = `pay_${obj.custom_data.uid == null ? "unauth" : obj.custom_data.uid}_${vlib.String.random(4)}${Date.now()}`;
-    const payment = {
-      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: void 0,
-        email: void 0,
-        business: void 0,
-        vat_id: void 0,
-        address: void 0,
-        city: void 0,
-        postal_code: void 0,
-        province: void 0,
-        country: void 0,
-        tax_identifier: void 0
-      }
-    };
-    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;
-      }
-    }
-    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;
-    }
-    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;
-    }
-    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;
-      }
-    }
-    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;
-    }
-    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".
-      });
-    });
-    if (obj.adustments != null) {
-      obj.adustments.iterate((adj) => {
-        switch (adj.action) {
-          case "refund":
-          case "chargeback":
-            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;
-        }
-      });
-    }
-    await this._save_payment(payment);
-    const { uid } = payment;
-    for (const item of payment.line_items) {
-      const product = this.get_product_sync(item.product, false);
-      if (product == null) {
-        continue;
-      } else if (product.is_subscription) {
-        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}".`);
-              await this._cancel_subscription(sub_id);
-            }
-          }
-        }
-      } else {
-        await this._exec_user_callback(this.server.on_payment, { product, payment });
-      }
-    }
-  }
-  // 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) {
-    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: []
-    };
-    for (const item of data.items) {
-      const product = this._get_product_by_paddle_prod_id(item.price.product_id, false);
-      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;
-      } else if (product.is_subscription) {
-        subscription.plans.append(product.id);
-        this.server.log(0, `Activating subscription "${product.id}" of user "${subscription.uid}".`);
-        await this._add_subscription(uid, product.id, subscription.id);
-        await this._exec_user_callback(this.server.on_subscription, { product, subscription });
-      }
-    }
-    await this._save_subscription(subscription);
-  }
-  // On a subscription cancelled webhook event.
-  async _subscription_cancelled_webhook(data) {
-    const subscription = await this._load_subscription(data.id);
-    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}".`);
-    }
-    subscription.status = "cancelled";
-    await this._save_subscription(subscription);
-    await this._exec_user_callback(this.server.on_cancellation, { subscription });
-  }
-  // On a adjustment (refunds) updated webhook event.
-  async _adjustment_webhook(data) {
-    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";
-      const payment = await this._load_payment_by_transaction(data.transaction_id);
-      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;
-          }
-        }
-      }
-      if (payment.sub_id != null && is_approved) {
-        await this._cancel_subscription(payment.sub_id, true);
-      }
-      if (line_items.length > 0) {
-        await this._save_payment(payment);
-      }
-      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 });
-      } 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 });
-      }
-    } else if (data.action === "chargeback_reverse" && data.status === "reversed") {
-      const payment = await this._load_payment_by_transaction(data.transaction_id);
-      if (payment.sub_id != null) {
-        this.server.log(0, `Chargeback reversed for payment ${payment.id} from user "${payment.uid}".`);
-      }
-      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);
-          }
-        }
-      }
-      if (line_items.length > 0) {
-        await this._save_payment(payment);
-      }
-    }
-  }
-  // Create and register the webhook endpoint.
-  async _create_webhook() {
-    const now = this.performance.start();
-    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);
-    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)
-      });
-    };
-    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) {
-      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 import_collection.Collection.NotFoundError)) {
-        throw webhook_doc;
-      }
-      if (!(webhook_doc instanceof import_collection.Collection.NotFoundError)) {
-        this.webhook_key = webhook_doc.key;
-        if (webhook_doc.hash !== hashed_webhook_settings) {
-          this.server.log(0, `Checking payments webhook.`);
-          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 = void 0;
-              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;
-            })();
-            if (patch === true) {
-              this.server.log(0, "Updating payments webhook.");
-              await this._req("PATCH", `/notification-settings/${webhook_id}`, { ...webhook_settings, active: true });
-            }
-            await this._webhook_conf_db.set({ production: this.server.production, version: 1 }, { hash: this.server.hash(webhook_settings) });
-          }
-        }
-      } else {
-        await register_webhook();
-      }
-      await cached_local_hash_file.save(hashed_webhook_settings);
-    }
-    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"
-    ];
-    this.server.performance.end("create-payments-webhook", now);
-    return {
-      method: "POST",
-      endpoint: "/volt/api/v1/payments/webhook",
-      content_type: "application/json",
-      rate_limit: void 0,
-      callback: async (stream) => {
-        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: import_status.Status.unauthorized });
-        }
-        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: import_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: import_status.Status.unauthorized, data: { error: "Webhook signature verification failed." } });
-        }
-        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;
-        }
-        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 = 1e4, status = void 0, for_public }) {
-    const query = {
-      uid
-    };
-    if (days != null) {
-      const since = /* @__PURE__ */ new Date();
-      since.setHours(0, 0, 0, 0);
-      query.timestamp = { $gte: Math.floor(since.getTime() - 3600 * 24 * 1e3 * 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 });
-    payments.sort((a, b) => b.timestamp - a.timestamp);
-    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 = void 0, 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 = void 0, 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 = void 0, limit = void 0, 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 = void 0, reason = "refund") {
-    if (typeof payment === "string") {
-      payment = await this._load_payment(payment);
-    } else {
-      payment = await this._load_payment(payment.id);
-    }
-    if (line_items == null) {
-      line_items = payment.line_items;
-    }
-    if (line_items.length === 0) {
-      throw Error("No refund line items array is empty.");
-    }
-    const items = [];
-    const item_ids = [];
-    for (const item of line_items) {
-      if (item.status === "refunded" || item.status === "refunding") {
-        continue;
-      }
-      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.
-      });
-    }
-    if (items.length === 0) {
-      throw Error("This payment no longer has any refundable line items.");
-    }
-    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";
-        }
-      }
-    }
-    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 import_errors.ExternalError({
-        type: "NoCancellableSubscriptions",
-        message: "No cancellable subscriptions found.",
-        status: import_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) {
-    if (payment == null || typeof payment !== "object") {
-      throw Error(`Parameter "payment" should be a defined value of type "object".`);
-    }
-    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 = import_utils.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;
-    let top_offset = 57;
-    let spacing = 10;
-    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;
-      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;
-      }
-      if (top_offset + max_height + 10 > doc.page.height - 50) {
-        doc.addPage();
-        top_offset = 50;
-      }
-      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;
-      }
-      top_offset += max_height + spacing;
-    };
-    const format_date = (date) => {
-      return `${date.getDate()}/${date.getMonth() + 1}/${date.getFullYear()}`;
-    };
-    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;
-    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;
-    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(/* @__PURE__ */ new Date())]
-    ]) {
-      gen_col_text(item[0], 550 - (150 + 10 + 80), { width: 80 });
-      gen_col_text(item[1], 550 - 150, { width: 150 }, true);
-    }
-    top_offset = Math.max(top_offset, left_top_offset) + 25;
-    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);
-    }
-    top_offset += 35;
-    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;
-    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();
-    });
-  }
-  // ---------------------------------------------------------
-  // 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.");
-    }
-    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;
-    }
-    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"
-        });
-      }
-    }
-  }
-}
-(function(Paddle2) {
-  class RequestError extends Error {
-    status_code;
-    constructor(err, status_code) {
-      super(err);
-      this.status_code = status_code;
-    }
-  }
-  Paddle2.RequestError = RequestError;
-})(Paddle || (Paddle = {}));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LineItem,
-  Paddle,
-  Payment,
-  PaymentStatusValues
-});