shutro-erp 0.3.0 → 0.3.2

package/dist/payment/module.js

@@ -0,0 +1,74 @@
+/**
+ * The data layer of online payments (RFC 0017 §5.5): a company's payment providers (the adapter, its mode, the
+ * journal the money arrives in, the inbound webhook its callbacks come through) and the transactions customers
+ * start from the portal (the invoice, the amount, the provider's reference, the state, the `account.payment` that
+ * settled it). Credentials are never in records: an adapter reads them from the environment; the callbacks' secret
+ * is the endpoint's.
+ */
+import { randomBytes } from 'node:crypto';
+import { accountPortalShutro } from '../account_portal/index.js';
+import { integrationsShutro } from '../integrations/index.js';
+import { defineModel, defineModule, f } from './.kosh/bindings.js';
+const ALL = ['read', 'write', 'create', 'unlink', 'export', 'import'];
+/** A transaction's reference: what the provider is told and gives back. */
+export const newReference = () => `PAY-${randomBytes(9).toString('base64url')}`;
+/** The adapters Kosh ships; a module adding one extends this selection. */
+export const PROVIDERS = {
+    fake: 'Test provider (no money moves)',
+    sslcommerz: 'SSLCommerz',
+};
+export const PaymentProvider = defineModel('payment.provider', {
+    label: 'Payment provider',
+    recName: 'name',
+    companyScoped: { required: true },
+    order: ['sequence asc', 'id asc'],
+    tracking: ['state', 'journal'],
+    access: { 'account.user': ['read'], 'account.manager': ALL },
+    fields: {
+        name: f.char({ required: true }),
+        code: f.selection(PROVIDERS, { required: true, default: 'fake', label: 'Provider' }),
+        state: f.selection({ disabled: 'Disabled', test: 'Test', live: 'Live' }, { required: true, default: 'test', label: 'Mode' }),
+        /** Where the money arrives: the payments are registered in this bank (or cash) journal. */
+        journal: f.many2one('account.journal', { required: true, checkCompany: true }),
+        /** The inbound webhook the provider's callbacks come through (made with the provider). */
+        endpoint: f.many2one('webhook.endpoint', { label: 'Callback endpoint' }),
+        sequence: f.integer({ required: true, default: 10 }),
+    },
+});
+export const PaymentTransaction = defineModel('payment.transaction', {
+    label: 'Payment transaction',
+    recName: 'reference',
+    companyScoped: { required: true },
+    order: ['id desc'],
+    tracking: ['state'],
+    access: {
+        'account.invoicing': ['read'],
+        'account.user': ['read', 'export'],
+        'account.manager': ['read', 'export'],
+    },
+    fields: {
+        reference: f.char({ required: true, index: 'unique', default: newReference }),
+        provider: f.many2one('payment.provider', { required: true, checkCompany: true }),
+        move: f.many2one('account.move', { required: true, label: 'Invoice', checkCompany: true }),
+        partner: f.many2one('res.partner', { label: 'Customer' }),
+        currency: f.many2one('res.currency', { required: true }),
+        amount: f.monetary({ currency: 'currency', required: true }),
+        state: f.selection({
+            pending: 'Pending',
+            done: 'Paid',
+            failed: 'Failed',
+            cancelled: 'Cancelled',
+        }, { required: true, default: 'pending' }),
+        providerReference: f.char({ label: 'Provider reference' }),
+        /** The payment registered when the provider confirmed. */
+        payment: f.many2one('account.payment', { label: 'Payment' }),
+        error: f.text(),
+        doneAt: f.datetime({ label: 'Paid at' }),
+    },
+});
+export const paymentShutro = defineModule({
+    name: 'payment',
+    version: '0.1.0',
+    depends: [accountPortalShutro, integrationsShutro],
+    models: [PaymentProvider, PaymentTransaction],
+});

package/dist/payment/providers.d.ts

