@pax2pay/model-banking 0.1.384 → 0.1.386

package/Card/Creatable.ts

@@ -1,7 +1,8 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Amount } from "../Amount"
-import { Rule, type as ruleType } from "../Rule/Rule"
+import type { Rule } from "../Rule"
+import { type as ruleType } from "../Rule/type"
 import { Expiry } from "./Expiry"
 import { Meta } from "./Meta"
 import { Preset } from "./Preset"

package/Card/index.ts

@@ -3,7 +3,8 @@ import { isly } from "isly"
 import { Amount } from "../Amount"
 import { Realm } from "../Realm"
 import { Report } from "../Report"
-import { Rule, type as ruleType } from "../Rule/Rule"
+import type { Rule } from "../Rule"
+import { type as ruleType } from "../Rule/type"
 import { Changeable as CardChangeable } from "./Changeable"
 import { Creatable as CardCreatable } from "./Creatable"
 import { Expiry as CardExpiry } from "./Expiry"

package/Operation/Changes.ts

@@ -2,6 +2,7 @@ import { isoly } from "isoly"
 import { isly } from "isly"
 import { Balance as AccountBalance } from "../Balance"
 import { Counterbalance as CounterbalanceOperation } from "../Counterbalance"
+import type { Settlement } from "../Settlement"
 import { Change } from "./Change"
 
 export type Changes = Partial<Record<Changes.Entry.Balance, Change>> & Record<Changes.Entry.Counterbalance, Change>
@@ -113,4 +114,28 @@ export namespace Changes {
 			}),
 		}
 	}
+	export function fromRefund(
+		settlement: string | undefined, // FIXME: remove | undefined when we're sure we send the id
+		refund: Settlement.Entry.Refund.Creatable,
+		charge: number | undefined,
+		sum: Sum
+	): Changes {
+		const currency = refund.amount[0]
+		const fee = refund.fee.other[currency] ?? 0
+		const net = refund.amount[1]
+		const available = isoly.Currency.subtract(currency, isoly.Currency.add(currency, fee, net), charge ?? 0)
+		return {
+			available: { type: available > 0 ? "add" : "subtract", amount: Math.abs(available), status: "pending" },
+			["reserved-incoming"]: {
+				type: "subtract",
+				amount: sum["reserved-incoming"] ?? 0,
+				status: "pending",
+			},
+			[`${settlement}-net`]: { type: "subtract" as const, amount: net, status: "pending" as const },
+			[`${settlement}-fee`]: { type: "subtract" as const, amount: fee, status: "pending" as const },
+			...(charge && {
+				[`${settlement}-charge`]: { type: "add" as const, amount: charge, status: "pending" as const },
+			}),
+		}
+	}
 }

package/Operation/Creatable.ts

@@ -38,12 +38,7 @@ export namespace Creatable {
 	})
 	export const is = type.is
 	export const flaw = type.flaw
-	export function fromRefund(
-		account: string,
-		settlement: string,
-		entry: Settlement.Entry.Refund.Creatable,
-		charge: number
-	): Creatable {
+	export function fromRefund(account: string, settlement: string, entry: Settlement.Entry.Refund.Creatable): Creatable {
 		// The Entry.Refund.Creatable has negative amount and fee
 		// The operation amounts should always be positive
 		const [currency, entryAmount] = entry.amount
@@ -69,18 +64,6 @@ export namespace Creatable {
 					amount: operationFee,
 					status: "pending" as const,
 				},
-				...(charge > 0 && {
-					[`${settlement}-charge`]: {
-						type: "add" as const,
-						amount: charge,
-						status: "pending" as const,
-					},
-					available: {
-						type: "subtract" as const,
-						amount: charge,
-						status: "pending" as const,
-					},
-				}),
 			},
 		}
 	}

package/Organization/index.ts

@@ -1,6 +1,7 @@
 import { isly } from "isly"
 import { Realm } from "../Realm"
-import { Rule, type as ruleType } from "../Rule/Rule"
+import { Rule } from "../Rule"
+import { type as ruleType } from "../Rule/type"
 import { Changeable as OrganizationChangeable } from "./Changeable"
 import { Contact as OrganizationContact } from "./Contact"
 

package/Rule/{Rule/Base.ts → Base.ts}

