ztechno_core 0.0.105 → 0.0.108

package/lib/mollie/orm/invoices_orm.js

@@ -0,0 +1,172 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.InvoicesOrm = void 0;
+const orm_1 = require('../../core/orm/orm');
+class InvoicesOrm extends orm_1.ZOrm {
+  constructor(opt) {
+    super({ sqlService: opt.sqlService, alias: opt.alias ?? 'mollie_invoices' });
+  }
+  async create(invoice) {
+    const res = await this.sqlService.query(
+      /*SQL*/ `
+      INSERT INTO \`${this.alias}\`
+        (invoice_number, customer_id, subscription_id, subscription_period_start, subscription_period_end, mollie_customer_id, mollie_payment_id, pay_token_hash, pay_token_expires_at, pay_token_finalized_at, status, amount_due, amount_paid, currency, description, payment_terms, due_date, issued_at, paid_at, checkout_url, metadata)
+      VALUES
+        (:invoice_number, :customer_id, :subscription_id, :subscription_period_start, :subscription_period_end, :mollie_customer_id, :mollie_payment_id, :pay_token_hash, :pay_token_expires_at, :pay_token_finalized_at, :status, :amount_due, :amount_paid, :currency, :description, :payment_terms, :due_date, :issued_at, :paid_at, :checkout_url, :metadata)
+      ON DUPLICATE KEY UPDATE
+        subscription_id=VALUES(subscription_id),
+        subscription_period_start=VALUES(subscription_period_start),
+        subscription_period_end=VALUES(subscription_period_end),
+        mollie_customer_id=VALUES(mollie_customer_id),
+        mollie_payment_id=VALUES(mollie_payment_id),
+        pay_token_hash=VALUES(pay_token_hash),
+        pay_token_expires_at=VALUES(pay_token_expires_at),
+        pay_token_finalized_at=VALUES(pay_token_finalized_at),
+        status=VALUES(status),
+        amount_due=VALUES(amount_due),
+        amount_paid=VALUES(amount_paid),
+        currency=VALUES(currency),
+        description=VALUES(description),
+        payment_terms=VALUES(payment_terms),
+        due_date=VALUES(due_date),
+        issued_at=VALUES(issued_at),
+        paid_at=VALUES(paid_at),
+        checkout_url=VALUES(checkout_url),
+        metadata=VALUES(metadata),
+        updated_at=NOW()
+    `,
+      invoice,
+    );
+    return res;
+  }
+  async findById(id) {
+    const res = await this.sqlService.exec({
+      query: `SELECT * FROM \`${this.alias}\` WHERE id=:id LIMIT 1`,
+      params: { id },
+    });
+    return res[0];
+  }
+  async findByInvoiceNumber(invoice_number) {
+    const res = await this.sqlService.exec({
+      query: `SELECT * FROM \`${this.alias}\` WHERE invoice_number=:invoice_number LIMIT 1`,
+      params: { invoice_number },
+    });
+    return res[0];
+  }
+  async findByPayTokenHash(pay_token_hash) {
+    const res = await this.sqlService.exec({
+      query: `SELECT * FROM \`${this.alias}\` WHERE pay_token_hash=:pay_token_hash LIMIT 1`,
+      params: { pay_token_hash },
+    });
+    return res[0];
+  }
+  async findAll() {
+    return await this.sqlService.exec({ query: `SELECT * FROM \`${this.alias}\` ORDER BY created_at DESC` });
+  }
+  async findLastByYear(year) {
+    const res = await this.sqlService.exec({
+      query: `SELECT * FROM \`${this.alias}\` WHERE invoice_number LIKE :pattern ORDER BY invoice_number DESC LIMIT 1`,
+      params: { pattern: `INV-${year}-%` },
+    });
+    return res[0];
+  }
+  async updateStatus(id, status, amount_paid, paid_at) {
+    await this.sqlService.query(
+      /*SQL*/ `
+      UPDATE \`${this.alias}\`
+      SET status=:status, amount_paid=COALESCE(:amount_paid, amount_paid), paid_at=COALESCE(:paid_at, paid_at), updated_at=NOW()
+      WHERE id=:id
+    `,
+      { id, status, amount_paid: amount_paid ?? null, paid_at: paid_at ?? null },
+    );
+  }
+  async updatePaymentRef(id, payload) {
+    await this.sqlService.query(
+      /*SQL*/ `
+      UPDATE \`${this.alias}\`
+      SET
+        mollie_payment_id=COALESCE(:mollie_payment_id, mollie_payment_id),
+        checkout_url=COALESCE(:checkout_url, checkout_url),
+        updated_at=NOW()
+      WHERE id=:id
+    `,
+      { id, mollie_payment_id: payload.mollie_payment_id ?? null, checkout_url: payload.checkout_url ?? null },
+    );
+  }
+  async updateSubscriptionPeriod(id, payload) {
+    await this.sqlService.query(
+      /*SQL*/ `
+      UPDATE \`${this.alias}\`
+      SET
+        subscription_id=COALESCE(:subscription_id, subscription_id),
+        subscription_period_start=COALESCE(:subscription_period_start, subscription_period_start),
+        subscription_period_end=COALESCE(:subscription_period_end, subscription_period_end),
+        updated_at=NOW()
+      WHERE id=:id
+    `,
+      {
+        id,
+        subscription_id: payload.subscription_id ?? null,
+        subscription_period_start: payload.subscription_period_start ?? null,
+        subscription_period_end: payload.subscription_period_end ?? null,
+      },
+    );
+  }
+  async setPayToken(id, payload) {
+    await this.sqlService.query(
+      /*SQL*/ `
+      UPDATE \`${this.alias}\`
+      SET pay_token_hash=:pay_token_hash, pay_token_expires_at=:pay_token_expires_at, pay_token_finalized_at=NULL, updated_at=NOW()
+      WHERE id=:id
+    `,
+      { id, ...payload },
+    );
+  }
+  async finalizePayToken(id) {
+    await this.sqlService.query(
+      /*SQL*/ `
+      UPDATE \`${this.alias}\`
+      SET pay_token_finalized_at=NOW(), updated_at=NOW()
+      WHERE id=:id
+    `,
+      { id },
+    );
+  }
+  async createTable() {
+    await this.sqlService.query(/*SQL*/ `
+      CREATE TABLE IF NOT EXISTS \`${this.alias}\` (
+        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+        invoice_number VARCHAR(32) NOT NULL,
+        customer_id BIGINT UNSIGNED NOT NULL,
+        subscription_id BIGINT UNSIGNED NULL,
+        subscription_period_start DATETIME,
+        subscription_period_end DATETIME,
+        mollie_customer_id VARCHAR(64),
+        mollie_payment_id VARCHAR(64),
+        pay_token_hash CHAR(64),
+        pay_token_expires_at DATETIME,
+        pay_token_finalized_at DATETIME,
+        status ENUM('draft','pending','paid','failed','canceled','expired','refunded') NOT NULL DEFAULT 'draft',
+        amount_due DECIMAL(12,2) NOT NULL,
+        amount_paid DECIMAL(12,2) NOT NULL DEFAULT 0,
+        currency CHAR(3) NOT NULL DEFAULT 'EUR',
+        description VARCHAR(512),
+        payment_terms VARCHAR(255),
+        due_date DATE,
+        issued_at DATETIME,
+        paid_at DATETIME,
+        checkout_url VARCHAR(512),
+        metadata JSON NULL,
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        UNIQUE KEY uq_invoice_number (invoice_number),
+        UNIQUE KEY uq_invoices_pay_token_hash (pay_token_hash),
+        KEY idx_invoices_customer (customer_id),
+        KEY idx_invoices_subscription (subscription_id),
+        KEY idx_invoices_status (status),
+        KEY idx_invoices_due (due_date)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
+    `);
+  }
+}
+exports.InvoicesOrm = InvoicesOrm;