@@ -0,0 +1,64 @@
+import type { InboundCall } from '../modules-sdk/index.js';
+export type PaymentStatus = 'pending' | 'done' | 'failed' | 'cancelled';
+export interface PaymentRequest {
+    /** The transaction's reference: what the provider gives back. */
+    readonly reference: string;
+    /** Decimal string in the currency's unit (`'1250.00'`). */
+    readonly amount: string;
+    /** ISO 4217 (`BDT`). */
+    readonly currency: string;
+    /** What is paid (`Invoice INV/2026/0042`). */
+    readonly description: string;
+    readonly customer: {
+        readonly name: string;
+        readonly email: string | null;
+        readonly phone: string | null;
+        readonly street: string | null;
+        readonly city: string | null;
+        readonly zip: string | null;
+        /** ISO 3166 alpha-2. */
+        readonly country: string | null;
+    };
+    /** Where the provider sends the customer back (GET or POST; the server forwards them to the portal). */
+    readonly returnUrl: string;
+    /** The inbound webhook the provider calls (absolute URL). */
+    readonly callbackUrl: string;
+    readonly mode: 'test' | 'live';
+}
+export interface PaymentResult {
+    readonly reference: string;
+    readonly status: PaymentStatus;
+    readonly providerReference: string | null;
+    /** What the provider says was paid; checked against the transaction. */
+    readonly amount?: string;
+    readonly currency?: string;
+    readonly error?: string;
+}
+export interface PaymentAdapter {
+    readonly code: string;
+    /** Whether its credentials are set (the portal offers only providers whose adapter can work). */
+    configured(mode: 'test' | 'live'): boolean;
+    /** Starts a payment; returns the page to send the customer to. */
+    createPayment(request: PaymentRequest): Promise<{
+        readonly redirectUrl: string;
+    }>;
+    /** A callback's event id, or `null` when it is not genuine (checked with the endpoint's secret). */
+    verifyCallback(call: InboundCall, secret: string): string | null | Promise<string | null>;
+    /** What a verified callback says. */
+    readCallback(call: InboundCall): PaymentResult | null;
+    /** The provider's word on a payment (null: unknown to it). */
+    status(reference: string, mode: 'test' | 'live'): Promise<PaymentResult | null>;
+}
+/** The fake adapter's header: HMAC-SHA256 (hex) of the raw body with the endpoint's secret. */
+export declare const FAKE_SIGNATURE = "x-fake-signature";
+export declare const fakeAdapter: PaymentAdapter & {
+    /** The payment the fake checkout shows. */
+    pending(reference: string): PaymentRequest | null;
+    /** The customer paid or declined on the fake checkout: the result and the signed callback body. */
+    complete(reference: string, paid: boolean, secret: string): {
+        body: string;
+        signature: string;
+    } | null;
+};
+/** The adapters by code. */
+export declare const ADAPTERS: ReadonlyMap<string, PaymentAdapter>;

package/dist/payment/providers.js

