@pax2pay/model-banking 0.1.118 → 0.1.120

package/Amount.ts

@@ -0,0 +1,10 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+
+export type Amount = [isoly.Currency, number]
+
+export namespace Amount {
+	export const type = isly.tuple<Amount>(isly.string(isoly.Currency.types), isly.number())
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Amounts.ts

@@ -0,0 +1,10 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+
+export type Amounts = Partial<Record<isoly.Currency, number>>
+
+export namespace Amounts {
+	export const type = isly.record<Amounts>(isly.string(isoly.Currency.types), isly.number())
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Authorization/Creatable.ts

@@ -1,11 +1,12 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Acquirer } from "../Acquirer"
+import { Amount } from "../Amount"
 import { Merchant } from "../Merchant"
 
 export interface Creatable {
 	card: string
-	amount: [isoly.Currency, number]
+	amount: Amount
 	merchant: Merchant
 	acquirer: Acquirer
 	reference: string

package/Authorization/Status.ts

@@ -0,0 +1,47 @@
+import { gracely } from "gracely"
+import { isly } from "isly"
+import { Transaction } from "../Transaction"
+
+export type Status = "approved" | Status.Failed
+
+export namespace Status {
+	export interface Failed {
+		code: string
+		reason: string | string[]
+		error?: gracely.Error
+	}
+	export namespace Failed {
+		export function from(error?: gracely.Error): Failed {
+			let result: Status
+			if (error?.error?.includes("Card with id"))
+				result = { code: "14", reason: "Invalid card number" }
+			else if (error?.error?.includes("must correspond to card limit")) {
+				result = { code: "13", reason: "Invalid amount" }
+			} else if (error?.error?.includes("Failed to reach account")) {
+				result = { code: "78", reason: "Invalid/nonexistent account specified (general)" }
+			} else if (gracely.client.InvalidContent.is(error) && error.content.description.includes("rules")) {
+				const reasons: string[] = error.content.details?.notes.reduce(
+					(a: string[], c: Transaction.Note) => [...a, `${c.created} ${c.author}: ${c.text ?? ""}`],
+					[]
+				)
+				result = {
+					code: "62", //Restricted card: "This means that the card that you processed is restricted to where it can be used.
+					//The restricted card is only allowed to be used for certain types of businesses or purchases."
+					reason: ["Restricted card.", ...reasons],
+				}
+			} else
+				result = { code: "05", reason: "Do not honor" } //default
+			return result
+		}
+	}
+	export const type = isly.union(
+		isly.string("approved"),
+		isly.object<Status.Failed>({
+			code: isly.string(),
+			reason: isly.union(isly.string(), isly.string().array()),
+			error: isly.fromIs("gracely.Error", gracely.Error.is).optional(),
+		})
+	)
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Authorization/index.ts

@@ -1,33 +1,107 @@
+import { cryptly } from "cryptly"
 import { gracely } from "gracely"
+import { isoly } from "isoly"
 import { isly } from "isly"
+import { Acquirer } from "../Acquirer"
+import { Amount } from "../Amount"
 import { Card } from "../Card"
+import { Identifier } from "../Identifier"
+import { Merchant } from "../Merchant"
 import { Transaction } from "../Transaction"
-import { Approved as AuthorizationApproved } from "./Approved"
 import { Creatable as AuthorizationCreatable } from "./Creatable"
-import { Failed as AuthorizationFailed } from "./Failed"
+import { Status } from "./Status"
 
-export type Authorization = Authorization.Failed | Authorization.Approved
+export interface Authorization {
+	id: cryptly.Identifier
+	created: isoly.DateTime
+	status: Status
+	reference: string
+	amount: Amount
+	card: {
+		id: string
+		token?: string
+		iin?: string
+		last4?: string
+	}
+	transaction?: {
+		id: string
+		posted: isoly.DateTime
+		description: string
+	}
+	account?: string
+	merchant: Merchant
+	acquirer: Acquirer
+	description: string
+}
 export namespace Authorization {
-	export type Approved = AuthorizationApproved
-	export const Approved = AuthorizationApproved
-	export type Failed = AuthorizationFailed
-	export const Failed = AuthorizationFailed
 	export type Creatable = AuthorizationCreatable
 	export const Creatable = AuthorizationCreatable
+
+	export const type = isly.object<Authorization>({
+		id: isly.fromIs("Authorization.id", cryptly.Identifier.is),
+		status: Status.type,
+		transaction: isly
+			.object<Required<Authorization>["transaction"]>({
+				id: isly.string(),
+				posted: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
+				description: isly.string(),
+			})
+			.optional(),
+		card: isly.object<Authorization["card"]>({
+			id: isly.string(),
+			token: isly.string().optional(),
+			iin: isly.string().optional(),
+			last4: isly.string().optional(),
+		}),
+		created: isly.fromIs("Authorization.created", isoly.DateTime.is),
+		amount: isly.tuple(isly.fromIs("isoly.Currency", isoly.Currency.is), isly.number()),
+		account: isly.string().optional(),
+		merchant: Merchant.type,
+		acquirer: Acquirer.type,
+		reference: isly.string(),
+		description: isly.string(),
+	})
+	export const is = type.is
+	export const flaw = type.flaw
 	export function fromCreatable(
-		authorization: Authorization.Creatable,
-		transaction: Transaction | gracely.Error
+		creatable: Creatable,
+		card: Card | gracely.Error,
+		transaction?: Transaction | gracely.Error
 	): Authorization {
-		return gracely.Error.is(transaction)
-			? Authorization.Failed.fromCreatable(authorization, transaction)
-			: Authorization.Approved.fromCreatable(authorization, transaction)
+		const partial: Pick<Authorization, "created" | "amount" | "merchant" | "acquirer" | "reference" | "description"> = {
+			created: isoly.DateTime.now(),
+			amount: creatable.amount,
+			merchant: creatable.merchant,
+			acquirer: creatable.acquirer,
+			reference: creatable.reference,
+			description: creatable.description,
+		}
+		let result: Authorization
+		if (gracely.Error.is(card))
+			result = {
+				id: Identifier.generate(),
+				status: Status.Failed.from(card),
+				...partial,
+				card: { id: creatable.card },
+			}
+		else if (gracely.Error.is(transaction) || !transaction)
+			result = {
+				id: Identifier.generate(),
+				status: Status.Failed.from(transaction),
+				...partial,
+				card: { id: card.id, iin: card.details.iin, last4: card.details.last4, token: card.details.token },
+			}
+		else
+			result = {
+				id: transaction.id,
+				status: "approved",
+				...partial,
+				card: { id: card.id, iin: card.details.iin, last4: card.details.last4, token: card.details.token },
+				account: card.account,
+				transaction: { id: transaction?.id, posted: transaction?.posted, description: transaction.description },
+			}
+		return result
 	}
-	export const type = isly.union<Authorization, Authorization.Failed, Authorization.Approved>(
-		Authorization.Failed.type,
-		Authorization.Approved.type
-	)
-	export const is = type.is
-	export const flaw = type.flaw
 
 	export function toTransaction(authorization: Authorization, card: Card): Transaction.Creatable {
 		return {

package/Card/Changeable.ts

@@ -1,9 +1,10 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { Amount } from "../Amount"
 import { Meta } from "./Meta"
 
 export type Changeable = {
-	limit?: [isoly.Currency, number]
+	limit?: Amount
 	meta?: Meta
 }
 

package/Card/Creatable.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { Amount } from "../Amount"
 import { Rule, type as ruleType } from "../Rule/Rule"
 import { Expiry } from "./Expiry"
 import { Meta } from "./Meta"
@@ -13,7 +14,7 @@ export interface Creatable {
 		expiry: Expiry
 		holder: string
 	}
-	limit: [isoly.Currency, number]
+	limit: Amount
 	rules?: Rule[]
 	meta?: Meta
 }

package/Card/Operation/Settlement.ts

@@ -3,7 +3,7 @@ import { isly } from "isly"
 
 export interface Settlement {
 	type: "settlement"
-	status: "capture" | "cancel" | "refund"
+	status: "capture" | "cancel" | "refund" | "unknown"
 	transaction?: string
 	created: isoly.DateTime
 }
@@ -11,7 +11,7 @@ export interface Settlement {
 export namespace Settlement {
 	export const type = isly.object<Settlement>({
 		type: isly.string("settlement"),
-		status: isly.union(isly.string("capture"), isly.string("cancel"), isly.string("refund")),
+		status: isly.union(isly.string("capture"), isly.string("cancel"), isly.string("refund"), isly.string("unknown")),
 		transaction: isly.string().optional(),
 		created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
 	})

package/Card/Preset.ts

@@ -2,6 +2,7 @@ import { isly } from "isly"
 
 export type Preset = typeof Preset.names[number]
 
+// "realm-scheme-interchange"
 export namespace Preset {
 	export const names = ["p2p-mc-200", "test-mc-200", "test-pg-200", "test-ta-pg-200", "test-ta-mc-200"] as const
 	export const type = isly.string(names)

package/Card/index.ts

@@ -1,5 +1,6 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { Amount } from "../Amount"
 import { Realm } from "../Realm"
 import { Rule, type as ruleType } from "../Rule/Rule"
 import { Changeable as CardChangeable } from "./Changeable"
@@ -27,8 +28,8 @@ export interface Card {
 		holder: string
 		token: string
 	}
-	limit: [isoly.Currency, number]
-	spent: [isoly.Currency, number]
+	limit: Amount
+	spent: Amount
 	status: "active" | "cancelled"
 	history: CardOperation[]
 	rules: Rule[]

package/Client/Settlements.ts

@@ -15,8 +15,8 @@ export class Settlements extends rest.Collection<gracely.Error> {
 	async fetch(id: string, created: isoly.DateTime): Promise<Settlement | gracely.Error> {
 		return this.client.get<Settlement>(`/settlement/${id}?created=${created}`)
 	}
-	async list(): Promise<Settlement.Summary[] | gracely.Error> {
-		return this.client.get<Settlement.Summary[] & { cursor?: string | undefined }>(`/settlement`)
+	async list(): Promise<Settlement[] | gracely.Error> {
+		return this.client.get<Settlement[] & { cursor?: string | undefined }>(`/settlement`)
 	}
 	async remove(settlement: string): Promise<Settlement | gracely.Error> {
 		return this.client.delete<Settlement>(`/settlement/${settlement}`)

package/Identifier.ts

@@ -0,0 +1,12 @@
+import { cryptly } from "cryptly"
+import { isoly } from "isoly"
+
+export namespace Identifier {
+	export function generate(
+		length: cryptly.Identifier.Length = 16,
+		ordering: "ordered" | "reversed" = "reversed",
+		date: isoly.DateTime = isoly.DateTime.now()
+	): string {
+		return cryptly.Identifier.generate(length, ordering, isoly.DateTime.epoch(date))
+	}
+}

package/{Realm/index.ts → Realm.ts}

@@ -1,5 +1,5 @@
 import { isly } from "isly"
-import { Supplier as modelSupplier } from "../Supplier"
+import { Supplier as modelSupplier } from "./Supplier"
 
 export type Realm = typeof Realm.realms[number]
 
@@ -7,6 +7,7 @@ export namespace Realm {
 	export const realms = ["test", "testUK", "uk", "eu", "upcheck"] as const
 	export const type: isly.Type<Realm> = isly.string(realms)
 	export const is = type.is
+	export const flaw = type.flaw
 	export function toString(): string {
 		return realms.toString().replaceAll(",", ", ") + "."
 	}

package/Rule/State/index.ts

@@ -19,7 +19,7 @@ export namespace State {
 	export function from(
 		account: ModelAccount,
 		transaction: ModelTransaction,
-		authorization?: ModelAuthorization,
+		authorization?: ModelAuthorization.Creatable,
 		card?: ModelCard
 	): State {
 		return {

package/Settlement/Creatable.ts

@@ -0,0 +1,18 @@
+import { isly } from "isly"
+import { Total } from "./Total"
+
+export interface Creatable {
+	expected?: Total
+	processor: string
+	reference: string
+}
+
+export namespace Creatable {
+	export const type = isly.object<Creatable>({
+		expected: Total.type.optional(),
+		processor: isly.string(),
+		reference: isly.string(),
+	})
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Entry/Cancel.ts

@@ -0,0 +1,34 @@
+import { isly } from "isly"
+import { Amount } from "../../Amount"
+import { Authorization } from "../../Authorization"
+import { Fee } from "../Fee"
+
+export interface Cancel extends Cancel.Creatable {
+	status: "succeeded" | "failed"
+}
+
+export namespace Cancel {
+	export interface Creatable {
+		type: "cancel"
+		authorization?: Authorization
+		reference: string
+		fee?: Fee
+		amount?: Amount
+	}
+	export namespace Creatable {
+		export const type = isly.object<Creatable>({
+			type: isly.string("cancel"),
+			authorization: Authorization.type.optional(),
+			reference: isly.string(),
+			fee: Fee.type.optional(),
+			amount: Amount.type.optional(),
+		})
+		export const is = type.is
+		export const flaw = type.flaw
+	}
+	export const type = Creatable.type.extend<Cancel>({
+		status: isly.string(["succeeded", "failed"]),
+	})
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Entry/Capture.ts

@@ -0,0 +1,34 @@
+import { isly } from "isly"
+import { Amount } from "../../Amount"
+import { Authorization } from "../../Authorization"
+import { Fee } from "../Fee"
+
+export interface Capture extends Capture.Creatable {
+	status: "succeeded" | "failed"
+}
+
+export namespace Capture {
+	export interface Creatable {
+		type: "capture"
+		authorization?: Authorization
+		reference: string
+		fee?: Fee
+		amount?: Amount
+	}
+	export namespace Creatable {
+		export const type = isly.object<Creatable>({
+			type: isly.string("capture"),
+			authorization: Authorization.type.optional(),
+			reference: isly.string(),
+			fee: Fee.type.optional(),
+			amount: Amount.type.optional(),
+		})
+		export const is = type.is
+		export const flaw = type.flaw
+	}
+	export const type = Creatable.type.extend<Capture>({
+		status: isly.string(["succeeded", "failed"]),
+	})
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Entry/Creatable.ts

@@ -0,0 +1,18 @@
+import { isly } from "isly"
+import { Cancel as EntryCancel } from "./Cancel"
+import { Capture as EntryCapture } from "./Capture"
+import { Refund as EntryRefund } from "./Refund"
+import { Unknown as EntryUnknown } from "./Unknown"
+
+export type Creatable = EntryCancel.Creatable | EntryCapture.Creatable | EntryRefund.Creatable | EntryUnknown.Creatable
+
+export namespace Creatable {
+	export const type = isly.union(
+		EntryCancel.Creatable.type,
+		EntryCapture.Creatable.type,
+		EntryRefund.Creatable.type,
+		EntryUnknown.Creatable.type
+	)
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Entry/Refund.ts

@@ -0,0 +1,34 @@
+import { isly } from "isly"
+import { Amount } from "../../Amount"
+import { Authorization } from "../../Authorization"
+import { Fee } from "../Fee"
+
+export interface Refund extends Refund.Creatable {
+	status: "succeeded" | "failed"
+}
+
+export namespace Refund {
+	export interface Creatable {
+		type: "refund"
+		authorization?: Authorization
+		reference: string
+		fee?: Fee
+		amount?: Amount
+	}
+	export namespace Creatable {
+		export const type = isly.object<Creatable>({
+			type: isly.string("refund"),
+			authorization: Authorization.type.optional(),
+			reference: isly.string(),
+			fee: Fee.type.optional(),
+			amount: Amount.type.optional(),
+		})
+		export const is = type.is
+		export const flaw = type.flaw
+	}
+	export const type = Creatable.type.extend<Refund>({
+		status: isly.string(["succeeded", "failed"]),
+	})
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Entry/Summary.ts

@@ -0,0 +1,21 @@
+import { isly } from "isly"
+
+export interface Summary {
+	count: number
+	failed?: {
+		count: number
+	}
+}
+
+export namespace Summary {
+	export const type = isly.object<Summary>({
+		count: isly.number(),
+		failed: isly
+			.object<{ count: number }>({
+				count: isly.number(),
+			})
+			.optional(),
+	})
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Entry/Unknown.ts

@@ -0,0 +1,29 @@
+import { isly } from "isly"
+import { Authorization } from "../../Authorization"
+
+export interface Unknown extends Unknown.Creatable {
+	status: "succeeded" | "failed"
+}
+
+export namespace Unknown {
+	export interface Creatable {
+		type: "unknown"
+		authorization?: Authorization
+		data: Record<string, any>
+	}
+	export namespace Creatable {
+		export const type = isly.object<Creatable>({
+			type: isly.string("unknown"),
+			authorization: Authorization.type.optional(),
+			data: isly.record(isly.string(), isly.any()),
+		})
+		export const is = Unknown.is
+		export const flaw = Unknown.flaw
+	}
+	export function from(creatable: Creatable): Unknown {
+		return { ...creatable, status: "failed" }
+	}
+	export const type = Creatable.type.extend<Unknown>({ status: isly.string(["succeeded", "failed"]) })
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Entry/index.ts

@@ -0,0 +1,49 @@
+import { gracely } from "gracely"
+import { isly } from "isly"
+import { Authorization } from "../../Authorization"
+import { Transaction } from "../../Transaction"
+import { Cancel as EntryCancel } from "./Cancel"
+import { Capture as EntryCapture } from "./Capture"
+import { Creatable as EntryCreatable } from "./Creatable"
+import { Refund as EntryRefund } from "./Refund"
+import { Summary as EntrySummary } from "./Summary"
+import { Unknown as EntryUnknown } from "./Unknown"
+
+export type Entry = Entry.Cancel | Entry.Capture | Entry.Refund | Entry.Unknown
+
+export namespace Entry {
+	export type Cancel = EntryCancel
+	export const Cancel = EntryCancel
+	export type Capture = EntryCapture
+	export const Capture = EntryCapture
+	export type Creatable = EntryCreatable
+	export const Creatable = EntryCreatable
+	export type Refund = EntryRefund
+	export const Refund = EntryRefund
+	export type Summary = EntrySummary
+	export const Summary = EntrySummary
+	export type Unknown = EntryUnknown
+	export const Unknown = EntryUnknown
+	export namespace Unknown {
+		export type Creatable = EntryUnknown.Creatable
+	}
+	export function from(creatable: Entry.Creatable, transaction?: Transaction | gracely.Error): Entry {
+		return Transaction.is(transaction) && creatable.authorization
+			? {
+					status: "succeeded",
+					...creatable,
+			  }
+			: {
+					status: "failed",
+					...creatable,
+			  }
+	}
+	export const type = isly.union<Entry, Entry.Cancel, Entry.Capture, Entry.Refund, Entry.Unknown>(
+		Entry.Cancel.type,
+		Entry.Capture.type,
+		Entry.Refund.type,
+		Entry.Unknown.type
+	)
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Fee.ts

@@ -0,0 +1,12 @@
+import { isly } from "isly"
+import { Amounts } from "../Amounts"
+
+export interface Fee {
+	other: Amounts
+}
+
+export namespace Fee {
+	export const type = isly.object<Fee>({ other: Amounts.type })
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Settled.ts

@@ -0,0 +1,19 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+import { Amount } from "../Amount"
+
+export interface Settled {
+	by?: string
+	created: isoly.DateTime
+	transactions: Record<string, Amount>
+}
+
+export namespace Settled {
+	export const type = isly.object<Settled>({
+		by: isly.string().optional(),
+		created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
+		transactions: isly.record(isly.string(), Amount.type),
+	})
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Status.ts

@@ -0,0 +1,13 @@
+import { isly } from "isly"
+
+export type Status = "succeeded" | ["failed", string] | "ongoing"
+
+export namespace Status {
+	export const type = isly.union(
+		isly.string("succeeded"),
+		isly.string("ongoing"),
+		isly.tuple(isly.string("failed"), isly.string())
+	)
+	export const is = type.is
+	export const flaw = type.flaw
+}

package/Settlement/Total.ts

@@ -0,0 +1,17 @@
+import { isly } from "isly"
+import { Amounts } from "../Amounts"
+import { Fee } from "./Fee"
+
+export type Total = {
+	amount: Amounts
+	fee: Fee
+}
+
+export namespace Total {
+	export function initiate(): Total {
+		return { amount: {}, fee: { other: {} } }
+	}
+	export const type = isly.object<Total>({ amount: Amounts.type, fee: Fee.type })
+	export const is = type.is
+	export const flaw = type.flaw
+}