@pax2pay/model-banking 0.1.384 → 0.1.385

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/Creatable.ts

@@ -77,7 +77,7 @@ export namespace Creatable {
 					},
 					available: {
 						type: "subtract" as const,
-						amount: charge,
+						amount: Math.abs(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)
+}

package/Rule/index.ts

@@ -1,129 +1,108 @@
-import { isoly } from "isoly"
 import { selectively } from "selectively"
+import { isly } from "isly"
 import { Exchange } from "../Exchange"
-import { Note } from "../Transaction/Note"
-import { definitions } from "./definitions"
-import { Rule as ModelRule, type as ruleType } from "./Rule"
+import { Realm } from "../Realm"
+import { Base as RuleBase } from "./Base"
+import { Charge as RuleCharge } from "./Charge"
+import { control as ruleControl } from "./control"
+import { Other as RuleOther } from "./Other"
+import { Reserve as RuleReserve } from "./Reserve"
+import { Score as RuleScore } from "./Score"
 import { State as RuleState } from "./State"
+import { type as ruleType } from "./type"
 
-export type Rule = ModelRule
-
+export type Rule = Rule.Other | Rule.Score | Rule.Charge | Rule.Reserve
 export namespace Rule {
-	export import Api = ModelRule.Api
-	export import Action = ModelRule.Action
-	export import Category = ModelRule.Base.Category
-	export import Kind = ModelRule.Base.Kind
-	export import Other = ModelRule.Other
-	export import Score = ModelRule.Score
-	export import Charge = ModelRule.Charge
+	export import Other = RuleOther
+	export import Score = RuleScore
+	export import Charge = RuleCharge
 	export import State = RuleState
-	export const type = ruleType
-	export const is = ruleType.is
-	export const flaw = ruleType.flaw
-	function shouldUse(kind: Rule.Kind, rule: Rule, groups: string[] | undefined): boolean {
-		return (
-			kind == rule.type &&
-			(!rule.groups || rule.groups.some(ruleGroup => groups?.some(organizationGroup => organizationGroup == ruleGroup)))
+	export import Reserve = RuleReserve
+	export import Base = RuleBase
+	export import Kind = Base.Kind
+	export import Category = Base.Category
+	export const control = ruleControl
+	export type Api = Rule.Other | Rule.Score | Rule.Charge.Api | Rule.Reserve.Api
+	export namespace Api {
+		export const type = isly.union<Api, Rule.Other, Rule.Score, Rule.Charge.Api, Rule.Reserve.Api>(
+			Rule.Other.type,
+			Rule.Score.type,
+			Rule.Charge.Api.type,
+			Rule.Reserve.Api.type
 		)
 	}
-	function control(rule: ModelRule, state: State, macros?: Record<string, selectively.Definition>): boolean {
-		return selectively.resolve({ ...macros, ...definitions }, selectively.parse(rule.condition)).is(state)
+	export function fromApi(rule: Rule.Api, realm: Realm): Rule {
+		return rule.action == "charge"
+			? Charge.fromApi(rule, realm)
+			: rule.action == "reserve"
+			? Reserve.fromApi(rule, realm)
+			: rule
 	}
-	function score(
-		rules: ModelRule.Score[],
-		state: State,
-		macros?: Record<string, selectively.Definition>
-	): number | undefined {
-		return rules.reduce(
-			(r: number | undefined, rule) => (control(rule, state, macros) ? (r ?? 100) * (rule.risk / 100) : r),
-			undefined
-		)
-	}
-	function charge(
-		rules: ModelRule.Charge[],
-		state: State,
-		macros?: Record<string, selectively.Definition>,
-		table: Exchange.Rates = {}
-	): { outcomes: Rule[]; charge: number } {
-		const result: { outcomes: Rule[]; charge: number } = { outcomes: [], charge: 0 }
-		for (const rule of rules) {
-			if (control(rule, state, macros)) {
-				if (rule.charge.percentage)
-					result.charge = isoly.Currency.add(
-						state.transaction.currency,
-						result.charge,
-						isoly.Currency.multiply(state.transaction.currency, state.transaction.amount, rule.charge.percentage / 100)
-					)
-				if (rule.charge.fixed) {
-					const charge =
-						state.transaction.currency === rule.charge.fixed[0]
-							? rule.charge.fixed[1]
-							: Exchange.convert(rule.charge.fixed[1], rule.charge.fixed[0], state.transaction.currency, table) ?? 0
-					result.charge = isoly.Currency.add(state.transaction.currency, result.charge, charge)
-				}
-				result.outcomes.push(rule)
-			}
-		}
-		return result
+	export type Action = typeof Action.values[number]
+	export namespace Action {
+		export const values = [
+			...Other.Action.values,
+			Score.Action.value,
+			Charge.Action.value,
+			Reserve.Action.value,
+		] as const
+		export const type = isly.string<Action>(values)
 	}
+	export const type = ruleType
 	export function evaluate(
 		rules: Rule[],
-		state: State,
+		state: RuleState,
 		macros?: Record<string, selectively.Definition>,
 		table: Exchange.Rates = {}
-	): State.Evaluated {
-		const outcomes: Record<ModelRule.Other.Action | ModelRule.Charge.Action, Rule[]> = {
+	): RuleState.Evaluated {
+		const outcomes: Record<Rule.Action, Rule[]> = {
 			review: [],
 			reject: [],
 			flag: [],
 			charge: [],
+			score: [],
+			reserve: [],
 		}
-		const { other, chargers, scorers } = rules.reduce(
-			(r: { other: ModelRule.Other[]; chargers: ModelRule.Charge[]; scorers: ModelRule.Score[] }, rule) => {
-				if (shouldUse(state.transaction.kind, rule, state.organization?.groups))
+		const { other, chargers, scorers, reservers } = sort(rules, state)
+		const scored = Score.evaluate(scorers, state, macros)
+		outcomes.score.push(...scored.outcomes)
+		state.transaction.risk = scored.risk
+		const evaluated = Other.evaluate(other, state, macros)
+		outcomes.flag.push(...evaluated.outcomes.flag)
+		outcomes.review.push(...evaluated.outcomes.review)
+		outcomes.reject.push(...evaluated.outcomes.reject)
+		const reserved = Reserve.evaluate(reservers, state, macros, table)
+		outcomes.reserve.push(...reserved.outcomes)
+		state.transaction.original.reserve = reserved.reserve
+		state.transaction.original.total = Reserve.apply(reserved.reserve, state)
+		const charged = Charge.evaluate(chargers, state, macros, table)
+		outcomes.charge.push(...charged.outcomes)
+		state.transaction.original.charge = charged.charge
+		state.transaction.original.total = Charge.apply(charged.charge, state)
+		const outcome = outcomes.reject.length > 0 ? "reject" : outcomes.review.length > 0 ? "review" : "approve"
+		return { ...state, flags: [...evaluated.flags], notes: evaluated.notes, outcomes, outcome }
+	}
+	function sort(
+		rules: Rule[],
+		state: State
+	): { other: Rule.Other[]; chargers: Rule.Charge[]; scorers: Rule.Score[]; reservers: Rule.Reserve[] } {
+		return rules.reduce(
+			(r: ReturnType<typeof sort>, rule) => {
+				if (Base.Kind.is(state.transaction.kind, rule, state.organization?.groups))
 					rule.action == "score"
 						? r.scorers.push(rule)
 						: rule.action == "charge"
 						? r.chargers.push(rule)
+						: rule.action == "reserve"
+						? r.reservers.push(rule)
 						: r.other.push(rule)
 				return r
 			},
-			{ other: [], chargers: [], scorers: [] }
+			{ other: [], chargers: [], scorers: [], reservers: [] }
 		)
-		state.transaction.risk = score(scorers, state, macros)
-		const notes: Note[] = []
-		const flags: Set<string> = new Set()
-		const now = isoly.DateTime.now()
-		for (const rule of other) {
-			if (control(rule, state, macros)) {
-				outcomes[rule.action].push(rule)
-				notes.push({ author: "automatic", created: now, text: rule.name, rule })
-				rule.flags.forEach(f => flags.add(f))
-				rule.action == "review" && flags.add("review")
-			}
-		}
-		const charged = charge(chargers, state, macros, table)
-		state.transaction.original.charge = isoly.Currency.add(
-			state.transaction.original.currency,
-			state.transaction.original.charge ?? 0,
-			charged.charge
-		)
-		state.transaction.original.total =
-			state.transaction.kind == "authorization" ||
-			state.transaction.kind == "outbound" ||
-			state.transaction.kind == "capture"
-				? isoly.Currency.add(state.transaction.original.currency, state.transaction.original.amount, charged.charge)
-				: isoly.Currency.subtract(
-						state.transaction.original.currency,
-						state.transaction.original.amount,
-						charged.charge
-				  )
-		outcomes.charge.push(...charged.outcomes)
-		const outcome = outcomes.reject.length > 0 ? "reject" : outcomes.review.length > 0 ? "review" : "approve"
-		return { ...state, flags: [...flags], notes, outcomes, outcome }
 	}
 	export function isLegacy(rule: Rule): boolean {
-		return !ModelRule.Base.Category.type.is(rule.category)
+		return !Rule.Base.Category.type.is(rule.category)
 	}
 	export function fromLegacy(rule: Rule): Rule {
 		return isLegacy(rule) ? { ...rule, category: "fincrime" } : rule

package/Rule/type.ts

@@ -0,0 +1,13 @@
+import { isly } from "isly"
+import { Charge } from "./Charge"
+import type { Rule } from "./index"
+import { Other } from "./Other"
+import { Reserve } from "./Reserve"
+import { Score } from "./Score"
+
+export const type = isly.union<Rule, Other, Score, Charge.Api, Reserve>(
+	Other.type,
+	Score.type,
+	Charge.Api.type,
+	Reserve.type
+)