@@ -0,0 +1,77 @@
+/**
+ * Payment provider adapters (RFC 0017 §5.5). An adapter starts a payment at the provider (a page to send the customer
+ * to), reads the provider's callbacks (verified with the callback endpoint's secret), and asks the provider for a
+ * payment's status (when the customer returns before the callback). Credentials come from the environment, never
+ * from records. The fake adapter moves no money: its checkout page (served by this module) lets the customer pay or
+ * decline, and it calls back like a real provider, signed.
+ */
+import { createHmac, randomUUID, timingSafeEqual } from 'node:crypto';
+/** The fake adapter's header: HMAC-SHA256 (hex) of the raw body with the endpoint's secret. */
+export const FAKE_SIGNATURE = 'x-fake-signature';
+/** What the fake checkout knows (per process: it is for tests and demonstrations). */
+const fakeLedger = new Map();
+export const fakeAdapter = {
+    code: 'fake',
+    configured: (mode) => mode === 'test',
+    async createPayment(request) {
+        fakeLedger.set(request.reference, {
+            reference: request.reference,
+            status: 'pending',
+            providerReference: null,
+            request,
+        });
+        return {
+            redirectUrl: `/api/v1/payment/fake/checkout/${encodeURIComponent(request.reference)}`,
+        };
+    },
+    verifyCallback(call, secret) {
+        const given = Buffer.from(call.headers[FAKE_SIGNATURE] ?? '');
+        const expected = Buffer.from(createHmac('sha256', secret).update(call.body).digest('hex'));
+        if (given.length !== expected.length || !timingSafeEqual(given, expected))
+            return null;
+        const id = call.json?.id;
+        return typeof id === 'string' && id !== '' ? id : null;
+    },
+    readCallback(call) {
+        const event = call.json;
+        if (typeof event?.reference !== 'string')
+            return null;
+        return {
+            reference: event.reference,
+            status: event.status ?? 'pending',
+            providerReference: event.providerReference ?? null,
+            ...(event.amount === undefined ? {} : { amount: event.amount }),
+            ...(event.currency === undefined ? {} : { currency: event.currency }),
+        };
+    },
+    async status(reference) {
+        const known = fakeLedger.get(reference);
+        if (known === undefined)
+            return null;
+        const { request: _request, ...result } = known;
+        return result;
+    },
+    pending(reference) {
+        const known = fakeLedger.get(reference);
+        return known?.status === 'pending' ? known.request : null;
+    },
+    complete(reference, paid, secret) {
+        const known = fakeLedger.get(reference);
+        if (known === undefined || known.status !== 'pending')
+            return null;
+        const result = {
+            reference,
+            status: paid ? 'done' : 'failed',
+            providerReference: `FAKE-${randomUUID().slice(0, 8).toUpperCase()}`,
+            amount: known.request.amount,
+            currency: known.request.currency,
+        };
+        fakeLedger.set(reference, { ...result, request: known.request });
+        const body = JSON.stringify({ id: `evt_${randomUUID()}`, ...result });
+        return { body, signature: createHmac('sha256', secret).update(body).digest('hex') };
+    },
+};
+/** The adapters by code. */
+export const ADAPTERS = new Map([
+    [fakeAdapter.code, fakeAdapter],
+]);

package/dist/payment/settle.d.ts

@@ -0,0 +1,11 @@
+import type { Env } from './.kosh/bindings.js';
+import type { PaymentResult } from './providers.js';
+export interface Settled {
+    readonly reference: string;
+    readonly state: string;
+    /** False when it was settled before (a repeated callback, a return after the callback). */
+    readonly changed: boolean;
+    readonly payment: number | null;
+}
+/** Applies the provider's result to transaction `result.reference`, as the system in the transaction's company. */
+export declare function settle(env: Env, result: PaymentResult): Promise<Settled | null>;

package/dist/payment/settle.js

@@ -0,0 +1,59 @@
+/**
+ * Settling a transaction (RFC 0017 §5.5): the provider's word — by its callback or asked when the customer returns —
+ * moves a pending transaction to paid, failed or cancelled. Paid registers an `account.payment` for the invoice in
+ * the provider's journal (Accounting posts and reconciles it), **once**: a transaction-scoped advisory lock on the
+ * reference serialises a callback and a return arriving together, and a paid transaction is never settled again
+ * (a failed or cancelled one becomes paid if the provider confirms it later).
+ */
+import { registerPayment } from '../accounting/index.js';
+import { orm } from '../server/orm.js';
+/** Applies the provider's result to transaction `result.reference`, as the system in the transaction's company. */
+export async function settle(env, result) {
+    await env.sql `SELECT pg_advisory_xact_lock(hashtext(${`payment:${result.reference}`}))`;
+    const found = await env
+        .model('payment.transaction')
+        .search({ where: { reference: result.reference }, limit: 1 });
+    if (found.length === 0)
+        return null;
+    const [tx] = await found.load({ provider: true, currency: true, move: true });
+    if (tx === undefined)
+        return null;
+    const same = { reference: tx.reference, changed: false };
+    // Paid is final. A failure or cancellation is not: the provider may still confirm the payment later (a retry,
+    // a failure reported early) — then it is paid. Nothing else changes a settled transaction.
+    if (tx.state === 'done' ||
+        result.status === 'pending' ||
+        (tx.state !== 'pending' && result.status !== 'done'))
+        return { ...same, state: tx.state, payment: tx.payment?.id ?? null };
+    if (result.status !== 'done') {
+        await found.write({
+            state: result.status,
+            providerReference: result.providerReference,
+            error: result.error ?? (result.status === 'failed' ? 'The provider refused the payment.' : null),
+        });
+        return { ...same, state: result.status, changed: true, payment: null };
+    }
+    // What the provider says was paid must be what was asked.
+    const amount = tx.amount.amount;
+    if ((result.amount !== undefined && !orm.toDecimal(result.amount).eq(amount)) ||
+        (result.currency !== undefined && result.currency !== tx.currency.name)) {
+        const error = `The provider reports ${result.amount ?? '?'} ${result.currency ?? ''}, not ${amount.toFixed()} ${tx.currency.name}.`;
+        await found.write({ state: 'failed', providerReference: result.providerReference, error });
+        return { ...same, state: 'failed', changed: true, payment: null };
+    }
+    const payment = await registerPayment(env, {
+        moves: [tx.move.id],
+        journal: tx.provider.journal.id,
+        amount: amount.toFixed(),
+        memo: `${tx.provider.name} ${result.providerReference ?? tx.reference}`,
+    });
+    await found.write({
+        state: 'done',
+        providerReference: result.providerReference,
+        payment: payment.id,
+        error: null,
+        doneAt: new Date(),
+    });
+    await env.flush(); // checks run in this system scope, not at commit (Shutro request #11)
+    return { ...same, state: 'done', changed: true, payment: payment.id };
+}