@@ -15,6 +15,13 @@ export namespace Base {
 	export namespace Kind {
 		export const values = ["authorization", "outbound", "inbound", "capture", "refund"] as const
 		export const type = isly.string<Kind>(values)
+		export function is(kind: Kind, rule: Base, groups: string[] | undefined): boolean {
+			return (
+				kind == rule.type &&
+				(!rule.groups ||
+					rule.groups.some(ruleGroup => groups?.some(organizationGroup => organizationGroup == ruleGroup)))
+			)
+		}
 	}
 	export type Category = typeof Category.values[number]
 	export namespace Category {

package/Rule/Charge.ts

@@ -0,0 +1,108 @@
+import { isoly } from "isoly"
+import { selectively } from "selectively"
+import { isly } from "isly"
+import { Amount } from "../Amount"
+import { Exchange } from "../Exchange"
+import { Realm } from "../Realm"
+import { Base } from "./Base"
+import { control } from "./control"
+import type { State } from "./State"
+
+export interface Charge extends Charge.Api {
+	charge: {
+		percentage?: number
+		fixed?: Amount
+	}
+}
+export namespace Charge {
+	export type Action = typeof Action.value
+	export namespace Action {
+		export const value = "charge"
+	}
+	export interface Api extends Base {
+		action: Charge.Action
+		charge: {
+			percentage?: number
+			fixed?: number | Amount
+		}
+	}
+	export namespace Api {
+		export const type = Base.type.extend<Api>({
+			action: isly.string(Action.value),
+			charge: isly.object({
+				percentage: isly.number().optional(),
+				fixed: isly.union<number | Amount>(Amount.type, isly.number()).optional(),
+			}),
+		})
+	}
+	export function fromApi(rule: Api, realm: Realm): Charge
+	export function fromApi(rule: Api, currency: isoly.Currency): Charge
+	export function fromApi(rule: Api, currency: Realm | isoly.Currency): Charge {
+		return {
+			...rule,
+			charge: {
+				...rule.charge,
+				fixed:
+					typeof rule.charge.fixed == "number"
+						? [Realm.is(currency) ? Realm.currency[currency] : currency, rule.charge.fixed]
+						: rule.charge.fixed,
+			},
+		}
+	}
+	export function evaluate(
+		rules: Charge[],
+		state: State,
+		macros?: Record<string, selectively.Definition>,
+		table: Exchange.Rates = {}
+	): { outcomes: Charge[]; charge: Required<State["transaction"]["original"]>["charge"] } {
+		const result: ReturnType<typeof evaluate> = {
+			outcomes: [],
+			charge: { current: 0, total: state.transaction.original.charge?.total ?? 0 },
+		}
+		if (state.transaction.stage == "finalize" && ["card", "external"].some(type => type == state.transaction.type))
+			for (const rule of rules) {
+				if (control(rule, state, macros)) {
+					if (rule.charge.percentage)
+						result.charge.current = isoly.Currency.add(
+							state.transaction.original.currency,
+							result.charge.current,
+							isoly.Currency.multiply(
+								state.transaction.original.currency,
+								state.transaction.original.amount,
+								rule.charge.percentage / 100
+							)
+						)
+					if (rule.charge.fixed) {
+						const charge =
+							state.transaction.original.currency === rule.charge.fixed[0]
+								? rule.charge.fixed[1]
+								: Exchange.convert(
+										rule.charge.fixed[1],
+										rule.charge.fixed[0],
+										state.transaction.original.currency,
+										table
+								  ) ?? 0
+						result.charge.current = isoly.Currency.add(
+							state.transaction.original.currency,
+							result.charge.current,
+							charge
+						)
+					}
+					result.outcomes.push(rule)
+				}
+			}
+		result.charge.total = isoly.Currency.add(
+			state.transaction.original.currency,
+			result.charge.current,
+			result.charge.total
+		)
+		return result
+	}
+	export function apply(charge: { current: number; total: number }, state: State): number {
+		return state.transaction.kind == "authorization" ||
+			state.transaction.kind == "outbound" ||
+			state.transaction.kind == "capture"
+			? isoly.Currency.add(state.transaction.original.currency, state.transaction.original.total, charge.current)
+			: isoly.Currency.subtract(state.transaction.original.currency, state.transaction.original.total, charge.current)
+	}
+}

package/Rule/Other.ts

@@ -0,0 +1,48 @@
+import { isoly } from "isoly"
+import { selectively } from "selectively"
+import { isly } from "isly"
+import type { Note } from "../Transaction/Note"
+import { Base } from "./Base"
+import { control } from "./control"
+import type { State } from "./State"
+
+export interface Other extends Base {
+	action: Other.Action
+}
+export namespace Other {
+	export type Action = typeof Action.values[number]
+	export namespace Action {
+		export const values = ["review", "reject", "flag"] as const
+		export const type = isly.string<Action>(values)
+	}
+	export const type = Base.type.extend<Other>({ action: Action.type })
+	export function evaluate(
+		rules: Other[],
+		state: State,
+		macros?: Record<string, selectively.Definition>
+	): { outcomes: Record<Other.Action, Other[]>; notes: Note[]; flags: Set<string> } {
+		const now = isoly.DateTime.now()
+		const result: ReturnType<typeof evaluate> = {
+			outcomes: {
+				review: [],
+				reject: [],
+				flag: [],
+			},
+			notes: [],
+			flags: new Set<string>(),
+		}
+		if (
+			state.transaction.stage == "initiate" &&
+			["card", "external", "internal"].some(type => type == state.transaction.type)
+		)
+			for (const rule of rules) {
+				if (control(rule, state, macros)) {
+					result.outcomes[rule.action].push(rule)
+					result.notes.push({ author: "automatic", created: now, text: rule.name, rule })
+					rule.flags.forEach(f => result.flags.add(f))
+					rule.action == "review" && result.flags.add("review")
+				}
+			}
+		return result
+	}
+}

package/Rule/Reserve.ts

@@ -0,0 +1,111 @@
+import { isoly } from "isoly"
+import { selectively } from "selectively"
+import { isly } from "isly"
+import { Amount } from "../Amount"
+import { Exchange } from "../Exchange"
+import { Realm } from "../Realm"
+import { Base } from "./Base"
+import { control } from "./control"
+import type { State } from "./State"
+
+export interface Reserve extends Reserve.Api {
+	reserve: {
+		percentage?: number
+		fixed?: Amount
+	}
+}
+export namespace Reserve {
+	export type Action = typeof Action.value
+	export namespace Action {
+		export const value = "reserve"
+	}
+	export const type = Base.type.extend<Reserve>({
+		action: isly.string(Action.value),
+		reserve: isly.object({
+			percentage: isly.number(),
+			fixed: Amount.type.optional(),
+		}),
+	})
+
+	export interface Api extends Base {
+		action: Reserve.Action
+		reserve: {
+			percentage?: number
+			fixed?: number | Amount
+		}
+	}
+	export namespace Api {
+		export const type = Base.type.extend<Api>({
+			action: isly.string(Action.value),
+			reserve: isly.object({
+				percentage: isly.number().optional(),
+				fixed: isly.union<number | Amount>(Amount.type, isly.number()).optional(),
+			}),
+		})
+	}
+	export function fromApi(rule: Api, realm: Realm): Reserve
+	export function fromApi(rule: Api, currency: isoly.Currency): Reserve
+	export function fromApi(rule: Api, currency: Realm | isoly.Currency): Reserve {
+		return {
+			...rule,
+			reserve: {
+				...rule.reserve,
+				fixed:
+					typeof rule.reserve.fixed == "number"
+						? [Realm.is(currency) ? Realm.currency[currency] : currency, rule.reserve.fixed]
+						: rule.reserve.fixed,
+			},
+		}
+	}
+	export function evaluate(
+		rules: Reserve[],
+		state: State,
+		macros?: Record<string, selectively.Definition>,
+		table: Exchange.Rates = {}
+	): { outcomes: Reserve[]; reserve: number } {
+		const result: ReturnType<typeof evaluate> = {
+			outcomes: [],
+			reserve: 0,
+		}
+		if (
+			state.transaction.stage == "initiate" &&
+			["authorization", "outbound"].some(kind => kind == state.transaction.kind) &&
+			["card", "external"].some(type => type == state.transaction.type)
+		)
+			for (const rule of rules) {
+				if (control(rule, state, macros)) {
+					if (rule.reserve.percentage)
+						result.reserve = isoly.Currency.add(
+							state.transaction.original.currency,
+							result.reserve,
+							isoly.Currency.multiply(
+								state.transaction.original.currency,
+								state.transaction.original.amount,
+								rule.reserve.percentage / 100
+							)
+						)
+					if (rule.reserve.fixed) {
+						const reserve =
+							state.transaction.original.currency === rule.reserve.fixed[0]
+								? rule.reserve.fixed[1]
+								: Exchange.convert(
+										rule.reserve.fixed[1],
+										rule.reserve.fixed[0],
+										state.transaction.original.currency,
+										table
+								  ) ?? 0
+						result.reserve = isoly.Currency.add(state.transaction.original.currency, result.reserve, reserve)
+					}
+					result.outcomes.push(rule)
+				}
+			}
+		return result
+	}
+	export function apply(reserve: number, state: State): number {
+		return state.transaction.kind == "authorization" ||
+			state.transaction.kind == "outbound" ||
+			state.transaction.kind == "capture"
+			? isoly.Currency.add(state.transaction.original.currency, state.transaction.original.total, reserve)
+			: isoly.Currency.subtract(state.transaction.original.currency, state.transaction.original.total, reserve)
+	}
+}

package/Rule/Score.ts

@@ -0,0 +1,45 @@
+import { selectively } from "selectively"
+import { isly } from "isly"
+import { Base } from "./Base"
+import { control } from "./control"
+import type { State } from "./State"
+
+export interface Score extends Base {
+	action: Score.Action
+	category: "fincrime"
+	risk: Score.Risk
+}
+export namespace Score {
+	export type Action = typeof Action.value
+	export namespace Action {
+		export const value = "score"
+	}
+	export type Risk = number
+	export const Risk = isly.number<Risk>(["positive", "integer"])
+	export const type = Base.type.extend<Score>({
+		action: isly.string(Action.value),
+		category: isly.string("fincrime"),
+		risk: Risk,
+	})
+	export function evaluate(
+		rules: Score[],
+		state: State,
+		macros?: Record<string, selectively.Definition>
+	): {
+		outcomes: Score[]
+		risk?: number | undefined
+	} {
+		const result: ReturnType<typeof evaluate> = { outcomes: [] }
+		if (
+			state.transaction.stage == "initiate" &&
+			["card", "external", "internal"].some(type => type == state.transaction.type)
+		)
+			for (const rule of rules) {
+				if (control(rule, state, macros)) {
+					result.risk = (result.risk ?? 100) * (rule.risk / 100)
+					result.outcomes.push(rule)
+				}
+			}
+		return result
+	}
+}

package/Rule/State/Transaction.ts

@@ -1,27 +1,40 @@
 import { isoly } from "isoly"
 import type { Address } from "../../Rail/Address"
 import { Transaction as ModelTransaction } from "../../Transaction"
-import { Rule } from "../Rule"
+import type { Rule } from "../index"
 
 export interface Transaction extends ModelTransaction.Creatable {
 	kind: Rule.Base.Kind
+	stage: "finalize" | "initiate"
 	amount: number
 	type: ModelTransaction.Types
 	risk?: number
-	original: { currency: isoly.Currency; amount: number; charge?: number; total?: number }
+	original: {
+		currency: isoly.Currency
+		total: number
+		amount: number
+		charge?: { current: number; total: number }
+		reserve?: number
+	}
 }
 export namespace Transaction {
 	export function from(
 		accountName: string,
 		transaction: ModelTransaction.Creatable & { counterpart: Address },
-		kind: Rule.Base.Kind
+		kind: Rule.Base.Kind,
+		stage: "finalize" | "initiate"
 	): Transaction {
 		return {
 			...transaction,
+			stage,
 			kind,
 			amount: Math.abs(transaction.amount),
 			type: ModelTransaction.getType(transaction.counterpart, accountName),
-			original: { currency: transaction.currency, amount: Math.abs(transaction.amount) },
+			original: {
+				currency: transaction.currency,
+				amount: Math.abs(transaction.amount),
+				total: Math.abs(transaction.amount),
+			},
 		}
 	}
 }

package/Rule/State/index.ts

@@ -2,7 +2,7 @@ import { isly } from "isly"
 import { Account as ModelAccount } from "../../Account"
 import type { Address } from "../../Rail/Address"
 import type { Transaction as ModelTransaction } from "../../Transaction"
-import { Rule } from "../Rule"
+import type { Rule } from "../index"
 import { Account as StateAccount } from "./Account"
 import { Authorization as StateAuthorization } from "./Authorization"
 import { Card as StateCard } from "./Card"
@@ -45,6 +45,7 @@ export namespace State {
 		days: Account.Days,
 		transaction: ModelTransaction.Creatable & { counterpart: Address },
 		kind: Rule.Base.Kind,
+		stage: "finalize" | "initiate",
 		authorization?: Authorization,
 		card?: Card,
 		organization?: Organization
@@ -52,7 +53,7 @@ export namespace State {
 		return {
 			data,
 			account: Account.from(account, transactions, days),
-			transaction: Transaction.from(account.name, transaction, kind),
+			transaction: Transaction.from(account.name, transaction, kind, stage),
 			authorization,
 			card,
 			organization,

package/Rule/control.ts

@@ -0,0 +1,8 @@
+import { selectively } from "selectively"
+import type { Rule } from "."
+import { definitions } from "./definitions"
+import type { State } from "./State"
+
+export function control(rule: Rule, state: State, macros?: Record<string, selectively.Definition>): boolean {
+	return selectively.resolve({ ...macros, ...definitions }, selectively.parse(rule.condition)).is(state)
+}