@things-factory/saas 0.0.0-stage → 10.1.236

package/dist-server/service/saas-service.d.ts

@@ -0,0 +1,119 @@
+import { Transaction } from '@things-factory/accounting';
+import { Patch } from '@things-factory/asset/dist-server/service/patches.js';
+import { Domain } from '@things-factory/shell';
+import { EntityManager } from 'typeorm';
+import { SaasScope } from './saas-access';
+import { SaasAccount } from './saas-account';
+import { SaasBill } from './saas-bill';
+import { SaasSeat } from './saas-seat';
+import { SaasSubscription } from './saas-subscription';
+import { SaasTrend } from './saas-trend-type';
+export declare const SAAS_ACCOUNT_FACT = "saas-account";
+export declare const SAAS_SUBSCRIPTION_FACT = "saas-subscription";
+export declare function saveSaasAccounts(tx: EntityManager, domain: Domain, user: any, patches: Patch[]): Promise<SaasAccount[]>;
+export declare function saveSaasSubscriptions(tx: EntityManager, domain: Domain, user: any, scope: SaasScope, accountId: string, patches: Patch[]): Promise<SaasSubscription[]>;
+/** The subscriptions of an account, with the seats held today. */
+export declare function saasSubscriptionsOf(tx: EntityManager, domain: Domain, scope: SaasScope, accountId: string, today: string): Promise<SaasSubscription[]>;
+export declare function saveSaasSeats(tx: EntityManager, domain: Domain, user: any, scope: SaasScope, subscriptionId: string, patches: Patch[]): Promise<SaasSeat[]>;
+export declare function saasSeatsOf(tx: EntityManager, domain: Domain, scope: SaasScope, subscriptionId: string): Promise<SaasSeat[]>;
+export interface SaasBillFields {
+    id?: string | null;
+    month: string;
+    billedOn?: string | null;
+    description?: string | null;
+    lines: {
+        subscriptionId?: string | null;
+        label?: string | null;
+        amount: number;
+    }[];
+}
+export declare function saveSaasBill(tx: EntityManager, domain: Domain, user: any, scope: SaasScope, accountId: string, input: SaasBillFields): Promise<SaasBill>;
+export declare function deleteSaasBill(tx: EntityManager, domain: Domain, scope: SaasScope, id: string): Promise<boolean>;
+/** The bills of some accounts (all when none named) from a month on, with their lines and totals, latest first. */
+export declare function billsOf(tx: EntityManager, domain: Domain, accountIds?: string[], from?: string, to?: string): Promise<SaasBill[]>;
+export declare function saasBillsOf(tx: EntityManager, domain: Domain, scope: SaasScope, accountId: string): Promise<SaasBill[]>;
+export interface SaasExpectedRow {
+    accountId: string;
+    accountName: string;
+    counterpartyId?: string | null;
+    paymentAccountId?: string | null;
+    month: string;
+    day: string | null;
+    amount: number;
+    currency: string;
+    /** A bill is written for the month: the amount is the bill's, not an estimate. */
+    billed: boolean;
+}
+/**
+ * What each account is expected to be billed, month by month from `from` to `to`: the bill when one is written for the
+ * month, else what its subscriptions say (usage at the average of its latest bills).
+ */
+export declare function saasExpected(tx: EntityManager, domain: Domain, from: string, to: string): Promise<SaasExpectedRow[]>;
+/**
+ * The bills of the months from `from` to `to` as series - all, an account, a subscription - and a department series: a
+ * line of a seat plan split by the seats held at the month's end by department, any other line its subscription's
+ * department. Plus what the latest month's bills are worth telling.
+ */
+export declare function saasCostTrend(tx: EntityManager, domain: Domain, from: string, to: string): Promise<{
+    months: string[];
+    all: import("./saas-rules").TrendSeries[];
+    accounts: {
+        name: string;
+        key: string;
+        accountId?: string | null;
+        subscriptionId?: string | null;
+        currency: string;
+        amounts: number[];
+        total: number;
+        monthOverMonth: number | null;
+        yearOverYear: number | null;
+    }[];
+    subscriptions: {
+        name: string;
+        accountName: string;
+        key: string;
+        accountId?: string | null;
+        subscriptionId?: string | null;
+        currency: string;
+        amounts: number[];
+        total: number;
+        monthOverMonth: number | null;
+        yearOverYear: number | null;
+    }[];
+    departments: {
+        total: number;
+        key: string;
+        departmentId: string | null;
+        name: string | null;
+        currency: string;
+        amounts: number[];
+    }[];
+    alerts: {
+        accountName: string;
+        subscriptionName: string;
+        accountId: string;
+        month: string;
+        kind: import("./saas-rules").SaasAlertKind;
+        subscriptionId?: string;
+        amount: number;
+        limit: number;
+    }[];
+}>;
+/**
+ * What left the bank for an account's vendor (ADR-0177 decision 10, the user 2026-10-30: 「이테크 입금 이력이 있을텐데」)
+ * - the bank lines (accounting, confirmed) of money out to the account's counterparty, newest first. Only lines in the
+ * account's currency count toward its months.
+ */
+export declare function bankPaymentsOf(tx: EntityManager, domain: Domain, counterpartyIds: string[], from?: string, to?: string): Promise<Transaction[]>;
+/** The bank lines that paid an account's vendor, every one - for its 360. */
+export declare function saasPaymentsOf(tx: EntityManager, domain: Domain, scope: SaasScope, accountId: string): Promise<any[] | Transaction[]>;
+/**
+ * Each account's last twelve months before this one and the next three expected (`saasExpected`). A month is its bill
+ * when one is written; else, for a reader of the bank lines (`withBank`), what left the bank for its vendor that month
+ * (decision 10); else empty. One read for all the accounts of a list.
+ */
+export declare function saasTrendsOf(tx: EntityManager, domain: Domain, accounts: SaasAccount[], today: string, withBank?: boolean): Promise<Map<string, SaasTrend>>;
+/** What moved on an account and on each of its subscriptions, newest first. */
+export declare function saasChangesOf(tx: EntityManager, domain: Domain, scope: SaasScope, accountId: string): Promise<(import("@things-factory/fact-change").FactChange & {
+    subject: string;
+})[]>;