package/dist/payment/sslcommerz.d.ts

@@ -0,0 +1,12 @@
+import type { PaymentAdapter } from './providers.js';
+export interface SslcommerzOptions {
+    readonly storeId?: string | undefined;
+    readonly storePassword?: string | undefined;
+    /** The sandbox (default) or the live system. */
+    readonly sandbox?: boolean;
+    /** The HTTP client (tests). */
+    readonly fetch?: typeof fetch;
+}
+export declare function sslcommerzAdapter(options?: SslcommerzOptions): PaymentAdapter;
+/** SSLCommerz with its credentials from the environment, read on first use (after the server applied its names). */
+export declare function sslcommerzFromEnvironment(env?: NodeJS.ProcessEnv): PaymentAdapter;

package/dist/payment/sslcommerz.js

@@ -0,0 +1,185 @@
+const HOSTS = {
+    sandbox: 'https://sandbox.sslcommerz.com',
+    live: 'https://securepay.sslcommerz.com',
+};
+/** The IPN's fields: a form post (or JSON, which some integrations send). */
+function fieldsOf(call) {
+    if (call.json !== null && typeof call.json === 'object' && !Array.isArray(call.json))
+        return Object.fromEntries(Object.entries(call.json).map(([k, v]) => [k, String(v ?? '')]));
+    return Object.fromEntries(new URLSearchParams(call.body));
+}
+/** What was paid, in the transaction's currency (`currency_type` / `currency_amount` when it was not BDT). */
+const paidAmount = (f) => f['currency_amount'] || f['amount'] || '';
+const paidCurrency = (f) => f['currency_type'] || f['currency'] || '';
+const same = (a, b) => a !== '' && b !== '' && Number(a).toFixed(2) === Number(b).toFixed(2);
+const IPN_STATUS = {
+    VALID: 'done',
+    VALIDATED: 'done',
+    FAILED: 'failed',
+    CANCELLED: 'cancelled',
+    EXPIRED: 'cancelled',
+};
+const countryName = (code) => {
+    if (code === null || code === '')
+        return 'Bangladesh';
+    try {
+        return new Intl.DisplayNames(['en'], { type: 'region' }).of(code.toUpperCase()) ?? code;
+    }
+    catch {
+        return code;
+    }
+};
+export function sslcommerzAdapter(options = {}) {
+    const storeId = options.storeId ?? '';
+    const storePassword = options.storePassword ?? '';
+    const sandbox = options.sandbox ?? true;
+    const host = sandbox ? HOSTS.sandbox : HOSTS.live;
+    const http = options.fetch ?? fetch;
+    const ready = storeId !== '' && storePassword !== '';
+    const credentials = () => {
+        if (!ready)
+            throw new Error('SSLCommerz is not configured: set SHUTRO_ERP_SSLCOMMERZ_STORE_ID and SHUTRO_ERP_SSLCOMMERZ_STORE_PASSWORD.');
+        return { store_id: storeId, store_passwd: storePassword };
+    };
+    const getJson = async (path, query) => {
+        const url = `${host}${path}?${new URLSearchParams({ ...query, ...credentials(), format: 'json' })}`;
+        const res = await http(url, { signal: AbortSignal.timeout(15_000) });
+        if (!res.ok)
+            throw new Error(`SSLCommerz answered ${res.status}.`);
+        return (await res.json());
+    };
+    /** The attempts SSLCommerz knows for a transaction id. */
+    const attempts = async (reference) => {
+        const answer = await getJson('/validator/api/merchantTransIDvalidationAPI.php', {
+            tran_id: reference,
+        });
+        if (answer['APIConnect'] !== 'DONE')
+            return null;
+        const element = Array.isArray(answer['element'])
+            ? answer['element']
+            : [];
+        return element.map((e) => Object.fromEntries(Object.entries(e).map(([k, v]) => [k, String(v ?? '')])));
+    };
+    return {
+        code: 'sslcommerz',
+        configured: (mode) => ready && (mode === 'test') === sandbox,
+        async createPayment(request) {
+            const body = new URLSearchParams({
+                ...credentials(),
+                total_amount: request.amount,
+                currency: request.currency,
+                tran_id: request.reference,
+                success_url: request.returnUrl,
+                fail_url: request.returnUrl,
+                cancel_url: request.returnUrl,
+                ipn_url: request.callbackUrl,
+                cus_name: request.customer.name || 'Customer',
+                cus_email: request.customer.email ?? '',
+                cus_add1: request.customer.street ?? 'N/A',
+                cus_city: request.customer.city ?? 'N/A',
+                cus_postcode: request.customer.zip ?? '0000',
+                cus_country: countryName(request.customer.country),
+                cus_phone: request.customer.phone ?? 'N/A',
+                shipping_method: 'NO',
+                product_name: request.description,
+                product_category: 'Invoice',
+                product_profile: 'general',
+                emi_option: '0',
+                value_a: request.reference,
+            });
+            const res = await http(`${host}/gwprocess/v4/api.php`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/x-www-form-urlencoded' },
+                body,
+                signal: AbortSignal.timeout(15_000),
+            });
+            const answer = (await res.json().catch(() => ({})));
+            const page = answer['GatewayPageURL'];
+            if (answer['status'] !== 'SUCCESS' || typeof page !== 'string' || page === '')
+                throw new Error(`SSLCommerz refused the payment: ${String(answer['failedreason'] ?? res.status)}.`);
+            return { redirectUrl: page };
+        },
+        async verifyCallback(call) {
+            const f = fieldsOf(call);
+            const reference = f['tran_id'] ?? '';
+            const status = IPN_STATUS[f['status'] ?? ''];
+            if (reference === '' || status === undefined || !ready)
+                return null;
+            if (status === 'done') {
+                // Paid: SSLCommerz confirms this val_id, for this transaction, amount and currency.
+                const valId = f['val_id'] ?? '';
+                if (valId === '')
+                    return null;
+                const v = await getJson('/validator/api/validationserverAPI.php', { val_id: valId });
+                const fv = Object.fromEntries(Object.entries(v).map(([k, x]) => [k, String(x ?? '')]));
+                const confirmed = (fv['status'] === 'VALID' || fv['status'] === 'VALIDATED') &&
+                    fv['tran_id'] === reference &&
+                    same(paidAmount(fv), paidAmount(f)) &&
+                    paidCurrency(fv) === paidCurrency(f);
+                return confirmed ? valId : null;
+            }
+            // Failed or cancelled: SSLCommerz knows the transaction and no attempt of it succeeded.
+            const known = await attempts(reference);
+            if (known === null || known.length === 0)
+                return null;
+            if (known.some((a) => a['status'] === 'VALID' || a['status'] === 'VALIDATED'))
+                return null;
+            return `${reference}:${f['status']}:${f['val_id'] || f['tran_date'] || ''}`;
+        },
+        readCallback(call) {
+            const f = fieldsOf(call);
+            const status = IPN_STATUS[f['status'] ?? ''];
+            if ((f['tran_id'] ?? '') === '' || status === undefined)
+                return null;
+            return {
+                reference: f['tran_id'],
+                status,
+                providerReference: f['bank_tran_id'] || f['val_id'] || null,
+                ...(status === 'done' ? { amount: paidAmount(f), currency: paidCurrency(f) } : {}),
+                ...(f['error'] ? { error: f['error'] } : {}),
+            };
+        },
+        async status(reference) {
+            if (!ready)
+                return null;
+            const known = await attempts(reference);
+            if (known === null || known.length === 0)
+                return null;
+            const paid = known.find((a) => a['status'] === 'VALID' || a['status'] === 'VALIDATED');
+            if (paid !== undefined)
+                return {
+                    reference,
+                    status: 'done',
+                    providerReference: paid['bank_tran_id'] || paid['val_id'] || null,
+                    amount: paidAmount(paid),
+                    currency: paidCurrency(paid),
+                };
+            if (known.some((a) => a['status'] === 'PENDING'))
+                return { reference, status: 'pending', providerReference: null };
+            const last = known.at(-1);
+            return {
+                reference,
+                status: 'failed',
+                providerReference: last?.['val_id'] || null,
+                ...(last?.['error'] ? { error: last['error'] } : {}),
+            };
+        },
+    };
+}
+/** SSLCommerz with its credentials from the environment, read on first use (after the server applied its names). */
+export function sslcommerzFromEnvironment(env = process.env) {
+    let made;
+    const real = () => (made ??= sslcommerzAdapter({
+        storeId: env['KOSH_SSLCOMMERZ_STORE_ID'],
+        storePassword: env['KOSH_SSLCOMMERZ_STORE_PASSWORD'],
+        sandbox: env['KOSH_SSLCOMMERZ_SANDBOX'] !== 'false',
+    }));
+    return {
+        code: 'sslcommerz',
+        configured: (mode) => real().configured(mode),
+        createPayment: (request) => real().createPayment(request),
+        verifyCallback: (call, secret) => real().verifyCallback(call, secret),
+        readCallback: (call) => real().readCallback(call),
+        status: (reference, mode) => real().status(reference, mode),
+    };
+}

