ztechno_core 0.0.105 → 0.0.108

package/lib/mollie/services/invoice_service.js

@@ -0,0 +1,866 @@
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.InvoiceService = void 0;
+const pdfkit_1 = __importDefault(require('pdfkit'));
+const path_1 = __importDefault(require('path'));
+const fs_1 = __importDefault(require('fs'));
+const crypto_1 = __importDefault(require('crypto'));
+const invoice_items_orm_1 = require('../orm/invoice_items_orm');
+const invoice_payments_orm_1 = require('../orm/invoice_payments_orm');
+const invoices_orm_1 = require('../orm/invoices_orm');
+const subscription_items_orm_1 = require('../orm/subscription_items_orm');
+const subscriptions_orm_1 = require('../orm/subscriptions_orm');
+const subscription_utils_1 = require('../util/subscription_utils');
+const orm_1 = require('../../core/orm/orm');
+class InvoiceService {
+  get config() {
+    return this.opt.siteConfig;
+  }
+  get baseUrl() {
+    return this.opt.siteConfig.company.website;
+  }
+  constructor(opt) {
+    this.opt = opt;
+    this.payTokenSecret = this.opt.payTokenSecret || '';
+    this.payTokenLifetimeMs = 60 * 24 * 60 * 60 * 1000;
+    this.invoicesOrm = new invoices_orm_1.InvoicesOrm({ sqlService: opt.sqlService });
+    this.itemsOrm = new invoice_items_orm_1.InvoiceItemsOrm({ sqlService: opt.sqlService });
+    this.paymentsOrm = new invoice_payments_orm_1.InvoicePaymentsOrm({ sqlService: opt.sqlService });
+    this.subscriptionsOrm = new subscriptions_orm_1.SubscriptionsOrm({ sqlService: opt.sqlService });
+    this.subscriptionItemsOrm = new subscription_items_orm_1.SubscriptionItemsOrm({ sqlService: opt.sqlService });
+    this.mailService = opt.mailService;
+  }
+  async autoInit() {
+    await this.invoicesOrm.ensureTableExists();
+    await this.itemsOrm.ensureTableExists();
+    await this.paymentsOrm.ensureTableExists();
+    await this.ensurePayTokenSchema();
+    await this.ensureSubscriptionInvoiceSchema();
+    await this.ensureInvoicePaymentSchema();
+    await this.ensureSubsidyItemTypeSchema();
+  }
+  async ensurePayTokenSchema() {
+    const table = this.invoicesOrm.alias;
+    const ensureColumn = async (column, sqlType) => {
+      const rows = await this.opt.sqlService.exec({
+        query: `SELECT COLUMN_NAME FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=:schema AND TABLE_NAME=:tableName AND COLUMN_NAME=:columnName LIMIT 1`,
+        params: { schema: this.opt.sqlService.database, tableName: table, columnName: column },
+      });
+      if (!rows?.[0]) {
+        await this.opt.sqlService.query(`ALTER TABLE \`${table}\` ADD COLUMN ${column} ${sqlType}`);
+      }
+    };
+    await ensureColumn('pay_token_hash', 'CHAR(64) NULL');
+    await ensureColumn('pay_token_expires_at', 'DATETIME NULL');
+    await ensureColumn('pay_token_finalized_at', 'DATETIME NULL');
+    const indexRows = await this.opt.sqlService.exec({
+      query: `SELECT INDEX_NAME FROM information_schema.STATISTICS WHERE TABLE_SCHEMA=:schema AND TABLE_NAME=:tableName AND INDEX_NAME='uq_invoices_pay_token_hash' LIMIT 1`,
+      params: { schema: this.opt.sqlService.database, tableName: table },
+    });
+    if (!indexRows?.[0]) {
+      await this.opt.sqlService.query(
+        `ALTER TABLE \`${table}\` ADD UNIQUE KEY uq_invoices_pay_token_hash (pay_token_hash)`,
+      );
+    }
+  }
+  async ensureSubscriptionInvoiceSchema() {
+    const table = this.invoicesOrm.alias;
+    const ensureColumn = async (column, sqlType) => {
+      const rows = await this.opt.sqlService.exec({
+        query: `SELECT COLUMN_NAME FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=:schema AND TABLE_NAME=:tableName AND COLUMN_NAME=:columnName LIMIT 1`,
+        params: { schema: this.opt.sqlService.database, tableName: table, columnName: column },
+      });
+      if (!rows?.[0]) {
+        await this.opt.sqlService.query(`ALTER TABLE \`${table}\` ADD COLUMN ${column} ${sqlType}`);
+      }
+    };
+    await ensureColumn('subscription_id', 'BIGINT UNSIGNED NULL');
+    await ensureColumn('subscription_period_start', 'DATETIME NULL');
+    await ensureColumn('subscription_period_end', 'DATETIME NULL');
+    const indexRows = await this.opt.sqlService.exec({
+      query: `SELECT INDEX_NAME FROM information_schema.STATISTICS WHERE TABLE_SCHEMA=:schema AND TABLE_NAME=:tableName AND INDEX_NAME='idx_invoices_subscription' LIMIT 1`,
+      params: { schema: this.opt.sqlService.database, tableName: table },
+    });
+    if (!indexRows?.[0]) {
+      await this.opt.sqlService.query(`ALTER TABLE \`${table}\` ADD KEY idx_invoices_subscription (subscription_id)`);
+    }
+  }
+  async ensureSubsidyItemTypeSchema() {
+    const table = this.itemsOrm.alias;
+    const rows = await this.opt.sqlService.exec({
+      query: `SELECT COLUMN_NAME FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=:schema AND TABLE_NAME=:tableName AND COLUMN_NAME='item_type' LIMIT 1`,
+      params: { schema: this.opt.sqlService.database, tableName: table },
+    });
+    if (!rows?.[0]) {
+      await this.opt.sqlService.query(
+        `ALTER TABLE \`${table}\` ADD COLUMN item_type ENUM('service','subsidy') NOT NULL DEFAULT 'service' AFTER invoice_id`,
+      );
+    }
+  }
+  async ensureInvoicePaymentSchema() {
+    const table = this.paymentsOrm.alias;
+    const ensureColumn = async (column, sqlType) => {
+      const rows = await this.opt.sqlService.exec({
+        query: `SELECT COLUMN_NAME FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=:schema AND TABLE_NAME=:tableName AND COLUMN_NAME=:columnName LIMIT 1`,
+        params: { schema: this.opt.sqlService.database, tableName: table, columnName: column },
+      });
+      if (!rows?.[0]) {
+        await this.opt.sqlService.query(`ALTER TABLE \`${table}\` ADD COLUMN ${column} ${sqlType}`);
+      }
+    };
+    await ensureColumn('sequence_type', "ENUM('oneoff','first','recurring') NULL");
+    await ensureColumn('mollie_subscription_id', 'VARCHAR(64) NULL');
+    const indexRows = await this.opt.sqlService.exec({
+      query: `SELECT INDEX_NAME FROM information_schema.STATISTICS WHERE TABLE_SCHEMA=:schema AND TABLE_NAME=:tableName AND INDEX_NAME='idx_payments_subscription' LIMIT 1`,
+      params: { schema: this.opt.sqlService.database, tableName: table },
+    });
+    if (!indexRows?.[0]) {
+      await this.opt.sqlService.query(
+        `ALTER TABLE \`${table}\` ADD KEY idx_payments_subscription (mollie_subscription_id)`,
+      );
+    }
+  }
+  async generateInvoiceNumber() {
+    const now = new Date();
+    const year = now.getFullYear();
+    // Get the highest invoice number for this year
+    const lastInvoice = await this.invoicesOrm.findLastByYear(year);
+    let sequence = 1;
+    if (lastInvoice?.invoice_number) {
+      // Extract sequence from format "INV-YYYY-NNNNNN"
+      const match = lastInvoice.invoice_number.match(/INV-\d{4}-(\d+)/);
+      if (match) {
+        sequence = parseInt(match[1], 10) + 1;
+      }
+    }
+    return `INV-${year}-${sequence.toString().padStart(6, '0')}`;
+  }
+  getWebhookUrl() {
+    return this.opt.mollieService.webhookUrl;
+  }
+  signPayTokenRaw(raw) {
+    if (!this.payTokenSecret) {
+      throw new Error('PAY_TOKEN_SECRET or Mollie key is required for pay token signing');
+    }
+    return crypto_1.default.createHmac('sha256', this.payTokenSecret).update(raw).digest('hex');
+  }
+  buildPayToken(raw) {
+    const signature = this.signPayTokenRaw(raw);
+    return `${raw}.${signature}`;
+  }
+  parseSignedPayToken(token) {
+    const separator = token.lastIndexOf('.');
+    if (separator <= 0 || separator >= token.length - 1) {
+      return null;
+    }
+    const raw = token.substring(0, separator);
+    const signature = token.substring(separator + 1);
+    return { raw, signature };
+  }
+  verifySignedPayToken(token) {
+    const parsed = this.parseSignedPayToken(token);
+    if (!parsed) {
+      return null;
+    }
+    const expected = this.signPayTokenRaw(parsed.raw);
+    const expectedBuf = Buffer.from(expected);
+    const signatureBuf = Buffer.from(parsed.signature);
+    if (expectedBuf.length !== signatureBuf.length) {
+      return null;
+    }
+    const valid = crypto_1.default.timingSafeEqual(new Uint8Array(expectedBuf), new Uint8Array(signatureBuf));
+    if (!valid) {
+      return null;
+    }
+    return parsed.raw;
+  }
+  hashPayTokenRaw(raw) {
+    return crypto_1.default.createHash('sha256').update(raw).digest('hex');
+  }
+  async getInvoiceBundle(invoiceId) {
+    const invoice = await this.invoicesOrm.findById(invoiceId);
+    if (!invoice) {
+      throw new Error(`Invoice ${invoiceId} not found`);
+    }
+    const items = await this.itemsOrm.findByInvoice(invoiceId);
+    const customer = await this.opt.customerService.findById(invoice.customer_id);
+    if (!customer) {
+      throw new Error(`Customer ${invoice.customer_id} not found`);
+    }
+    return { invoice, items, customer };
+  }
+  formatMoney(value, currency) {
+    const symbol = currency === 'EUR' ? '€' : currency;
+    return `${symbol} ${value.toFixed(2)}`;
+  }
+  calcTotals(items) {
+    let amount_due = 0;
+    const mapped = items.map((item, idx) => {
+      const itemType = item.item_type ?? 'service';
+      const total_ex_vat = Number(item.quantity) * Number(item.unit_price);
+      // Subsidy items are VAT-exempt gross deductions (vat_rate forced to 0)
+      const effectiveVatRate = itemType === 'subsidy' ? 0 : Number(item.vat_rate || 0);
+      const total_inc_vat = total_ex_vat * (1 + effectiveVatRate / 100);
+      amount_due += total_inc_vat;
+      return {
+        invoice_id: 0,
+        item_type: itemType,
+        description: item.description,
+        quantity: Number(item.quantity),
+        unit_price: Number(item.unit_price),
+        vat_rate: effectiveVatRate,
+        total_ex_vat,
+        total_inc_vat,
+        sort_order: item.sort_order ?? idx,
+      };
+    });
+    return { amount_due: Number(amount_due.toFixed(2)), items: mapped };
+  }
+  createPayTokenRaw(invoiceId) {
+    const nonce = crypto_1.default.randomBytes(16).toString('hex');
+    return `inv_${invoiceId}_${nonce}`;
+  }
+  isInvoicePaid(invoice) {
+    return invoice?.status === 'paid';
+  }
+  isInvoiceFinalizedForPay(invoice) {
+    return this.isInvoicePaid(invoice) || !!invoice?.pay_token_finalized_at;
+  }
+  isTokenExpired(invoice) {
+    if (!invoice.pay_token_expires_at) {
+      return true;
+    }
+    return new Date(invoice.pay_token_expires_at).getTime() <= Date.now();
+  }
+  async createMolliePaymentForInvoice(invoice, opt) {
+    const customer = await this.opt.customerService.findById(invoice.customer_id);
+    if (!customer) {
+      throw new Error(`Customer ${invoice.customer_id} not found`);
+    }
+    if (!customer.mollie_customer_id) {
+      throw new Error(`Customer ${customer.id} missing mollie_customer_id`);
+    }
+    const metadata = {
+      ...(invoice.metadata ?? {}),
+      ...(opt?.metadata ?? {}),
+    };
+    metadata.invoice_number = invoice.invoice_number;
+    metadata.customer_id = customer.id;
+    metadata.invoice_id = invoice.id;
+    if (invoice.subscription_id) {
+      metadata.subscription_id = invoice.subscription_id;
+    }
+    if (invoice.payment_terms) {
+      metadata.payment_terms = invoice.payment_terms;
+    }
+    if (invoice.due_date) {
+      metadata.due_date = invoice.due_date;
+    }
+    // Store line items for recovery
+    const invoiceItems = await this.itemsOrm.findByInvoice(invoice.id);
+    if (invoiceItems.length > 0) {
+      metadata.items = invoiceItems.map((it) => ({
+        d: it.description,
+        q: it.quantity,
+        u: it.unit_price,
+        v: it.vat_rate,
+        t: it.item_type ?? 'service',
+      }));
+    }
+    const payment = await this.opt.mollieService.createPayment({
+      amount: { currency: invoice.currency || 'EUR', value: Number(invoice.amount_due).toFixed(2) },
+      description: invoice.description || `Invoice ${invoice.invoice_number}`,
+      redirectUrl: `${this.baseUrl}/pay/success?invoice=${encodeURIComponent(invoice.invoice_number)}`,
+      webhookUrl: this.getWebhookUrl(),
+      customerId: customer.mollie_customer_id,
+      metadata,
+      sequenceType: opt?.sequenceType ?? 'oneoff',
+      mandateId: opt?.mandateId ?? undefined,
+    });
+    await this.paymentsOrm.upsert({
+      invoice_id: invoice.id,
+      mollie_payment_id: payment.id,
+      status: payment.status,
+      sequence_type: payment.sequenceType ?? opt?.sequenceType ?? 'oneoff',
+      mollie_subscription_id: payment.subscriptionId ?? null,
+      method: payment.method ?? null,
+      amount: Number(payment.amount.value),
+      currency: payment.amount.currency,
+      checkout_url: payment?._links?.checkout?.href ?? null,
+      paid_at: (0, orm_1.toDatetime)(payment.paidAt ?? null),
+      expires_at: (0, orm_1.toDatetime)(payment.expiresAt),
+      mandate_id: payment.mandateId ?? opt?.mandateId ?? null,
+    });
+    await this.invoicesOrm.updatePaymentRef(invoice.id, {
+      mollie_payment_id: payment.id,
+      checkout_url: payment?.getCheckoutUrl() ?? payment?._links?.checkout?.href ?? null,
+    });
+    return payment;
+  }
+  async issueOrRotatePayToken(invoice) {
+    if (this.isInvoiceFinalizedForPay(invoice)) {
+      throw new Error(`Invoice ${invoice.invoice_number} is already finalized`);
+    }
+    const raw = this.createPayTokenRaw(invoice.id);
+    const token = this.buildPayToken(raw);
+    const expiresAtDate = new Date(Date.now() + this.payTokenLifetimeMs);
+    const expiresAt = (0, orm_1.formatDatetime)(expiresAtDate);
+    const tokenHash = this.hashPayTokenRaw(raw);
+    await this.invoicesOrm.setPayToken(invoice.id, {
+      pay_token_hash: tokenHash,
+      pay_token_expires_at: expiresAt,
+    });
+    return {
+      token,
+      expiresAt,
+      payUrl: `${this.baseUrl}/pay?token=${encodeURIComponent(token)}`,
+    };
+  }
+  async ensurePayLink(invoiceId) {
+    const invoice = await this.invoicesOrm.findById(invoiceId);
+    if (!invoice) {
+      throw new Error(`Invoice ${invoiceId} not found`);
+    }
+    if (this.isInvoiceFinalizedForPay(invoice)) {
+      return {
+        token: '',
+        expiresAt: invoice.pay_token_expires_at ?? (0, orm_1.formatDatetime)(new Date()),
+        payUrl: `${this.baseUrl}/pay/success?invoice=${encodeURIComponent(invoice.invoice_number)}`,
+      };
+    }
+    return await this.issueOrRotatePayToken(invoice);
+  }
+  async resolvePayToken(token) {
+    const raw = this.verifySignedPayToken(token);
+    if (!raw) {
+      throw new Error('Invalid pay token');
+    }
+    const tokenHash = this.hashPayTokenRaw(raw);
+    const invoice = await this.invoicesOrm.findByPayTokenHash(tokenHash);
+    if (!invoice) {
+      throw new Error('Pay token not found');
+    }
+    if (this.isInvoicePaid(invoice)) {
+      await this.invoicesOrm.finalizePayToken(invoice.id);
+      return { action: 'paid', invoice };
+    }
+    if (this.isTokenExpired(invoice)) {
+      throw new Error('Pay token expired');
+    }
+    if (invoice.mollie_payment_id) {
+      const existingPayment = await this.opt.mollieService.getPayment(invoice.mollie_payment_id);
+      const mapped = this.opt.mollieService.mapPaymentStatus(existingPayment.status);
+      if (mapped === 'paid') {
+        await this.syncPayment(existingPayment.id);
+        const paidInvoice = await this.invoicesOrm.findById(invoice.id);
+        if (paidInvoice) {
+          await this.invoicesOrm.finalizePayToken(paidInvoice.id);
+          return { action: 'paid', invoice: paidInvoice };
+        }
+      }
+      const checkoutUrl = existingPayment?.getCheckoutUrl() || existingPayment?._links?.checkout?.href;
+      if (existingPayment.status === 'open' && checkoutUrl) {
+        return { action: 'redirect', checkoutUrl, invoice };
+      }
+    }
+    const payment = await this.createMolliePaymentForInvoice(invoice, {
+      sequenceType: invoice.subscription_id ? 'first' : 'oneoff',
+    });
+    const checkoutUrl = payment?.getCheckoutUrl() || payment?._links?.checkout?.href;
+    if (!checkoutUrl) {
+      throw new Error('Failed to create checkout URL');
+    }
+    const updatedInvoice = await this.invoicesOrm.findById(invoice.id);
+    return { action: 'redirect', checkoutUrl, invoice: updatedInvoice || invoice };
+  }
+  async listInvoices() {
+    return await this.invoicesOrm.findAll();
+  }
+  async getInvoiceById(invoiceId) {
+    return await this.invoicesOrm.findById(invoiceId);
+  }
+  async listPayments(invoice_id) {
+    return await this.paymentsOrm.findByInvoice(invoice_id);
+  }
+  async createInvoiceWithPayment(input) {
+    const draft = await this.createInvoiceDraft(input);
+    const payment = await this.createMolliePaymentForInvoice(draft.invoice);
+    const updated = await this.invoicesOrm.findById(draft.invoice.id);
+    return {
+      invoice: updated || draft.invoice,
+      checkoutUrl: payment?.getCheckoutUrl() || payment?._links?.checkout?.href || null,
+      payment,
+      payUrl: draft.pay.payUrl,
+    };
+  }
+  async createInvoiceFromItems(input, overrides) {
+    const customer = await this.opt.customerService.findById(input.customer_id);
+    if (!customer) {
+      throw new Error(`Customer ${input.customer_id} not found`);
+    }
+    if (!customer.mollie_customer_id) {
+      throw new Error(`Customer ${customer.id} missing mollie_customer_id`);
+    }
+    const { items, amount_due } = this.calcTotals(input.items);
+    const invoice_number = await this.generateInvoiceNumber();
+    const status = overrides?.status ?? 'pending';
+    const issuedAt = (0, orm_1.formatDatetime)(new Date());
+    const paidAt = overrides?.paid_at ?? (status === 'paid' ? issuedAt : null);
+    const amount_paid = overrides?.amount_paid ?? (status === 'paid' ? amount_due : 0);
+    const invoicePayload = {
+      invoice_number,
+      customer_id: customer.id,
+      subscription_id: overrides?.subscription_id ?? null,
+      subscription_period_start: overrides?.subscription_period_start ?? null,
+      subscription_period_end: overrides?.subscription_period_end ?? null,
+      mollie_customer_id: customer.mollie_customer_id,
+      mollie_payment_id: overrides?.mollie_payment_id ?? null,
+      pay_token_hash: null,
+      pay_token_expires_at: null,
+      pay_token_finalized_at: null,
+      status,
+      amount_due,
+      amount_paid,
+      currency: input.currency || 'EUR',
+      description: input.description,
+      payment_terms: input.payment_terms ?? 'Betaling binnen 14 dagen na factuurdatum',
+      due_date: input.due_date ?? null,
+      issued_at: issuedAt,
+      paid_at: paidAt,
+      checkout_url: overrides?.checkout_url ?? null,
+      metadata: input.metadata ?? null,
+    };
+    await this.invoicesOrm.create(invoicePayload);
+    const savedInvoice = await this.invoicesOrm.findByInvoiceNumber(invoice_number);
+    if (!savedInvoice) {
+      throw new Error('Failed to persist invoice');
+    }
+    const itemsWithInvoice = items.map((it) => ({ ...it, invoice_id: savedInvoice.id }));
+    await this.itemsOrm.bulkInsert(itemsWithInvoice);
+    const pay = overrides?.issuePayToken === false ? null : await this.ensurePayLink(savedInvoice.id);
+    return { invoice: savedInvoice, pay };
+  }
+  async createInvoiceDraft(input) {
+    const result = await this.createInvoiceFromItems(input, { issuePayToken: true });
+    if (!result.pay) {
+      throw new Error('Failed to issue pay token');
+    }
+    return { invoice: result.invoice, pay: result.pay };
+  }
+  async syncPayment(paymentId) {
+    const payment = await this.opt.mollieService.getPayment(paymentId);
+    const metadata = payment.metadata ?? {};
+    const localPayment = await this.paymentsOrm.findByPaymentId(paymentId);
+    let invoice = localPayment ? await this.invoicesOrm.findById(localPayment.invoice_id) : undefined;
+    const metadataInvoiceId = metadata?.invoice_id ? Number(metadata.invoice_id) : undefined;
+    if (!invoice && metadataInvoiceId) {
+      invoice = await this.invoicesOrm.findById(metadataInvoiceId);
+    }
+    if (!invoice && metadata?.invoice_number) {
+      invoice = await this.invoicesOrm.findByInvoiceNumber(metadata.invoice_number);
+    }
+    const subscriptionIdFromPayment = payment.subscriptionId ?? null;
+    const metadataSubscriptionId = metadata?.subscription_id ? Number(metadata.subscription_id) : undefined;
+    let subscription;
+    if (subscriptionIdFromPayment) {
+      subscription = await this.subscriptionsOrm.findByMollieSubscriptionId(subscriptionIdFromPayment);
+    }
+    if (!subscription && metadataSubscriptionId) {
+      subscription = await this.subscriptionsOrm.findById(metadataSubscriptionId);
+    }
+    if (!subscription && invoice?.subscription_id) {
+      subscription = await this.subscriptionsOrm.findById(invoice.subscription_id);
+    }
+    const hadInvoice = !!invoice;
+    const mappedStatus = this.opt.mollieService.mapPaymentStatus(payment.status);
+    const paidAmount = mappedStatus === 'paid' ? Number(payment.amount.value) : undefined;
+    const paidAt = mappedStatus === 'paid' && payment.paidAt ? (0, orm_1.toDatetime)(payment.paidAt) : null;
+    if (!invoice && subscription) {
+      const subscriptionItems = await this.subscriptionItemsOrm.findBySubscription(subscription.id);
+      if (subscriptionItems.length === 0) {
+        throw new Error(`Subscription ${subscription.id} has no items`);
+      }
+      const periodBase = payment.paidAt
+        ? new Date(payment.paidAt)
+        : payment.createdAt
+        ? new Date(payment.createdAt)
+        : new Date();
+      const interval = (0, subscription_utils_1.parseSubscriptionInterval)(subscription.interval);
+      const periodEnd = (0, subscription_utils_1.addSubscriptionInterval)(periodBase, interval);
+      const created = await this.createInvoiceFromItems(
+        {
+          customer_id: subscription.customer_id,
+          description: subscription.description ?? `Subscription ${subscription.id}`,
+          currency: subscription.currency || 'EUR',
+          items: subscriptionItems.map((it) => ({
+            description: it.description,
+            quantity: it.quantity,
+            unit_price: it.unit_price,
+            vat_rate: it.vat_rate,
+            sort_order: it.sort_order,
+          })),
+          metadata: subscription.metadata ?? null,
+        },
+        {
+          status: mappedStatus,
+          paid_at: paidAt,
+          amount_paid: mappedStatus === 'paid' ? Number(payment.amount.value) : 0,
+          subscription_id: subscription.id,
+          subscription_period_start: (0, orm_1.formatDatetime)(periodBase),
+          subscription_period_end: (0, orm_1.formatDatetime)(periodEnd),
+          issuePayToken: false,
+          mollie_payment_id: payment.id,
+          checkout_url: payment?._links?.checkout?.href ?? null,
+        },
+      );
+      invoice = created.invoice;
+    }
+    if (!invoice) {
+      throw new Error(`Invoice for payment ${paymentId} not found`);
+    }
+    await this.paymentsOrm.upsert({
+      invoice_id: invoice.id,
+      mollie_payment_id: payment.id,
+      status: payment.status,
+      sequence_type: payment.sequenceType ?? null,
+      mollie_subscription_id: payment.subscriptionId ?? null,
+      method: payment.method ?? null,
+      amount: Number(payment.amount.value),
+      currency: payment.amount.currency,
+      checkout_url: payment?._links?.checkout?.href ?? null,
+      paid_at: (0, orm_1.toDatetime)(payment.paidAt ?? null),
+      expires_at: (0, orm_1.toDatetime)(payment.expiresAt),
+      mandate_id: payment.mandateId ?? null,
+    });
+    await this.invoicesOrm.updatePaymentRef(invoice.id, {
+      mollie_payment_id: payment.id,
+      checkout_url: payment?._links?.checkout?.href ?? null,
+    });
+    const previousStatus = invoice.status;
+    await this.invoicesOrm.updateStatus(invoice.id, mappedStatus, paidAmount, paidAt);
+    if (mappedStatus === 'paid') {
+      await this.invoicesOrm.finalizePayToken(invoice.id);
+    }
+    if (subscription && !invoice.subscription_period_start) {
+      const periodBase = payment.paidAt
+        ? new Date(payment.paidAt)
+        : payment.createdAt
+        ? new Date(payment.createdAt)
+        : new Date();
+      const interval = (0, subscription_utils_1.parseSubscriptionInterval)(subscription.interval);
+      const periodEnd = (0, subscription_utils_1.addSubscriptionInterval)(periodBase, interval);
+      await this.invoicesOrm.updateSubscriptionPeriod(invoice.id, {
+        subscription_period_start: (0, orm_1.formatDatetime)(periodBase),
+        subscription_period_end: (0, orm_1.formatDatetime)(periodEnd),
+      });
+    }
+    if (subscription && mappedStatus === 'paid' && (!hadInvoice || previousStatus !== 'paid')) {
+      await this.sendInvoiceEmail(invoice.id, undefined, { mode: 'receipt' });
+    }
+    if (
+      subscription &&
+      mappedStatus === 'paid' &&
+      payment.sequenceType === 'first' &&
+      !subscription.mollie_subscription_id
+    ) {
+      if (!subscription.mollie_customer_id) {
+        throw new Error(`Subscription ${subscription.id} missing mollie_customer_id`);
+      }
+      const paidDate = payment.paidAt ? new Date(payment.paidAt) : new Date();
+      const interval = (0, subscription_utils_1.parseSubscriptionInterval)(subscription.interval);
+      const startDate = (0, subscription_utils_1.formatDateOnly)(
+        (0, subscription_utils_1.addSubscriptionInterval)(paidDate, interval),
+      );
+      const subscriptionItems = await this.subscriptionItemsOrm.findBySubscription(subscription.id);
+      const remote = await this.opt.mollieService.createSubscription({
+        customerId: subscription.mollie_customer_id,
+        amount: {
+          currency: subscription.currency || 'EUR',
+          value: Number(subscription.amount).toFixed(2),
+        },
+        interval: subscription.interval,
+        description: subscription.description ?? `Subscription ${subscription.id}`,
+        startDate,
+        webhookUrl: this.getWebhookUrl(),
+        metadata: {
+          subscription_id: subscription.id,
+          items: subscriptionItems.map((it) => ({
+            d: it.description,
+            q: it.quantity,
+            u: it.unit_price,
+            v: it.vat_rate,
+          })),
+        },
+        mandateId: payment.mandateId ?? undefined,
+      });
+      await this.subscriptionsOrm.update(subscription.id, {
+        mollie_subscription_id: remote.id,
+        status: remote.status,
+        mandate_id: remote.mandateId ?? payment.mandateId ?? null,
+        next_payment_date: remote.nextPaymentDate ? (0, orm_1.toDatetimeFromDateOnly)(remote.nextPaymentDate) : null,
+        canceled_at: remote.canceledAt ? (0, orm_1.toDatetime)(remote.canceledAt) : null,
+      });
+    }
+    if (
+      subscription &&
+      payment.sequenceType === 'recurring' &&
+      subscription.mollie_subscription_id &&
+      subscription.mollie_customer_id
+    ) {
+      const remote = await this.opt.mollieService.getSubscription(
+        subscription.mollie_customer_id,
+        subscription.mollie_subscription_id,
+      );
+      await this.subscriptionsOrm.update(subscription.id, {
+        status: remote.status,
+        mandate_id: remote.mandateId ?? subscription.mandate_id ?? null,
+        next_payment_date: remote.nextPaymentDate ? (0, orm_1.toDatetimeFromDateOnly)(remote.nextPaymentDate) : null,
+        canceled_at: remote.canceledAt ? (0, orm_1.toDatetime)(remote.canceledAt) : null,
+      });
+    }
+    return { invoiceId: invoice.id, status: mappedStatus };
+  }
+  async generateInvoicePdfBuffer(invoiceId) {
+    const { invoice, items, customer } = await this.getInvoiceBundle(invoiceId);
+    const doc = new pdfkit_1.default({ size: 'A4', margin: 50 });
+    const buffers = [];
+    doc.on('data', (chunk) => buffers.push(chunk));
+    const done = new Promise((resolve, reject) => {
+      doc.on('end', () => resolve(Buffer.concat(buffers)));
+      doc.on('error', reject);
+    });
+    // === COMPANY LOGO (left-aligned) ===
+    const logoPath = path_1.default.join(process.cwd(), '../zwebsite/public/img/invoice/invoice-logo.png');
+    if (fs_1.default.existsSync(logoPath)) {
+      doc.image(logoPath, 50, 50, { width: 200 }); // Left side of A4 page
+    }
+    const cfg = this.opt.siteConfig;
+    // === SUPPLIER INFORMATION (right-aligned, Dutch law: name, address, BTW, KVK) ===
+    const rightCol = 320;
+    doc.fontSize(18).text(cfg.company.company, rightCol, 50, { width: 230, align: 'right' });
+    doc.fontSize(10).text(cfg.address.street, rightCol, doc.y, { width: 230, align: 'right' });
+    doc.text(`${cfg.address.zipcode} ${cfg.address.city}`, rightCol, doc.y, { width: 230, align: 'right' });
+    doc.text(cfg.address.country, rightCol, doc.y, { width: 230, align: 'right' });
+    // doc.text(`Tel: ${cfg.contact.phone}`, rightCol, doc.y, { width: 230, align: 'right' })
+    doc.moveDown(0.5);
+    doc.text(`KVK ${cfg.company.kvk}`, rightCol, doc.y, { width: 230, align: 'right' });
+    doc.text(`${cfg.company.btwNr}`, rightCol, doc.y, { width: 230, align: 'right' });
+    doc.moveDown();
+    // === CUSTOMER INFORMATION (left-aligned, Dutch law: name, address; B2B: BTW-nummer) ===
+    doc.fontSize(18).text(customer.company || '', 50, doc.y);
+    doc.fontSize(10).text(customer.name, 50);
+    if (customer.address_line1) doc.text(customer.address_line1, 50);
+    if (customer.address_line2) doc.text(customer.address_line2, 50);
+    if (customer.postal_code || customer.city) {
+      doc.text(`${customer.postal_code || ''} ${customer.city || ''}`.trim(), 50);
+    }
+    if (customer.country) doc.text(customer.country === 'NL' ? 'Nederland' : customer.country, 50);
+    // doc.text(`Email: ${customer.email}`, 50)
+    // if (customer.phone) doc.text(`Tel: ${customer.phone}`, 50)
+    if (customer.btw_nummer) doc.text(`${customer.btw_nummer}`, 50);
+    doc.moveDown();
+    // === INVOICE HEADER (two-column layout like reference) ===
+    const headerY = doc.y + 10;
+    // Left side: Invoice number
+    doc.fontSize(14).font('Helvetica-Bold').text(`Factuur ${invoice.invoice_number}`, 50, headerY);
+    // Right side: Date and due date
+    const issuedDate = invoice.issued_at
+      ? new Date(invoice.issued_at).toLocaleDateString('nl-NL', { day: 'numeric', month: 'short', year: 'numeric' })
+      : '-';
+    const dueDate = invoice.due_date
+      ? new Date(invoice.due_date).toLocaleDateString('nl-NL', { day: 'numeric', month: 'short', year: 'numeric' })
+      : null;
+    doc.fontSize(12).font('Helvetica-Bold').text(issuedDate, rightCol, headerY, { width: 230, align: 'right' });
+    if (dueDate) {
+      doc
+        .fontSize(10)
+        .font('Helvetica')
+        .text(`Vervaldatum: ${dueDate}`, rightCol, headerY + 16, { width: 230, align: 'right' });
+    }
+    doc.font('Helvetica');
+    doc.y = headerY + 30;
+    doc.moveDown();
+    // === LINE ITEMS TABLE (Dutch law: description, quantity, unit price excl. VAT, VAT rate, total) ===
+    const tableTop = doc.y;
+    const col1 = 50; // Description
+    const col2 = 280; // Qty
+    const col3 = 330; // VAT %
+    const col4 = 390; // Unit price (excl. VAT)
+    const col5 = 480; // Total Ex. VAT
+    doc.fontSize(9).font('Helvetica-Bold');
+    doc.text('Omschrijving', col1, tableTop);
+    doc.text('Aantal', col2, tableTop);
+    doc.text('BTW %', col3, tableTop);
+    doc.text('Prijs excl.', col4, tableTop);
+    doc.text('Totaal excl.', col5, tableTop);
+    doc.font('Helvetica');
+    doc
+      .moveTo(50, tableTop + 14)
+      .lineTo(560, tableTop + 14)
+      .stroke();
+    // Split items: service items go in the main table, subsidy items in a separate section
+    const serviceItems = items.filter((it) => (it.item_type ?? 'service') === 'service');
+    const subsidyItems = items.filter((it) => it.item_type === 'subsidy');
+    // Pen helper: tracks vertical cursor, writes text and advances by gap, draws rules
+    const P = {
+      y: tableTop + 20,
+      skip(n) {
+        this.y += n;
+        return this;
+      },
+      text(text, x, opts, gap = 12) {
+        doc.text(text, x, this.y, opts ?? {});
+        this.y += gap;
+        return this;
+      },
+      row(label, labelX, value, valueX, gap = 14) {
+        doc.text(label, labelX, this.y);
+        doc.text(value, valueX, this.y);
+        this.y += gap;
+        return this;
+      },
+      rule(x1 = 50, x2 = 560) {
+        doc.moveTo(x1, this.y).lineTo(x2, this.y).stroke();
+        return this;
+      },
+      dashedRule(x1, x2) {
+        doc.moveTo(x1, this.y).lineTo(x2, this.y).lineWidth(0.5).dash(3, { space: 3 }).stroke();
+        doc.undash().lineWidth(1);
+        return this;
+      },
+      bold() {
+        doc.font('Helvetica-Bold');
+        return this;
+      },
+      normal() {
+        doc.font('Helvetica');
+        return this;
+      },
+      size(n) {
+        doc.fontSize(n);
+        return this;
+      },
+    };
+    let subtotal = 0;
+    const vatByRate = {};
+    for (const item of serviceItems) {
+      const lineSubtotal = Number(item.total_ex_vat ?? 0);
+      const lineTotal = Number(item.total_inc_vat ?? 0);
+      const vatRate = Number(item.vat_rate);
+      subtotal += lineSubtotal;
+      if (!vatByRate[vatRate]) vatByRate[vatRate] = { base: 0, vat: 0 };
+      vatByRate[vatRate].base += lineSubtotal;
+      vatByRate[vatRate].vat += lineTotal - lineSubtotal;
+      P.size(9);
+      doc.text(item.description, col1, P.y, { width: 225 });
+      doc.text(String(item.quantity), col2, P.y);
+      doc.text(`${vatRate.toFixed(0)}%`, col3, P.y);
+      doc.text(this.formatMoney(Number(item.unit_price), invoice.currency), col4, P.y);
+      doc.text(this.formatMoney(lineSubtotal, invoice.currency), col5, P.y);
+      P.skip(16);
+    }
+    P.rule().skip(10);
+    // === TOTALS (Dutch law: subtotal, VAT breakdown per rate, subtotal incl. VAT) ===
+    P.size(10);
+    P.row('Subtotaal excl. BTW:', 370, this.formatMoney(subtotal, invoice.currency), col5);
+    let totalVat = 0;
+    for (const [rate, { vat }] of Object.entries(vatByRate)) {
+      totalVat += vat;
+      P.row(`BTW ${rate}%`, 370, this.formatMoney(vat, invoice.currency), col5);
+    }
+    const serviceTotalIncVat = subtotal + totalVat;
+    // === SUBSIDY SECTION (shown before grand total when subsidies are present) ===
+    let subsidyTotal = 0;
+    if (subsidyItems.length > 0) {
+      P.normal().size(10);
+      P.row('Subtotaal incl. BTW:', 370, this.formatMoney(serviceTotalIncVat, invoice.currency), col5)
+        .skip(4)
+        .dashedRule(370, 560)
+        .skip(8);
+      P.bold().size(9);
+      P.text('Subsidie', 50, {}, 12);
+      P.normal().size(9);
+      for (const item of subsidyItems) {
+        const subsidyAmount = Number(item.total_inc_vat ?? 0); // negative
+        subsidyTotal += subsidyAmount;
+        doc.text(item.description, col1, P.y, { width: 400 });
+        doc.text(`− ${this.formatMoney(Math.abs(subsidyAmount), invoice.currency)}`, col5, P.y);
+        P.skip(14);
+      }
+      P.rule(370, 560).skip(8);
+    }
+    const grandTotal = serviceTotalIncVat + subsidyTotal; // subsidyTotal is negative
+    P.bold();
+    P.row('Totaal incl. BTW:', 370, this.formatMoney(grandTotal, invoice.currency), col5, 20);
+    P.normal();
+    // === DESCRIPTION ===
+    if (invoice.description) {
+      P.size(10).bold();
+      P.skip(10).text('Omschrijving:', 50, {}, 12);
+      P.normal();
+      P.text(invoice.description, 50, {}, 12);
+    }
+    // === PAYMENT TERMS (Dutch law recommended) ===
+    if (invoice.payment_terms) {
+      P.size(10).bold();
+      P.skip(10).text('Betalingsvoorwaarden:', 50, {}, 12);
+      P.normal();
+      P.text(invoice.payment_terms, 50, {}, 12);
+    }
+    // === BANK DETAILS FOR PAYMENT ===
+    P.size(10).bold();
+    P.skip(10).text('Betalingsgegevens:', 50, {}, 14);
+    P.normal();
+    P.text(`IBAN: ${cfg.company.iban}`, 50);
+    if (cfg.company.bankName) P.text(`Bank: ${cfg.company.bankName}`, 50);
+    P.text(`T.n.v.: ${cfg.company.company}`, 50);
+    P.text(`O.v.v.: ${invoice.invoice_number}`, 50);
+    doc.end();
+    return await done;
+  }
+  async sendInvoiceEmail(invoiceId, recipient, opt) {
+    const { invoice, customer } = await this.getInvoiceBundle(invoiceId);
+    const mode = opt?.mode ?? 'invoice';
+    const isReceipt = mode === 'receipt';
+    const pay = isReceipt ? null : await this.ensurePayLink(invoiceId);
+    const pdfBuffer = await this.generateInvoicePdfBuffer(invoiceId);
+    const to = recipient ?? customer.email;
+    const cfg = this.opt.siteConfig;
+    const subject = isReceipt ? `Betalingsbevestiging ${invoice.invoice_number}` : `Factuur ${invoice.invoice_number}`;
+    const title = isReceipt ? `Betaling ontvangen ${invoice.invoice_number}` : `Factuur ${invoice.invoice_number}`;
+    const content = isReceipt
+      ? `<br>Beste ${customer.name},<br><br>We hebben uw betaling ontvangen. De factuur vindt u in de bijlage.<br><br>Dank u wel, ${cfg.company.website}<br>`
+      : `<br>Beste ${customer.name},<br><br>U vindt uw factuur in de bijlage.<br><br><a href="${pay?.payUrl}" style="display:inline-block;padding:10px 16px;background:#0d6efd;color:#fff;text-decoration:none;border-radius:6px;">Betaal nu</a><br><br>Dank u wel, ${cfg.company.website}<br>`;
+    await this.mailService.sendAdvanced({
+      from: `${cfg.company.website} <${cfg.contact.contact}>`,
+      recipient: to,
+      subject,
+      template: 'template.html',
+      inject: {
+        title,
+        content,
+        logoSrc: `${cfg.company.website}/img/logo-small.png`,
+        baseUrl: cfg.company.website,
+      },
+      attachments: [
+        {
+          filename: `factuur-${invoice.invoice_number}.pdf`,
+          content: pdfBuffer,
+          contentType: 'application/pdf',
+        },
+      ],
+    });
+    return {
+      invoice_number: invoice.invoice_number,
+      recipient: to,
+      payUrl: pay?.payUrl ?? null,
+      payTokenExpiresAt: pay?.expiresAt ?? null,
+    };
+  }
+}
+exports.InvoiceService = InvoiceService;