@wdft/micropayments-sdk 0.0.1 → 0.0.2

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "@wdft/micropayments-sdk",
-  "type": "module",
   "description": "wdft - we do fintech - micropayments sdk",
-  "version": "0.0.1",
+  "version": "0.0.2",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist/**/*"
+    "dist/**/*",
+    "src/**/*"
   ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js"
+  },
   "author": "Mateusz Worotyński <mateusz@wdft.ovh>",
   "license": "MIT",
   "devDependencies": {

package/src/browser.ts

@@ -0,0 +1,5 @@
+import QRCode from "qrcode";
+
+export async function generateQRCode(text: string) {
+	return await QRCode.toDataURL(text, { errorCorrectionLevel: "L" });
+}

package/src/client.test.ts

@@ -0,0 +1,164 @@
+import { describe, it } from "vitest";
+import { expect } from "vitest";
+import { Client } from "./client.js";
+import { mockFetch } from "./test_utils/mock_fetcher.js";
+
+describe("client e2e", () => {
+	const mock = mockFetch();
+
+	const client = Client.new({
+		currency: "PLN",
+		tenant_id: "my-tenant",
+		endpoint: "http://localhost:8787",
+		fetcher: mock.fetcher.bind(mock),
+		retry_ms: 100,
+	});
+
+	it("initialized -> waiting x2 -> resolved", async () => {
+		await new Promise((resolve, reject) => {
+			mock.next(200, {
+				click_url: "mock_click_url",
+				incoming_message_device: "mock_num",
+				expires_at: Date.now() + 30_000,
+				commitment_id: "sample_commitment_id",
+			});
+
+			mock.next(200, {
+				message: "waiting for sms",
+				status: "waiting",
+				commitment_id: "sample_commitment_id",
+			});
+
+			mock.next(200, {
+				message: "waiting for sms",
+				status: "waiting",
+				commitment_id: "sample_commitment_id",
+			});
+
+			mock.next(200, {
+				message: "waiting for sms",
+				status: "resolved",
+				commitment_id: "sample_commitment_id",
+			});
+
+			// Sync with Events
+			client.create("my-ref", 10, (error, payload) => {
+				if (!payload || error) {
+					console.log(error);
+					reject(error);
+					return;
+				}
+
+				const { status } = payload;
+
+				switch (status) {
+					case "waiting":
+					case "created":
+					case "duplicated":
+					case "expired":
+						console.log(payload);
+						break;
+					case "resolved":
+						resolve(status);
+				}
+			});
+		});
+	});
+
+	it("initialized -> expired", async () => {
+		await expect(
+			new Promise((resolve, reject) => {
+				mock.next(200, {
+					click_url: "mock_click_url",
+					incoming_message_device: "mock_num",
+					expires_at: Date.now() + 30_000,
+					commitment_id: "sample_commitment_id",
+				});
+
+				mock.next(200, {
+					message: "waiting for sms",
+					status: "waiting",
+					commitment_id: "sample_commitment_id",
+				});
+
+				mock.next(200, {
+					message: "waiting for sms",
+					status: "waiting",
+					commitment_id: "sample_commitment_id",
+				});
+
+				mock.next(410, {
+					message: "commitment expired",
+					status: "expired",
+					commitment_id: "sample_commitment_id",
+				});
+
+				// Sync with Events
+				client.create("my-ref", 10, (error, payload) => {
+					if (!payload || error) {
+						reject(error);
+						return;
+					}
+
+					const { status } = payload;
+
+					switch (status) {
+						case "waiting":
+						case "created":
+						case "duplicated":
+							break;
+						case "expired":
+							reject(status);
+							break;
+						case "resolved":
+							resolve(status);
+							break;
+					}
+				});
+			}),
+		).rejects.toBe("expired");
+	});
+
+	it("initialized -> duplicated", async () => {
+		await expect(
+			new Promise((resolve, reject) => {
+				mock.next(200, {
+					click_url: "mock_click_url",
+					incoming_message_device: "mock_num",
+					expires_at: Date.now() + 30_000,
+					commitment_id: "sample_commitment_id",
+				});
+
+				mock.next(200, {
+					message: "waiting for sms",
+					status: "duplicated",
+					commitment_id: "sample_commitment_id",
+				});
+
+				// Sync with Events
+				client.create("my-ref", 10, (error, payload) => {
+					if (!payload || error) {
+						reject(error);
+						return;
+					}
+
+					const { status } = payload;
+
+					switch (status) {
+						case "waiting":
+						case "created":
+						case "duplicated":
+							resolve(status);
+							break;
+						case "expired":
+							reject(status);
+							break;
+						case "resolved":
+							resolve(status);
+							break;
+					}
+				});
+			}),
+		).resolves.toBe("duplicated");
+	});
+});

package/src/client.ts

@@ -0,0 +1,475 @@
+import { type IServiceOptions, Service } from "./service.js";
+
+interface ICommitmentPayload {
+	commitment_id: string;
+	amount: number;
+	currency: string;
+	reference_id: string;
+	expires_at: number;
+	click_url: string;
+	retry_ms: number;
+	message: string;
+	status: CommitmentStatus;
+}
+
+export type CommitmentStatus =
+	| "initializing"
+	| "created"
+	| "waiting"
+	| "expired"
+	| "resolved"
+	| "duplicated";
+
+export type ICommitmentPayloadSimple = Omit<
+	ICommitmentPayload,
+	"status" | "message"
+>;
+
+class Commitment {
+	private readonly payload: ICommitmentPayload;
+
+	constructor(
+		private readonly service: Service,
+		payload: ICommitmentPayloadSimple,
+		private readonly options: ICommitmentOptions,
+	) {
+		this.payload = {
+			message: "Creating...",
+			status: "initializing",
+			...payload,
+		};
+
+		if (this.options.onCreated) {
+			this.options.onCreated(this);
+		}
+	}
+
+	isExpired() {
+		return Date.now() > this.payload.expires_at;
+	}
+
+	isResolved() {
+		return this.getStatus() === "resolved";
+	}
+
+	getStatus(): CommitmentStatus {
+		return this.payload.status;
+	}
+
+	getClickUrl() {
+		return this.payload.click_url;
+	}
+
+	getAmount() {
+		return this.payload.amount;
+	}
+
+	getCurrency() {
+		return this.payload.currency;
+	}
+
+	getReferenceId() {
+		return this.payload.reference_id;
+	}
+
+	getCommitmentId() {
+		return this.payload.commitment_id;
+	}
+
+	markAsCreated() {
+		if (this.payload.status === "created") {
+			return;
+		}
+
+		this.payload.status = "created";
+
+		if (this.options.onCreated) {
+			this.options.onCreated(this);
+		}
+	}
+
+	markAsDuplicated() {
+		if (this.payload.status === "duplicated") {
+			this.stopChecking();
+			return;
+		}
+
+		this.payload.status = "duplicated";
+
+		this.stopChecking();
+		if (this.options.onDuplicated) {
+			this.options.onDuplicated(this);
+		}
+	}
+
+	markAsWaiting() {
+		if (this.payload.status === "waiting") {
+			return;
+		}
+
+		this.payload.status = "waiting";
+
+		if (this.options.onWaiting) {
+			this.options.onWaiting(this);
+		}
+	}
+
+	markAsExpired() {
+		if (this.payload.status === "expired") {
+			this.stopChecking();
+			return;
+		}
+
+		this.payload.status = "expired";
+
+		if (this.options.onExpired) {
+			this.options.onExpired(this);
+		}
+
+		this.stopChecking();
+	}
+
+	markAsResolved() {
+		if (this.payload.status === "resolved") {
+			this.stopChecking();
+			return;
+		}
+
+		this.payload.status = "resolved";
+
+		this.stopChecking();
+
+		if (this.options.onResolved) {
+			this.options.onResolved(this);
+		}
+	}
+
+	private retries = 0;
+	private currentTimer: number | null = null;
+
+	getNextCallTime() {
+		this.retries++;
+		return Math.min(
+			5000,
+			this.payload.retry_ms + this.payload.retry_ms * (this.retries / 10),
+		);
+	}
+
+	startChecking() {
+		if (this.currentCheck) {
+			return;
+		}
+
+		this.currentCheck = this.check()
+			.then((status) => {
+				const nextTime = this.getNextCallTime();
+				if (status === "waiting") {
+					this.currentTimer = setTimeout(
+						() => this.startChecking(),
+						nextTime,
+					) as unknown as number;
+				}
+				return status;
+			})
+			.finally(() => {
+				this.stopChecking(false);
+			});
+	}
+
+	stopChecking(withTimer = true) {
+		this.currentCheck = null;
+		if (this.currentTimer && withTimer) {
+			clearTimeout(this.currentTimer);
+		}
+	}
+
+	private currentCheck: Promise<CommitmentStatus> | null = null;
+
+	async check(): Promise<CommitmentStatus> {
+		if (this.isExpired()) {
+			this.markAsExpired();
+			return this.getStatus();
+		}
+
+		if (this.isResolved()) {
+			this.markAsResolved();
+			return this.getStatus();
+		}
+
+		try {
+			const status = await this.service.checkCommitment(this.getCommitmentId());
+
+			switch (status.status) {
+				case "duplicated": {
+					this.markAsDuplicated();
+					break;
+				}
+				case "expired": {
+					this.markAsExpired();
+					break;
+				}
+				case "resolved": {
+					this.markAsResolved();
+					break;
+				}
+				case "waiting": {
+					this.markAsWaiting();
+					break;
+				}
+			}
+
+			if (this.options.onCheck) {
+				this.options.onCheck(this);
+			}
+		} catch (error) {
+			if (this.options.onError) {
+				this.options.onError(error as Error, this);
+				this.stopChecking();
+			} else {
+				throw error;
+			}
+		}
+
+		return this.getStatus();
+	}
+}
+
+interface IClientOptions {
+	currency: string;
+	retry_ms?: number;
+}
+
+interface INewClientOptions extends IClientOptions, IServiceOptions {}
+
+interface ICommitmentOptions {
+	currency?: string;
+	retry_ms?: number;
+	onCreated?: (commitment: Commitment) => void;
+	onResolved?: (commitment: Commitment) => void;
+	onError?: (error: Error, commitment: Commitment) => void;
+	onExpired?: (commitment: Commitment) => void;
+	onDuplicated?: (commitment: Commitment) => void;
+	onCheck?: (commitment: Commitment) => void;
+	onWaiting?: (commitment: Commitment) => void;
+}
+
+export class Client {
+	static new(opts: INewClientOptions) {
+		return new Client(new Service(opts), opts);
+	}
+
+	constructor(
+		private readonly svc: Service,
+		private readonly options: IClientOptions,
+	) {}
+
+	async createDirect(
+		reference_id: string,
+		amount: number,
+		options: ICommitmentOptions = {},
+	): Promise<Commitment> {
+		const curr = options.currency ?? this.options.currency;
+		const response = await this.svc.createCommitment(
+			reference_id,
+			amount,
+			curr,
+		);
+
+		return new Commitment(
+			this.svc,
+			{
+				commitment_id: response.commitment_id,
+				amount: amount,
+				currency: curr,
+				reference_id: reference_id,
+				expires_at: response.expires_at,
+				click_url: response.click_url,
+				retry_ms: this.options.retry_ms ?? 1000,
+			},
+			options,
+		);
+	}
+
+	create(reference_id: string, amount: number, on: ICallback) {
+		const builder = this.commitmentBuilder()
+			.setAmount(amount)
+			.setCurrency(this.options.currency)
+			.setReference(reference_id);
+
+		if (this.options.retry_ms) {
+			builder.setRetryTime(this.options.retry_ms);
+		}
+
+		builder
+			.onCreated((commitment) => {
+				commitment.startChecking();
+				return on(null, {
+					status: commitment.getStatus(),
+					reference_id,
+					commitment_id: commitment.getCommitmentId(),
+					click_url: commitment.getClickUrl(),
+				});
+			})
+			.onWaiting((commitment) =>
+				on(null, {
+					status: commitment.getStatus(),
+					reference_id,
+					commitment_id: commitment.getCommitmentId(),
+					click_url: commitment.getClickUrl(),
+				}),
+			)
+			.onDuplicated((commitment) =>
+				on(null, {
+					status: commitment.getStatus(),
+					reference_id,
+					commitment_id: commitment.getCommitmentId(),
+					click_url: commitment.getClickUrl(),
+				}),
+			)
+			.onExpired((commitment) =>
+				on(null, {
+					status: commitment.getStatus(),
+					reference_id,
+					commitment_id: commitment.getCommitmentId(),
+					click_url: commitment.getClickUrl(),
+				}),
+			)
+			.onResolved((commitment) =>
+				on(null, {
+					status: commitment.getStatus(),
+					reference_id,
+					commitment_id: commitment.getCommitmentId(),
+					click_url: commitment.getClickUrl(),
+				}),
+			)
+			.onError((error, commitment) => {
+				commitment?.stopChecking();
+				on(error, null);
+			})
+			.exec();
+	}
+
+	commitmentBuilder(): CommitmentObservabileBuilder {
+		return new CommitmentObservabileBuilder(this);
+	}
+}
+
+export interface CallbackPayload {
+	status: CommitmentStatus;
+	reference_id: string;
+	commitment_id: string;
+	click_url: string;
+}
+
+type OnStatusCallback = (error: null, payload: CallbackPayload) => void;
+type OnStatusErrorCallback = (error: Error, payload: null) => void;
+export type ICallback = OnStatusCallback & OnStatusErrorCallback;
+
+class CommitmentObservabileBuilder {
+	private _reference_id: string | undefined;
+	private _amount: number | undefined;
+	private _retry_ms = 1000;
+	private _currency: string | undefined;
+
+	private _onCreatedFn: (commitment: Commitment) => void = () => {};
+	private _onResolvedFn: (commitment: Commitment) => void = () => {};
+	private _onErrorFn: (error: Error, commitment?: Commitment) => void =
+		() => {};
+	private _onExpiredFn: (commitment: Commitment) => void = () => {};
+	private _onDuplicatedFn: (commitment: Commitment) => void = () => {};
+	private _onCheckFn: (commitment: Commitment) => void = () => {};
+	private _onWaitingFn: (commitment: Commitment) => void = () => {};
+
+	constructor(private readonly client: Client) {}
+
+	setRetryTime(retry: number) {
+		this._retry_ms = retry;
+		return this;
+	}
+
+	setAmount(amount: number) {
+		this._amount = amount;
+		return this;
+	}
+
+	setReference(reference: string) {
+		this._reference_id = reference;
+		return this;
+	}
+
+	setCurrency(currency: string) {
+		this._currency = currency;
+		return this;
+	}
+
+	onCreated(cb: (commitment: Commitment) => void) {
+		this._onCreatedFn = cb;
+		return this;
+	}
+
+	onResolved(cb: (commitment: Commitment) => void) {
+		this._onResolvedFn = cb;
+		return this;
+	}
+
+	onExpired(cb: (commitment: Commitment) => void) {
+		this._onExpiredFn = cb;
+		return this;
+	}
+
+	onError(cb: (error: Error, commitment?: Commitment) => void) {
+		this._onErrorFn = cb;
+		return this;
+	}
+
+	onDuplicated(cb: (commitment: Commitment) => void) {
+		this._onDuplicatedFn = cb;
+		return this;
+	}
+
+	onCheck(cb: (commitment: Commitment) => void) {
+		this._onCheckFn = cb;
+		return this;
+	}
+
+	onWaiting(cb: (commitment: Commitment) => void) {
+		this._onWaitingFn = cb;
+		return this;
+	}
+
+	exec() {
+		if (!this._reference_id) {
+			throw new Error("reference_id must be defined");
+		}
+
+		if (!this._amount) {
+			throw new Error("amount must be defined");
+		}
+
+		if (!this._currency) {
+			throw new Error("currency must be defined");
+		}
+
+		this.client
+			.createDirect(this._reference_id, this._amount, {
+				retry_ms: this._retry_ms,
+				currency: this._currency,
+				onCheck: this._onCheckFn,
+				onCreated: this._onCreatedFn,
+				onDuplicated: this._onDuplicatedFn,
+				onError: this._onErrorFn,
+				onExpired: this._onExpiredFn,
+				onWaiting: this._onWaitingFn,
+				onResolved: this._onResolvedFn,
+			})
+			.catch((error) => {
+				if (this._onErrorFn) {
+					this._onErrorFn(error);
+				} else {
+					throw error;
+				}
+			});
+	}
+}
+
+export type { Commitment };