package/dist/portal/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 435daa394f2704fc
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: bae647ca883975a1
 // Bindings of module `portal`: import the definition API from here to get types scoped to what it can see.
 export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
 import { definitions } from '../../server/orm.js';

package/dist/portal/.kosh/schema.d.ts

@@ -1,10 +1,11 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 435daa394f2704fc
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: bae647ca883975a1
 // Schema view of module `portal` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
 /** Model name → model type (RFC 0002 §7.7). */
 export interface SchemaView {
   readonly 'audit.event': AuditEvent;
+  readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
@@ -45,6 +46,34 @@ export interface AuditEvent {
 export interface AuditEventMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'audit.event'> {
 }
 
+/** `auth.api_key` (owner: base). */
+export interface AuthApiKey {
+  readonly name: 'auth.api_key';
+  readonly fields: {
+    readonly id: F.Id<'auth.api_key'>;
+    readonly createdAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly updatedAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly createdBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly updatedBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly displayName: F.Char<{ readonly required: true; readonly readonly: true; readonly compute: true }>;
+    readonly name: F.Char<{ readonly required: true }>;
+    readonly user: F.Many2one<'res.users', { readonly required: true }>;
+    readonly tokenHash: F.Char<{ readonly required: true }>;
+    readonly prefix: F.Char<{ readonly required: true }>;
+    readonly scopes: F.Text<{ readonly required: true }>;
+    readonly expiresAt: F.Datetime<{ readonly required: true }>;
+    readonly lastUsedAt: F.Datetime;
+    readonly lastUsedIp: F.Char;
+    readonly revoked: F.Bool<{ readonly required: true; readonly default: true }>;
+    readonly issuedBy: F.Many2one<'res.users'>;
+  };
+  readonly methods: AuthApiKeyMethods;
+}
+
+/** Methods of `auth.api_key`: declared ones and transitions. */
+export interface AuthApiKeyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.api_key'> {
+}
+
 /** `auth.credential` (owner: base). */
 export interface AuthCredential {
   readonly name: 'auth.credential';
@@ -336,6 +365,7 @@ export interface ResUsers {
     readonly companies: F.Many2many<'res.company', { readonly required: true }>;
     readonly lang: F.Char<{ readonly default: true }>;
     readonly tz: F.Char<{ readonly default: true }>;
+    readonly isService: F.Bool<{ readonly required: true; readonly default: true }>;
     readonly portalPartner: F.Many2one<'res.partner'>; // portal
   };
   readonly methods: ResUsersMethods;

package/dist/portal/routes-documents.js

@@ -207,6 +207,11 @@ export function registerPortalDocumentRoutes(context) {
                     ? {}
                     : { lineFields: meta(d.lineModel, d.spec.lines.fields), lines }),
                 actions: await available(su, d, id),
+                payable: d.spec.payment !== undefined &&
+                    (await ref(su, d.model.name).search({
+                        where: { and: [{ id }, d.spec.payment.when] },
+                        limit: 1,
+                    })).length > 0,
                 pdf: d.spec.pdf !== undefined,
                 thread: d.spec.thread === true,
             };

package/dist/product/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 5d099798463eb84a
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 86d7229d7b275957
 // Bindings of module `product`: import the definition API from here to get types scoped to what it can see.
 export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
 import { definitions } from '../../server/orm.js';

package/dist/product/.kosh/schema.d.ts

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 5d099798463eb84a
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 86d7229d7b275957
 // Schema view of module `product` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -6,6 +6,7 @@ import type { F } from '../../server/orm.js';
 export interface SchemaView {
   readonly 'account.tax': AccountTax;
   readonly 'audit.event': AuditEvent;
+  readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
@@ -73,6 +74,34 @@ export interface AuditEvent {
 export interface AuditEventMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'audit.event'> {
 }
 
+/** `auth.api_key` (owner: base). */
+export interface AuthApiKey {
+  readonly name: 'auth.api_key';
+  readonly fields: {
+    readonly id: F.Id<'auth.api_key'>;
+    readonly createdAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly updatedAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly createdBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly updatedBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly displayName: F.Char<{ readonly required: true; readonly readonly: true; readonly compute: true }>;
+    readonly name: F.Char<{ readonly required: true }>;
+    readonly user: F.Many2one<'res.users', { readonly required: true }>;
+    readonly tokenHash: F.Char<{ readonly required: true }>;
+    readonly prefix: F.Char<{ readonly required: true }>;
+    readonly scopes: F.Text<{ readonly required: true }>;
+    readonly expiresAt: F.Datetime<{ readonly required: true }>;
+    readonly lastUsedAt: F.Datetime;
+    readonly lastUsedIp: F.Char;
+    readonly revoked: F.Bool<{ readonly required: true; readonly default: true }>;
+    readonly issuedBy: F.Many2one<'res.users'>;
+  };
+  readonly methods: AuthApiKeyMethods;
+}
+
+/** Methods of `auth.api_key`: declared ones and transitions. */
+export interface AuthApiKeyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.api_key'> {
+}
+
 /** `auth.credential` (owner: base). */
 export interface AuthCredential {
   readonly name: 'auth.credential';
@@ -307,6 +336,7 @@ export interface ResUsers {
     readonly companies: F.Many2many<'res.company', { readonly required: true }>;
     readonly lang: F.Char<{ readonly default: true }>;
     readonly tz: F.Char<{ readonly default: true }>;
+    readonly isService: F.Bool<{ readonly required: true; readonly default: true }>;
   };
   readonly methods: ResUsersMethods;
 }

package/dist/project/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 1aabc867063cb52e
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 8538c294f98318cd
 // Bindings of module `project`: import the definition API from here to get types scoped to what it can see.
 export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
 import { definitions } from '../../server/orm.js';