package/lib/mollie/orm/subscription_items_orm.d.ts

@@ -0,0 +1,9 @@
+import { ZOrm } from '../../core/orm/orm';
+import { ZSQLService } from '../../core/sql_service';
+import { ZSubscriptionItem } from '../types/mollie_types';
+export declare class SubscriptionItemsOrm extends ZOrm {
+  constructor(opt: { sqlService: ZSQLService; alias?: string });
+  bulkInsert(items: ZSubscriptionItem[]): Promise<void>;
+  findBySubscription(subscription_id: number): Promise<ZSubscriptionItem[]>;
+  createTable(): Promise<void>;
+}

package/lib/mollie/orm/subscription_items_orm.js

@@ -0,0 +1,45 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SubscriptionItemsOrm = void 0;
+const orm_1 = require('../../core/orm/orm');
+class SubscriptionItemsOrm extends orm_1.ZOrm {
+  constructor(opt) {
+    super({ sqlService: opt.sqlService, alias: opt.alias ?? 'mollie_subscription_items' });
+  }
+  async bulkInsert(items) {
+    for (const item of items) {
+      await this.sqlService.query(
+        /*SQL*/ `
+        INSERT INTO \`${this.alias}\`
+          (subscription_id, description, quantity, unit_price, vat_rate, total_ex_vat, total_inc_vat, sort_order)
+        VALUES
+          (:subscription_id, :description, :quantity, :unit_price, :vat_rate, :total_ex_vat, :total_inc_vat, :sort_order)
+      `,
+        item,
+      );
+    }
+  }
+  async findBySubscription(subscription_id) {
+    return await this.sqlService.exec({
+      query: `SELECT * FROM \`${this.alias}\` WHERE subscription_id=:subscription_id ORDER BY sort_order, id`,
+      params: { subscription_id },
+    });
+  }
+  async createTable() {
+    await this.sqlService.query(/*SQL*/ `
+      CREATE TABLE IF NOT EXISTS \`${this.alias}\` (
+        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+        subscription_id BIGINT UNSIGNED NOT NULL,
+        description VARCHAR(255) NOT NULL,
+        quantity DECIMAL(10,2) NOT NULL DEFAULT 1,
+        unit_price DECIMAL(12,2) NOT NULL,
+        vat_rate DECIMAL(5,2) NOT NULL DEFAULT 0.00,
+        total_ex_vat DECIMAL(12,2) NOT NULL,
+        total_inc_vat DECIMAL(12,2) NOT NULL,
+        sort_order SMALLINT UNSIGNED NOT NULL DEFAULT 0,
+        KEY idx_subscription_items_subscription (subscription_id)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
+    `);
+  }
+}
+exports.SubscriptionItemsOrm = SubscriptionItemsOrm;