package/dist-server/service/saas-service.js

@@ -0,0 +1,492 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAAS_SUBSCRIPTION_FACT = exports.SAAS_ACCOUNT_FACT = void 0;
+exports.saveSaasAccounts = saveSaasAccounts;
+exports.saveSaasSubscriptions = saveSaasSubscriptions;
+exports.saasSubscriptionsOf = saasSubscriptionsOf;
+exports.saveSaasSeats = saveSaasSeats;
+exports.saasSeatsOf = saasSeatsOf;
+exports.saveSaasBill = saveSaasBill;
+exports.deleteSaasBill = deleteSaasBill;
+exports.billsOf = billsOf;
+exports.saasBillsOf = saasBillsOf;
+exports.saasExpected = saasExpected;
+exports.saasCostTrend = saasCostTrend;
+exports.bankPaymentsOf = bankPaymentsOf;
+exports.saasPaymentsOf = saasPaymentsOf;
+exports.saasTrendsOf = saasTrendsOf;
+exports.saasChangesOf = saasChangesOf;
+const accounting_1 = require("@things-factory/accounting");
+const asset_1 = require("@things-factory/asset");
+/* The register grids' save, the asset module's - this module saves its grids the same way (one implementation). */
+const patches_js_1 = require("@things-factory/asset/dist-server/service/patches.js");
+const biz_base_1 = require("@things-factory/biz-base");
+const fact_change_1 = require("@things-factory/fact-change");
+const organization_1 = require("@things-factory/organization");
+const shell_1 = require("@things-factory/shell");
+const typeorm_1 = require("typeorm");
+const saas_access_1 = require("./saas-access");
+const saas_account_1 = require("./saas-account");
+const saas_bill_1 = require("./saas-bill");
+const saas_rules_1 = require("./saas-rules");
+const saas_seat_1 = require("./saas-seat");
+const saas_subscription_1 = require("./saas-subscription");
+const currencyOf = (value, fallback) => {
+    const text = String(value ?? '').trim().toUpperCase();
+    if (!text)
+        return fallback;
+    if (!/^[A-Z]{3}$/.test(text))
+        throw new shell_1.Refusal('saas-currency-invalid', { value: text }, `'${text}' is not a currency code (KRW, USD)`);
+    return text;
+};
+const intOf = (value, code, min, max) => {
+    if (value === null || value === undefined || value === '')
+        return null;
+    const number = Number(value);
+    if (!Number.isInteger(number) || number < min || number > max)
+        throw new shell_1.Refusal(code, { min, max }, `Give a whole number from ${min} to ${max}`);
+    return number;
+};
+async function oneOf(tx, target, domain, id, code) {
+    if (!id)
+        return null;
+    const found = await tx.getRepository(target).findOne({ where: { domain: { id: domain.id }, id } });
+    if (!found)
+        throw new shell_1.Refusal(code, {}, 'What it points at was not found');
+    return found;
+}
+const field = (patch, name, old) => (patch[name] !== undefined ? patch[name] : old?.[name]);
+/*
+ * What moved on an account or a subscription, field by field (ADR-0177 decision 11) - the fact-change module keeps it.
+ * A row's relations are told by their id; a new row has no history yet.
+ */
+exports.SAAS_ACCOUNT_FACT = 'saas-account';
+exports.SAAS_SUBSCRIPTION_FACT = 'saas-subscription';
+const ACCOUNT_TRACKED = ['name', 'counterpartyId', 'identifier', 'parentId', 'paymentAccountId', 'currency', 'billingDay', 'increaseAlertRate', 'status', 'closedOn'];
+const SUBSCRIPTION_TRACKED = ['name', 'billing', 'quantity', 'unitPrice', 'amount', 'budget', 'everyMonths', 'startOn', 'renewalOn', 'autoRenew', 'noticeDays', 'departmentId', 'assetId', 'status', 'endedOn'];
+const idsOf = (row) => Object.fromEntries(Object.entries(row).map(([key, value]) => (value && typeof value === 'object' && 'id' in value ? [`${key}Id`, value.id] : value === null && ['counterparty', 'parent', 'paymentAccount', 'department', 'asset'].includes(key) ? [`${key}Id`, null] : [key, value])));
+async function recordChanges(tx, domain, user, factKind, old, row, fields) {
+    if (!old)
+        return;
+    const after = { ...old, ...idsOf(row) };
+    await (0, fact_change_1.recordFactChanges)(tx, domain, { factKind, factName: old.id, changes: (0, fact_change_1.fieldChanges)(old, after, fields) }, { user, source: 'saas' });
+}
+/* ----------------------------------------------------------------------------------------------------------------- */
+/* Accounts (decision 2) - kept by `saas` keepers only */
+function saveSaasAccounts(tx, domain, user, patches) {
+    return (0, patches_js_1.applyPatches)(tx, saas_account_1.SaasAccount, domain, user, patches, async (patch, old) => {
+        const row = {};
+        const name = (0, patches_js_1.touched)(patch, 'name', old) ? (0, patches_js_1.textOf)(patch.name) : old.name;
+        if (!name)
+            throw new shell_1.Refusal('saas-account-name-required', {}, 'Name the service');
+        row.name = name;
+        for (const one of ['identifier', 'purpose', 'billingEmail', 'secretLocation', 'description'])
+            if ((0, patches_js_1.touched)(patch, one, old))
+                row[one] = (0, patches_js_1.textOf)(patch[one]);
+        if ((0, patches_js_1.touched)(patch, 'currency', old))
+            row.currency = currencyOf(patch.currency, 'KRW');
+        if ((0, patches_js_1.touched)(patch, 'billingDay', old))
+            row.billingDay = intOf(patch.billingDay, 'saas-billing-day-invalid', 1, 31);
+        if ((0, patches_js_1.touched)(patch, 'increaseAlertRate', old)) {
+            const rate = (0, patches_js_1.amountOf)(patch.increaseAlertRate, 'saas-alert-rate-invalid');
+            if (rate !== null && rate > 10)
+                throw new shell_1.Refusal('saas-alert-rate-invalid', {}, 'Give the rate as a part - 0.2 for 20%');
+            row.increaseAlertRate = rate;
+        }
+        if ((0, patches_js_1.touched)(patch, 'counterpartyId', old))
+            row.counterparty = await oneOf(tx, biz_base_1.Counterparty, domain, patch.counterpartyId, 'saas-counterparty-not-found');
+        if ((0, patches_js_1.touched)(patch, 'paymentAccountId', old))
+            row.paymentAccount = await oneOf(tx, accounting_1.BankAccount, domain, patch.paymentAccountId, 'saas-payment-account-not-found');
+        if ((0, patches_js_1.touched)(patch, 'parentId', old)) {
+            const parent = await oneOf(tx, saas_account_1.SaasAccount, domain, patch.parentId, 'saas-parent-not-found');
+            if (parent && (parent.id === old?.id || (await tx.getRepository(saas_account_1.SaasAccount).findOne({ where: { id: parent.id }, relations: ['parent'] }))?.parent))
+                throw new shell_1.Refusal('saas-parent-invalid', {}, 'An account is under a top account only, and not under itself');
+            if (parent && old && (await tx.getRepository(saas_subscription_1.SaasSubscription).count({ where: { account: { id: old.id } } })))
+                throw new shell_1.Refusal('saas-parent-has-subscriptions', {}, 'An account with subscriptions is billed itself - it cannot go under another');
+            row.parent = parent;
+        }
+        if ((0, patches_js_1.touched)(patch, 'adminIds', old)) {
+            const ids = [...new Set((patch.adminIds ?? []).filter(Boolean))];
+            const admins = ids.length ? await tx.getRepository(organization_1.Employee).find({ where: { id: (0, typeorm_1.In)(ids), domain: { id: domain.id } } }) : [];
+            if (admins.length !== ids.length)
+                throw new shell_1.Refusal('saas-admin-not-found', {}, 'An admin is no employee of this domain');
+            row.admins = admins;
+        }
+        if ((0, patches_js_1.touched)(patch, 'status', old))
+            row.status = patch.status ?? saas_rules_1.SaasAccountStatus.ACTIVE;
+        if ((0, patches_js_1.touched)(patch, 'closedOn', old))
+            row.closedOn = (0, patches_js_1.dayOf)(patch.closedOn, 'saas-day-invalid');
+        if ((row.status ?? old?.status) === saas_rules_1.SaasAccountStatus.CLOSED && !(row.closedOn !== undefined ? row.closedOn : old?.closedOn))
+            throw new shell_1.Refusal('saas-closed-on-required', {}, 'Give the day it was closed');
+        await recordChanges(tx, domain, user, exports.SAAS_ACCOUNT_FACT, old, row, ACCOUNT_TRACKED);
+        return row;
+    }, 'saas-account-not-found');
+}
+/* ----------------------------------------------------------------------------------------------------------------- */
+/* Subscriptions (decision 3) - by keepers, and by the account's admins */
+async function saveSaasSubscriptions(tx, domain, user, scope, accountId, patches) {
+    const account = await (0, saas_access_1.accountIn)(tx, domain, scope, accountId);
+    if (account.parentId && patches.some(one => one.cuFlag !== '-'))
+        throw new shell_1.Refusal('saas-subscription-on-sub-account', {}, 'An account under another is billed by its parent - subscribe there');
+    return (0, patches_js_1.applyPatches)(tx, saas_subscription_1.SaasSubscription, domain, user, patches, async (patch, old) => {
+        const row = old ? {} : { account };
+        const name = (0, patches_js_1.touched)(patch, 'name', old) ? (0, patches_js_1.textOf)(patch.name) : old.name;
+        if (!name)
+            throw new shell_1.Refusal('saas-subscription-name-required', {}, 'Name the product or plan');
+        row.name = name;
+        const billing = (field(patch, 'billing', old) ?? saas_rules_1.SaasBilling.FIXED);
+        if (!Object.values(saas_rules_1.SaasBilling).includes(billing))
+            throw new shell_1.Refusal('saas-billing-invalid', {}, 'Say how it is paid for');
+        row.billing = billing;
+        for (const one of ['quantity', 'unitPrice', 'amount', 'budget'])
+            if ((0, patches_js_1.touched)(patch, one, old))
+                row[one] = (0, patches_js_1.amountOf)(patch[one], 'saas-amount-invalid');
+        const value = (name) => (row[name] !== undefined ? row[name] : old?.[name]);
+        if (billing === saas_rules_1.SaasBilling.SEAT && !(Number(value('quantity')) > 0 && value('unitPrice') !== null && value('unitPrice') !== undefined))
+            throw new shell_1.Refusal('saas-seat-price-required', {}, 'A seat plan takes its seats and the price of one');
+        if ((billing === saas_rules_1.SaasBilling.FIXED || billing === saas_rules_1.SaasBilling.COMMITMENT) && (value('amount') === null || value('amount') === undefined))
+            throw new shell_1.Refusal('saas-amount-required', {}, 'Give what one billing costs');
+        if ((0, patches_js_1.touched)(patch, 'everyMonths', old))
+            row.everyMonths = intOf(patch.everyMonths, 'saas-every-months-invalid', 1, 120) ?? 1;
+        row.startOn = (0, patches_js_1.touched)(patch, 'startOn', old) ? (0, patches_js_1.dayOf)(patch.startOn, 'saas-start-on-invalid', true) : old.startOn;
+        if ((0, patches_js_1.touched)(patch, 'renewalOn', old))
+            row.renewalOn = (0, patches_js_1.dayOf)(patch.renewalOn, 'saas-day-invalid');
+        if ((0, patches_js_1.touched)(patch, 'endedOn', old))
+            row.endedOn = (0, patches_js_1.dayOf)(patch.endedOn, 'saas-day-invalid');
+        if ((0, patches_js_1.touched)(patch, 'autoRenew', old))
+            row.autoRenew = patch.autoRenew !== false;
+        if ((0, patches_js_1.touched)(patch, 'noticeDays', old))
+            row.noticeDays = intOf(patch.noticeDays, 'saas-notice-days-invalid', 0, 365);
+        if ((0, patches_js_1.touched)(patch, 'description', old))
+            row.description = (0, patches_js_1.textOf)(patch.description);
+        if ((0, patches_js_1.touched)(patch, 'departmentId', old))
+            row.department = await oneOf(tx, organization_1.Department, domain, patch.departmentId, 'saas-department-not-found');
+        if ((0, patches_js_1.touched)(patch, 'assetId', old))
+            row.asset = await oneOf(tx, asset_1.Asset, domain, patch.assetId, 'saas-asset-not-found');
+        if (billing === saas_rules_1.SaasBilling.OWNED && !(row.asset !== undefined ? row.asset : old?.assetId))
+            throw new shell_1.Refusal('saas-owned-asset-required', {}, 'A license owned points at its asset in the register - its cost is there');
+        if (billing === saas_rules_1.SaasBilling.COMMITMENT && !value('renewalOn'))
+            throw new shell_1.Refusal('saas-term-end-required', {}, 'A commitment takes the day its term ends');
+        if ((0, patches_js_1.touched)(patch, 'status', old))
+            row.status = patch.status ?? saas_rules_1.SaasSubscriptionStatus.ACTIVE;
+        const status = row.status ?? old?.status ?? saas_rules_1.SaasSubscriptionStatus.ACTIVE;
+        if (status === saas_rules_1.SaasSubscriptionStatus.CANCELLED && !value('endedOn'))
+            throw new shell_1.Refusal('saas-ended-on-required', {}, 'Give the day it ended');
+        if (status === saas_rules_1.SaasSubscriptionStatus.CANCELLING && !value('renewalOn'))
+            throw new shell_1.Refusal('saas-renewal-on-required', {}, 'Not renewing needs the day it would renew');
+        if (value('endedOn') && value('endedOn') < row.startOn)
+            throw new shell_1.Refusal('saas-ended-before-start', {}, 'It ended before it started');
+        await recordChanges(tx, domain, user, exports.SAAS_SUBSCRIPTION_FACT, old, row, SUBSCRIPTION_TRACKED);
+        return row;
+    }, 'saas-subscription-not-found', { account: { id: account.id } });
+}
+/** The subscriptions of an account, with the seats held today. */
+async function saasSubscriptionsOf(tx, domain, scope, accountId, today) {
+    const account = await (0, saas_access_1.accountIn)(tx, domain, scope, accountId);
+    const subs = await tx.getRepository(saas_subscription_1.SaasSubscription).find({ where: { domain: { id: domain.id }, account: { id: account.id } }, relations: ['department', 'asset'], order: { name: 'ASC' } });
+    const seats = subs.length ? await tx.getRepository(saas_seat_1.SaasSeat).find({ where: { domain: { id: domain.id }, subscription: { id: (0, typeorm_1.In)(subs.map(one => one.id)) } } }) : [];
+    for (const sub of subs)
+        sub.seatsHeld = seats.filter(seat => seat.subscriptionId === sub.id && (0, saas_rules_1.seatHeld)(seat, today)).length;
+    return subs;
+}
+/* ----------------------------------------------------------------------------------------------------------------- */
+/* Seats (decision 6) */
+async function subscriptionIn(tx, domain, scope, subscriptionId) {
+    const sub = subscriptionId ? await tx.getRepository(saas_subscription_1.SaasSubscription).findOne({ where: { domain: { id: domain.id }, id: subscriptionId } }) : null;
+    if (!sub || (scope !== 'all' && !scope.has(sub.accountId)))
+        throw new shell_1.Refusal('saas-subscription-not-found', {}, 'The subscription was not found - reload and try again');
+    return sub;
+}
+async function saveSaasSeats(tx, domain, user, scope, subscriptionId, patches) {
+    const subscription = await subscriptionIn(tx, domain, scope, subscriptionId);
+    return (0, patches_js_1.applyPatches)(tx, saas_seat_1.SaasSeat, domain, user, patches, async (patch, old) => {
+        const row = old ? {} : { subscription };
+        if ((0, patches_js_1.touched)(patch, 'employeeId', old))
+            row.employee = await oneOf(tx, organization_1.Employee, domain, patch.employeeId, 'saas-seat-employee-not-found');
+        for (const one of ['holder', 'description'])
+            if ((0, patches_js_1.touched)(patch, one, old))
+                row[one] = (0, patches_js_1.textOf)(patch[one]);
+        if (!(row.employee !== undefined ? row.employee : old?.employeeId) && !(row.holder !== undefined ? row.holder : old?.holder))
+            throw new shell_1.Refusal('saas-seat-holder-required', {}, 'Say who holds the seat - an employee, or a name');
+        if ((0, patches_js_1.touched)(patch, 'fromOn', old))
+            row.fromOn = (0, patches_js_1.dayOf)(patch.fromOn, 'saas-day-invalid');
+        if ((0, patches_js_1.touched)(patch, 'untilOn', old))
+            row.untilOn = (0, patches_js_1.dayOf)(patch.untilOn, 'saas-day-invalid');
+        const from = row.fromOn !== undefined ? row.fromOn : old?.fromOn;
+        const until = row.untilOn !== undefined ? row.untilOn : old?.untilOn;
+        if (from && until && until < from)
+            throw new shell_1.Refusal('saas-seat-until-before-from', {}, 'It was taken back before it was given');
+        return row;
+    }, 'saas-seat-not-found', { subscription: { id: subscription.id } });
+}
+async function saasSeatsOf(tx, domain, scope, subscriptionId) {
+    const sub = await subscriptionIn(tx, domain, scope, subscriptionId);
+    return tx.getRepository(saas_seat_1.SaasSeat).find({ where: { domain: { id: domain.id }, subscription: { id: sub.id } }, relations: ['employee'], order: { fromOn: 'DESC' } });
+}
+async function saveSaasBill(tx, domain, user, scope, accountId, input) {
+    const account = await (0, saas_access_1.accountIn)(tx, domain, scope, accountId);
+    if (account.parentId)
+        throw new shell_1.Refusal('saas-bill-on-sub-account', {}, 'An account under another is billed by its parent');
+    const month = String(input.month ?? '').trim();
+    if (!saas_rules_1.MONTH.test(month))
+        throw new shell_1.Refusal('saas-month-invalid', { value: month }, 'Write the month as YYYY-MM');
+    const bills = tx.getRepository(saas_bill_1.SaasBill);
+    const old = input.id ? await bills.findOne({ where: { domain: { id: domain.id }, id: input.id, account: { id: account.id } } }) : null;
+    if (input.id && !old)
+        throw new shell_1.Refusal('saas-bill-not-found', {}, 'The bill was not found - reload and try again');
+    const twin = await bills.findOne({ where: { domain: { id: domain.id }, account: { id: account.id }, month } });
+    if (twin && twin.id !== old?.id)
+        throw new shell_1.Refusal('saas-bill-month-taken', { month }, `The account already has a bill for ${month} - change that one`);
+    const lines = (input.lines ?? []).filter(line => line && (line.subscriptionId || (0, patches_js_1.textOf)(line.label) || Number(line.amount)));
+    if (!lines.length)
+        throw new shell_1.Refusal('saas-bill-lines-required', {}, 'A bill takes at least one line');
+    const subIds = [...new Set(lines.map(line => line.subscriptionId).filter(Boolean))];
+    if (subIds.length) {
+        const found = await tx.getRepository(saas_subscription_1.SaasSubscription).count({ where: { domain: { id: domain.id }, account: { id: account.id }, id: (0, typeorm_1.In)(subIds) } });
+        if (found !== subIds.length)
+            throw new shell_1.Refusal('saas-bill-subscription-not-found', {}, 'A line names a subscription not of this account');
+    }
+    for (const line of lines)
+        if (!Number.isFinite(Number(line.amount)))
+            throw new shell_1.Refusal('saas-amount-invalid', {}, 'Give the amount as a number');
+    const bill = await bills.save({
+        ...(old ?? { domain, account, creator: user, currency: account.currency }),
+        month,
+        billedOn: (0, patches_js_1.dayOf)(input.billedOn, 'saas-day-invalid'),
+        description: (0, patches_js_1.textOf)(input.description),
+        updater: user
+    });
+    await tx.getRepository(saas_bill_1.SaasBillLine).delete({ bill: { id: bill.id } });
+    await tx.getRepository(saas_bill_1.SaasBillLine).save(lines.map(line => ({ domain, bill: { id: bill.id }, subscription: line.subscriptionId ? { id: line.subscriptionId } : null, label: (0, patches_js_1.textOf)(line.label), amount: Number(line.amount) })));
+    return billsOf(tx, domain, [account.id]).then(all => all.find(one => one.id === bill.id));
+}
+async function deleteSaasBill(tx, domain, scope, id) {
+    const bill = await tx.getRepository(saas_bill_1.SaasBill).findOne({ where: { domain: { id: domain.id }, id } });
+    if (!bill || (scope !== 'all' && !scope.has(bill.accountId)))
+        throw new shell_1.Refusal('saas-bill-not-found', {}, 'The bill was not found - reload and try again');
+    await tx.getRepository(saas_bill_1.SaasBill).softDelete({ id });
+    return true;
+}
+/** The bills of some accounts (all when none named) from a month on, with their lines and totals, latest first. */
+async function billsOf(tx, domain, accountIds, from, to) {
+    const query = tx
+        .getRepository(saas_bill_1.SaasBill)
+        .createQueryBuilder('bill')
+        .leftJoinAndSelect('bill.lines', 'line')
+        .leftJoinAndSelect('line.subscription', 'subscription')
+        .where('bill.domain = :domain', { domain: domain.id });
+    if (accountIds) {
+        if (!accountIds.length)
+            return [];
+        query.andWhere('bill.account IN (:...accounts)', { accounts: accountIds });
+    }
+    if (from)
+        query.andWhere('bill.month >= :from', { from });
+    if (to)
+        query.andWhere('bill.month <= :to', { to });
+    const bills = await query.orderBy('bill.month', 'DESC').getMany();
+    for (const bill of bills)
+        bill.total = (0, saas_rules_1.billTotal)(bill.lines ?? []);
+    return bills;
+}
+async function saasBillsOf(tx, domain, scope, accountId) {
+    const account = await (0, saas_access_1.accountIn)(tx, domain, scope, accountId);
+    return billsOf(tx, domain, [account.id]);
+}
+const factsOf = (bill) => ({
+    accountId: bill.accountId,
+    month: bill.month,
+    currency: bill.currency,
+    lines: (bill.lines ?? []).map(line => ({ subscriptionId: line.subscriptionId ?? null, amount: Number(line.amount) }))
+});
+/**
+ * What each account is expected to be billed, month by month from `from` to `to`: the bill when one is written for the
+ * month, else what its subscriptions say (usage at the average of its latest bills).
+ */
+async function saasExpected(tx, domain, from, to) {
+    const accounts = await tx.getRepository(saas_account_1.SaasAccount).find({ where: { domain: { id: domain.id }, status: saas_rules_1.SaasAccountStatus.ACTIVE } });
+    const top = accounts.filter(one => !one.parentId);
+    if (!top.length)
+        return [];
+    const subs = await tx.getRepository(saas_subscription_1.SaasSubscription).find({ where: { domain: { id: domain.id }, account: { id: (0, typeorm_1.In)(top.map(one => one.id)) } } });
+    const bills = await billsOf(tx, domain, top.map(one => one.id), (0, saas_rules_1.shiftMonth)(from, -12), to);
+    const billed = new Map();
+    for (const bill of bills)
+        if (bill.month < from)
+            for (const line of bill.lines ?? [])
+                if (line.subscriptionId)
+                    billed.set(line.subscriptionId, [...(billed.get(line.subscriptionId) ?? []), { month: bill.month, amount: Number(line.amount) }]);
+    const rows = [];
+    for (const account of top) {
+        const own = subs.filter(one => one.accountId === account.id);
+        for (const month of (0, saas_rules_1.monthsFrom)(from, to)) {
+            const [year, m] = month.split('-').map(Number);
+            const bill = bills.find(one => one.accountId === account.id && one.month === month);
+            const expected = (0, saas_rules_1.expectedOfMonth)(account, own, billed, year, m);
+            if (!bill && !expected)
+                continue;
+            rows.push({
+                accountId: account.id,
+                accountName: account.name,
+                counterpartyId: account.counterpartyId ?? null,
+                paymentAccountId: account.paymentAccountId ?? null,
+                month,
+                day: bill?.billedOn ?? expected?.day ?? null,
+                amount: bill ? bill.total : expected.amount,
+                currency: account.currency,
+                billed: !!bill
+            });
+        }
+    }
+    return rows;
+}
+/* ----------------------------------------------------------------------------------------------------------------- */
+/* The cost trend (decision 9) */
+/** Whose department each employee is in. */
+async function departmentsOfEmployees(tx, domain, ids) {
+    if (!ids.length)
+        return new Map();
+    const employees = await tx.getRepository(organization_1.Employee).find({ where: { domain: { id: domain.id }, id: (0, typeorm_1.In)(ids) }, relations: ['department'] });
+    return new Map(employees.filter(one => one.department).map(one => [one.id, { id: one.department.id, name: one.department.name }]));
+}
+/**
+ * The bills of the months from `from` to `to` as series - all, an account, a subscription - and a department series: a
+ * line of a seat plan split by the seats held at the month's end by department, any other line its subscription's
+ * department. Plus what the latest month's bills are worth telling.
+ */
+async function saasCostTrend(tx, domain, from, to) {
+    if (!saas_rules_1.MONTH.test(from) || !saas_rules_1.MONTH.test(to) || from > to)
+        throw new shell_1.Refusal('saas-month-invalid', {}, 'Give the months as YYYY-MM, the first before the last');
+    if ((0, saas_rules_1.monthsFrom)(from, to).length > 60)
+        throw new shell_1.Refusal('saas-trend-too-long', { max: 60 }, 'Up to 60 months at once');
+    const bills = await billsOf(tx, domain, undefined, (0, saas_rules_1.shiftMonth)(from, -1), to);
+    const facts = bills.map(factsOf);
+    const trend = (0, saas_rules_1.trendOf)(facts, from, to);
+    const accounts = await tx.getRepository(saas_account_1.SaasAccount).find({ where: { domain: { id: domain.id } }, withDeleted: true });
+    const subs = await tx.getRepository(saas_subscription_1.SaasSubscription).find({ where: { domain: { id: domain.id } }, relations: ['department'], withDeleted: true });
+    const seats = subs.length ? await tx.getRepository(saas_seat_1.SaasSeat).find({ where: { domain: { id: domain.id }, subscription: { id: (0, typeorm_1.In)(subs.map(one => one.id)) } } }) : [];
+    const departmentOf = await departmentsOfEmployees(tx, domain, [...new Set(seats.map(one => one.employeeId).filter(Boolean))]);
+    const months = trend.months;
+    const departments = new Map();
+    const addTo = (id, name, currency, at, amount) => {
+        const key = `${id ?? ''}|${currency}`;
+        let one = departments.get(key);
+        if (!one)
+            departments.set(key, (one = { key, departmentId: id, name, currency, amounts: months.map(() => 0) }));
+        one.amounts[at] += amount;
+    };
+    for (const bill of facts) {
+        const at = months.indexOf(bill.month);
+        if (at < 0)
+            continue;
+        const monthEnd = `${bill.month}-31`;
+        for (const line of bill.lines) {
+            const sub = subs.find(one => one.id === line.subscriptionId);
+            const held = sub?.billing === saas_rules_1.SaasBilling.SEAT ? seats.filter(seat => seat.subscriptionId === sub.id && (0, saas_rules_1.seatHeld)(seat, monthEnd) && (!seat.fromOn || seat.fromOn <= monthEnd)) : [];
+            if (held.length) {
+                for (const seat of held) {
+                    const department = seat.employeeId ? departmentOf.get(seat.employeeId) : undefined;
+                    addTo(department?.id ?? sub?.department?.id ?? null, department?.name ?? sub?.department?.name ?? null, bill.currency, at, line.amount / held.length);
+                }
+            }
+            else
+                addTo(sub?.department?.id ?? null, sub?.department?.name ?? null, bill.currency, at, line.amount);
+        }
+    }
+    const latest = facts.filter(one => one.month <= to).map(one => one.month).sort().pop();
+    const alerts = latest
+        ? facts
+            .filter(one => one.month === latest)
+            .flatMap(bill => {
+            const account = accounts.find(one => one.id === bill.accountId);
+            if (!account)
+                return [];
+            const previous = facts.find(one => one.accountId === bill.accountId && one.month === (0, saas_rules_1.shiftMonth)(bill.month, -1));
+            return (0, saas_rules_1.alertsOf)(account, subs.filter(one => one.accountId === account.id), bill, previous).map(alert => ({ ...alert, accountId: account.id, month: bill.month }));
+        })
+        : [];
+    const name = (id) => accounts.find(one => one.id === id)?.name ?? null;
+    const subName = (id) => subs.find(one => one.id === id)?.name ?? null;
+    return {
+        months,
+        all: trend.all,
+        accounts: trend.accounts.map(one => ({ ...one, name: name(one.accountId) })),
+        subscriptions: trend.subscriptions.map(one => ({ ...one, name: subName(one.subscriptionId), accountName: name(one.accountId) })),
+        departments: [...departments.values()].map(one => ({ ...one, total: one.amounts.reduce((sum, amount) => sum + amount, 0) })).sort((a, b) => b.total - a.total),
+        alerts: alerts.map(alert => ({ ...alert, accountName: name(alert.accountId), subscriptionName: subName(alert.subscriptionId) }))
+    };
+}
+/* ----------------------------------------------------------------------------------------------------------------- */
+/* A row's months for the list and the 360 (decision 10) and what moved on it (decision 11) */
+/**
+ * What left the bank for an account's vendor (ADR-0177 decision 10, the user 2026-10-30: 「이테크 입금 이력이 있을텐데」)
+ * - the bank lines (accounting, confirmed) of money out to the account's counterparty, newest first. Only lines in the
+ * account's currency count toward its months.
+ */
+async function bankPaymentsOf(tx, domain, counterpartyIds, from, to) {
+    if (!counterpartyIds.length)
+        return [];
+    const query = tx
+        .getRepository(accounting_1.Transaction)
+        .createQueryBuilder('line')
+        .where('line.domain = :domain', { domain: domain.id })
+        .andWhere('line.category = :category', { category: accounting_1.TransactionCategory.CONFIRMED })
+        .andWhere('line.type = :type', { type: accounting_1.CashFlowType.EXPENSE })
+        .andWhere('line.counterparty IN (:...parties)', { parties: counterpartyIds });
+    if (from)
+        query.andWhere('line.transactionDate >= :from', { from });
+    if (to)
+        query.andWhere('line.transactionDate <= :to', { to });
+    return query.orderBy('line.transactionDate', 'DESC').addOrderBy('line.amount', 'DESC').getMany();
+}
+/** The bank lines that paid an account's vendor, every one - for its 360. */
+async function saasPaymentsOf(tx, domain, scope, accountId) {
+    const account = await (0, saas_access_1.accountIn)(tx, domain, scope, accountId);
+    return account.counterpartyId ? bankPaymentsOf(tx, domain, [account.counterpartyId]) : [];
+}
+/**
+ * Each account's last twelve months before this one and the next three expected (`saasExpected`). A month is its bill
+ * when one is written; else, for a reader of the bank lines (`withBank`), what left the bank for its vendor that month
+ * (decision 10); else empty. One read for all the accounts of a list.
+ */
+async function saasTrendsOf(tx, domain, accounts, today, withBank = false) {
+    const trends = new Map();
+    if (!accounts.length)
+        return trends;
+    const now = today.slice(0, 7);
+    const months = (0, saas_rules_1.monthsFrom)((0, saas_rules_1.shiftMonth)(now, -12), (0, saas_rules_1.shiftMonth)(now, -1));
+    const nextMonths = (0, saas_rules_1.monthsFrom)(now, (0, saas_rules_1.shiftMonth)(now, 2));
+    const bills = await billsOf(tx, domain, accounts.map(one => one.id), months[0], months[months.length - 1]);
+    const expected = await saasExpected(tx, domain, nextMonths[0], nextMonths[nextMonths.length - 1]);
+    const parties = [...new Set(accounts.map(one => one.counterpartyId).filter(Boolean))];
+    const paid = withBank ? await bankPaymentsOf(tx, domain, parties, `${months[0]}-01`, `${months[months.length - 1]}-31`) : [];
+    for (const account of accounts) {
+        const own = bills.filter(one => one.accountId === account.id);
+        const lines = paid.filter(line => line.counterpartyId === account.counterpartyId && (line.currency || 'KRW') === account.currency);
+        const banked = (month) => {
+            const of = lines.filter(line => line.transactionDate?.slice(0, 7) === month);
+            return of.length ? of.reduce((sum, line) => sum + Number(line.amount), 0) : null;
+        };
+        const values = months.map(month => own.find(one => one.month === month)?.total ?? banked(month));
+        trends.set(account.id, {
+            months,
+            values,
+            sources: months.map((month, i) => (own.some(one => one.month === month) ? 'bill' : values[i] === null ? null : 'bank')),
+            nextMonths,
+            expected: nextMonths.map(month => expected.find(one => one.accountId === account.id && one.month === month)?.amount ?? null),
+            currency: account.currency
+        });
+    }
+    return trends;
+}
+/** What moved on an account and on each of its subscriptions, newest first. */
+async function saasChangesOf(tx, domain, scope, accountId) {
+    const account = await (0, saas_access_1.accountIn)(tx, domain, scope, accountId);
+    const subs = await tx.getRepository(saas_subscription_1.SaasSubscription).find({ where: { domain: { id: domain.id }, account: { id: account.id } }, withDeleted: true });
+    const rows = [
+        ...(await (0, fact_change_1.readFactChanges)(tx, domain, exports.SAAS_ACCOUNT_FACT, account.id)).map(one => Object.assign(one, { subject: account.name })),
+        ...(await Promise.all(subs.map(async (sub) => (await (0, fact_change_1.readFactChanges)(tx, domain, exports.SAAS_SUBSCRIPTION_FACT, sub.id)).map(one => Object.assign(one, { subject: sub.name }))))).flat()
+    ];
+    return rows.sort((a, b) => new Date(b.at).getTime() - new Date(a.at).getTime());
+}
+//# sourceMappingURL=saas-service.js.map