package/lib/mollie/orm/subscriptions_orm.d.ts

@@ -0,0 +1,17 @@
+import { ZOrm } from '../../core/orm/orm';
+import { ZSQLService } from '../../core/sql_service';
+import { ZSubscription } from '../types/mollie_types';
+export declare class SubscriptionsOrm extends ZOrm {
+  constructor(opt: { sqlService: ZSQLService; alias?: string; hashSalt?: string });
+  create(subscription: Omit<ZSubscription, 'id' | 'created_at' | 'updated_at'>): Promise<{
+    insertId: number;
+    affectedRows: number;
+  }>;
+  update(id: number, payload: Partial<Omit<ZSubscription, 'id' | 'created_at' | 'updated_at'>>): Promise<void>;
+  findById(id: number): Promise<ZSubscription>;
+  findByMollieSubscriptionId(mollie_subscription_id: string): Promise<ZSubscription>;
+  findByCustomer(customer_id: number): Promise<ZSubscription[]>;
+  findLatestByCustomer(customer_id: number): Promise<ZSubscription>;
+  findAll(): Promise<ZSubscription[]>;
+  createTable(): Promise<void>;
+}

package/lib/mollie/orm/subscriptions_orm.js

@@ -0,0 +1,122 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SubscriptionsOrm = void 0;
+const orm_1 = require('../../core/orm/orm');
+class SubscriptionsOrm extends orm_1.ZOrm {
+  constructor(opt) {
+    super({ sqlService: opt.sqlService, alias: opt.alias || 'mollie_subscriptions' });
+  }
+  async create(subscription) {
+    const res = await this.sqlService.query(
+      /*SQL*/ `
+      INSERT INTO \`${this.alias}\`
+        (customer_id, mollie_customer_id, mollie_subscription_id, status, \`interval\`, description, amount, currency, mandate_id, next_payment_date, canceled_at, metadata)
+      VALUES
+        (:customer_id, :mollie_customer_id, :mollie_subscription_id, :status, :interval, :description, :amount, :currency, :mandate_id, :next_payment_date, :canceled_at, :metadata)
+      ON DUPLICATE KEY UPDATE
+        mollie_customer_id=VALUES(mollie_customer_id),
+        mollie_subscription_id=VALUES(mollie_subscription_id),
+        status=VALUES(status),
+        \`interval\`=VALUES(\`interval\`),
+        description=VALUES(description),
+        amount=VALUES(amount),
+        currency=VALUES(currency),
+        mandate_id=VALUES(mandate_id),
+        next_payment_date=VALUES(next_payment_date),
+        canceled_at=VALUES(canceled_at),
+        metadata=VALUES(metadata),
+        updated_at=NOW()
+    `,
+      subscription,
+    );
+    return res;
+  }
+  async update(id, payload) {
+    const fields = [];
+    const params = { id };
+    const allowed = [
+      'customer_id',
+      'mollie_customer_id',
+      'mollie_subscription_id',
+      'status',
+      'interval',
+      'description',
+      'amount',
+      'currency',
+      'mandate_id',
+      'next_payment_date',
+      'canceled_at',
+      'metadata',
+    ];
+    for (const field of allowed) {
+      if (field in payload) {
+        fields.push(`\`${field}\`=:${field}`);
+        params[field] = payload[field];
+      }
+    }
+    if (fields.length === 0) return;
+    await this.sqlService.query(
+      /*SQL*/ `
+      UPDATE \`${this.alias}\`
+      SET ${fields.join(', ')}, updated_at=NOW()
+      WHERE id=:id
+    `,
+      params,
+    );
+  }
+  async findById(id) {
+    const res = await this.sqlService.exec({
+      query: `SELECT * FROM \`${this.alias}\` WHERE id=:id LIMIT 1`,
+      params: { id },
+    });
+    return res[0];
+  }
+  async findByMollieSubscriptionId(mollie_subscription_id) {
+    const res = await this.sqlService.exec({
+      query: `SELECT * FROM \`${this.alias}\` WHERE mollie_subscription_id=:mollie_subscription_id LIMIT 1`,
+      params: { mollie_subscription_id },
+    });
+    return res[0];
+  }
+  async findByCustomer(customer_id) {
+    return await this.sqlService.exec({
+      query: `SELECT * FROM \`${this.alias}\` WHERE customer_id=:customer_id ORDER BY created_at DESC`,
+      params: { customer_id },
+    });
+  }
+  async findLatestByCustomer(customer_id) {
+    const res = await this.sqlService.exec({
+      query: `SELECT * FROM \`${this.alias}\` WHERE customer_id=:customer_id ORDER BY id DESC LIMIT 1`,
+      params: { customer_id },
+    });
+    return res[0];
+  }
+  async findAll() {
+    return await this.sqlService.exec({ query: `SELECT * FROM \`${this.alias}\` ORDER BY created_at DESC` });
+  }
+  async createTable() {
+    await this.sqlService.query(/*SQL*/ `
+      CREATE TABLE IF NOT EXISTS \`${this.alias}\` (
+        id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+        customer_id BIGINT UNSIGNED NOT NULL,
+        mollie_customer_id VARCHAR(64),
+        mollie_subscription_id VARCHAR(64),
+        status ENUM('setup_pending','pending','active','canceled','suspended','completed') NOT NULL DEFAULT 'setup_pending',
+        \`interval\` VARCHAR(64) NOT NULL,
+        description VARCHAR(512),
+        amount DECIMAL(12,2) NOT NULL,
+        currency CHAR(3) NOT NULL DEFAULT 'EUR',
+        mandate_id VARCHAR(64),
+        next_payment_date DATETIME,
+        canceled_at DATETIME,
+        metadata JSON NULL,
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        UNIQUE KEY uq_subscription_mollie (mollie_subscription_id),
+        KEY idx_subscription_customer (customer_id),
+        KEY idx_subscription_status (status)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
+    `);
+  }
+}
+exports.SubscriptionsOrm = SubscriptionsOrm;

package/lib/mollie/services/customer_service.d.ts

@@ -0,0 +1,14 @@
+import { ZSQLService } from '../../core/sql_service';
+import { ZCustomer } from '../types/mollie_types';
+import { CustomersOrm } from '../orm/customers_orm';
+import { MollieService } from './mollie_service';
+export declare class CustomerService {
+  private opt;
+  protected orm: CustomersOrm;
+  constructor(opt: { sqlService: ZSQLService; mollieService: MollieService });
+  autoInit(): Promise<void>;
+  list(): Promise<ZCustomer[]>;
+  findById(id: number): Promise<ZCustomer | undefined>;
+  upsert(customer: Omit<ZCustomer, 'id' | 'created_at' | 'updated_at'>): Promise<ZCustomer>;
+  update(id: number, customer: Partial<Omit<ZCustomer, 'id' | 'created_at' | 'updated_at'>>): Promise<ZCustomer>;
+}

package/lib/mollie/services/customer_service.js

@@ -0,0 +1,53 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.CustomerService = void 0;
+const customers_orm_1 = require('../orm/customers_orm');
+class CustomerService {
+  constructor(opt) {
+    this.opt = opt;
+    this.orm = new customers_orm_1.CustomersOrm({ sqlService: opt.sqlService });
+  }
+  async autoInit() {
+    await this.orm.ensureTableExists();
+  }
+  async list() {
+    return await this.orm.findAll();
+  }
+  async findById(id) {
+    return await this.orm.findById(id);
+  }
+  async upsert(customer) {
+    const existing = await this.orm.findByEmail(customer.email);
+    const mollie_customer_id = existing?.mollie_customer_id
+      ? existing.mollie_customer_id
+      : (
+          await this.opt.mollieService.createCustomer({
+            name: customer.name,
+            email: customer.email,
+            locale: customer.locale ?? undefined,
+            metadata: {
+              ...(customer.metadata ?? {}),
+              company: customer.company ?? undefined,
+              phone: customer.phone ?? undefined,
+              btw_nummer: customer.btw_nummer ?? undefined,
+              address_line1: customer.address_line1 ?? undefined,
+              address_line2: customer.address_line2 ?? undefined,
+              postal_code: customer.postal_code ?? undefined,
+              city: customer.city ?? undefined,
+              country: customer.country ?? undefined,
+            },
+          })
+        ).id;
+    await this.orm.create({ ...existing, ...customer, mollie_customer_id });
+    return await this.orm.findByEmail(customer.email);
+  }
+  async update(id, customer) {
+    const existing = await this.orm.findById(id);
+    if (!existing) {
+      throw new Error(`Customer ${id} not found`);
+    }
+    await this.orm.update(id, customer);
+    return await this.orm.findById(id);
+  }
+}
+exports.CustomerService = CustomerService;

package/lib/mollie/services/invoice_service.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="node" />
+import { CustomerService } from './customer_service';
+import { RenderData } from '../../core/types/site_config';
+import { ZMailService } from '../../core/mail_service';
+import { MollieService } from './mollie_service';
+import { ZSQLService } from '../../core/sql_service';
+import {
+  ZInvoice,
+  CreateInvoiceInput,
+  ZInvoicePayment,
+  CreateInvoiceOverrides,
+  ZIssuedPayToken,
+  ZPayResolveResult,
+} from '../types/mollie_types';
+export declare class InvoiceService {
+  private opt;
+  private invoicesOrm;
+  private itemsOrm;
+  private paymentsOrm;
+  private subscriptionsOrm;
+  private subscriptionItemsOrm;
+  private payTokenSecret;
+  private payTokenLifetimeMs;
+  private mailService;
+  private get config();
+  private get baseUrl();
+  constructor(opt: {
+    sqlService: ZSQLService;
+    mollieService: MollieService;
+    customerService: CustomerService;
+    mailService: ZMailService;
+    siteConfig: Omit<RenderData, 'context'>;
+    payTokenSecret: string;
+  });
+  autoInit(): Promise<void>;
+  private ensurePayTokenSchema;
+  private ensureSubscriptionInvoiceSchema;
+  private ensureSubsidyItemTypeSchema;
+  private ensureInvoicePaymentSchema;
+  private generateInvoiceNumber;
+  private getWebhookUrl;
+  private signPayTokenRaw;
+  private buildPayToken;
+  private parseSignedPayToken;
+  private verifySignedPayToken;
+  private hashPayTokenRaw;
+  private getInvoiceBundle;
+  private formatMoney;
+  private calcTotals;
+  private createPayTokenRaw;
+  private isInvoicePaid;
+  private isInvoiceFinalizedForPay;
+  private isTokenExpired;
+  createMolliePaymentForInvoice(
+    invoice: ZInvoice,
+    opt?: {
+      sequenceType?: 'oneoff' | 'first' | 'recurring';
+      mandateId?: string | null;
+      metadata?: Record<string, any>;
+    },
+  ): Promise<import('@mollie/api-client/dist/types/data/payments/Payment').default>;
+  private issueOrRotatePayToken;
+  ensurePayLink(invoiceId: number): Promise<ZIssuedPayToken>;
+  resolvePayToken(token: string): Promise<ZPayResolveResult>;
+  listInvoices(): Promise<ZInvoice[]>;
+  getInvoiceById(invoiceId: number): Promise<ZInvoice | undefined>;
+  listPayments(invoice_id: number): Promise<ZInvoicePayment[]>;
+  createInvoiceWithPayment(input: CreateInvoiceInput): Promise<{
+    invoice: ZInvoice;
+    checkoutUrl: string;
+    payment: import('@mollie/api-client/dist/types/data/payments/Payment').default;
+    payUrl: string;
+  }>;
+  createInvoiceFromItems(
+    input: CreateInvoiceInput,
+    overrides?: CreateInvoiceOverrides,
+  ): Promise<{
+    invoice: ZInvoice;
+    pay: ZIssuedPayToken;
+  }>;
+  createInvoiceDraft(input: CreateInvoiceInput): Promise<{
+    invoice: ZInvoice;
+    pay: ZIssuedPayToken;
+  }>;
+  syncPayment(paymentId: string): Promise<{
+    invoiceId: number;
+    status: 'failed' | 'canceled' | 'pending' | 'expired' | 'paid' | 'refunded';
+  }>;
+  generateInvoicePdfBuffer(invoiceId: number): Promise<Buffer>;
+  sendInvoiceEmail(
+    invoiceId: number,
+    recipient?: string,
+    opt?: {
+      mode?: 'invoice' | 'receipt';
+    },
+  ): Promise<{
+    invoice_number: string;
+    recipient: string;
+    payUrl: string;
+    payTokenExpiresAt: string;
+  }>;
+}