@wdft/micropayments-sdk 0.0.1 → 0.0.2

package/src/index.test.ts

@@ -0,0 +1,66 @@
+import { it } from "vitest";
+import { getViaMsg } from "./index.js";
+import { mockFetch } from "./test_utils/mock_fetcher.js";
+
+it("getViaMsg", async () => {
+	const mock = mockFetch();
+
+	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",
+		});
+
+		getViaMsg(
+			{
+				amount: 10,
+				reference_id: "ref",
+				currency: "PLN",
+				tenant_id: "my-tenant",
+				endpoint: "http://localhost:8787",
+				fetcher: mock.fetcher.bind(mock),
+				retry_ms: 100,
+			},
+			(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);
+				}
+			},
+		);
+	});
+});

package/src/index.ts

@@ -0,0 +1,26 @@
+import type { ICallback } from "./client.js";
+import type { Fetcher } from "./service.js";
+
+import { Client } from "./client.js";
+
+export interface IGetViaMsgInit {
+	reference_id: string;
+	amount: number;
+	currency: "PLN" | "EUR" | "GBP" | "USD" | "CHF" | string;
+	tenant_id: string;
+	endpoint?: string;
+	fetcher?: Fetcher;
+	retry_ms?: number;
+}
+
+export function getViaMsg(init: IGetViaMsgInit, callback: ICallback) {
+	const client = Client.new({
+		currency: init.currency,
+		endpoint: init.endpoint ?? "https://api.micropayments.wdft.ovh/",
+		tenant_id: init.tenant_id,
+		fetcher: init.fetcher ?? fetch,
+		retry_ms: init.retry_ms ?? 1000,
+	});
+
+	client.create(init.reference_id, init.amount, callback);
+}

package/src/mock_fetcher.test.ts

@@ -0,0 +1,18 @@
+import { it } from "vitest";
+import { expect } from "vitest";
+import { mockFetch } from "./test_utils/mock_fetcher.js";
+
+it("mocking works", async () => {
+	const mock = mockFetch();
+
+	mock.next(200, {
+		test: 123,
+	});
+
+	const response = await mock.fetcher();
+
+	expect(response.status).toBe(200);
+	expect(await response.json()).toMatchObject({
+		test: 123,
+	});
+});

package/src/service.test.ts

@@ -0,0 +1,53 @@
+import { it } from "vitest";
+import { expect } from "vitest";
+import { Service } from "./service.js";
+import { mockFetch } from "./test_utils/mock_fetcher.js";
+
+it("service.createCommitment - 200 - resolved good data", async () => {
+	const mock = mockFetch();
+
+	const my = new Service({
+		endpoint: "http://localhost:8787",
+		tenant_id: "testing-dev-tenant",
+		fetcher: () => mock.fetcher(),
+	});
+
+	mock.next(200, {
+		click_url: "mock_click_url",
+		incoming_message_device: "mock_num",
+		expires_at: Date.now() + 30_000,
+		commitment_id: "sample_commitment_id",
+	});
+
+	const commitment = await my.createCommitment("sample-content-id", 10, "PLN");
+
+	expect(commitment).toMatchObject({
+		click_url: "mock_click_url",
+		incoming_message_device: "mock_num",
+		commitment_id: "sample_commitment_id",
+	});
+});
+
+it("service.checkCommitment - 200 - resolved good data", async () => {
+	const mock = mockFetch();
+
+	const my = new Service({
+		endpoint: "http://localhost:8787",
+		tenant_id: "testing-dev-tenant",
+		fetcher: () => mock.fetcher(),
+	});
+
+	mock.next(200, {
+		message: "waiting for sms",
+		status: "waiting",
+		commitment_id: "sample_commitment_id",
+	});
+
+	const status = await my.checkCommitment("sample_commitment_id");
+
+	expect(status).toMatchObject({
+		message: "waiting for sms",
+		status: "waiting",
+		commitment_id: "sample_commitment_id",
+	});
+});

package/src/service.ts

@@ -0,0 +1,171 @@
+interface CustomResponse {
+	status: number;
+	error: boolean;
+}
+
+interface SuccessResponse<T> extends CustomResponse {
+	error: false;
+	message: null;
+	data: T;
+}
+
+interface ErrorResponse extends CustomResponse {
+	error: true;
+	message: string;
+	data: null;
+}
+
+interface ICommitment {
+	click_url: string;
+	incoming_message_device: string;
+	expires_at: number;
+	commitment_id: string;
+}
+
+type ResponseDTO<T> = SuccessResponse<T> | ErrorResponse;
+
+async function parseResponse<T = unknown>(response: Response): Promise<T> {
+	if (response.headers.get("Content-Type")?.includes("application/json")) {
+		return (await response.json()) as T;
+	}
+	return (await response.text()) as T;
+}
+
+export type Fetcher = (
+	input: RequestInfo | URL,
+	init?: RequestInit,
+) => Promise<Response>;
+
+async function request<T = unknown>(
+	path: string,
+	req: RequestInit,
+	fetcher: Fetcher,
+): Promise<ResponseDTO<T | null>> {
+	try {
+		const response = await fetcher(new Request(path, req));
+		if (response.ok) {
+			return {
+				status: response.status,
+				error: false,
+				data: (await parseResponse(response)) as T,
+			} as ResponseDTO<T>;
+		}
+		const errorPayload = await parseResponse(response);
+		return {
+			status: response.status,
+			error:
+				errorPayload &&
+				typeof errorPayload === "object" &&
+				"error" in errorPayload
+					? errorPayload.error
+					: true,
+			message:
+				errorPayload &&
+				typeof errorPayload === "object" &&
+				"message" in errorPayload
+					? errorPayload.message
+					: response.statusText,
+			data: null,
+		} as ResponseDTO<T>;
+	} catch (error) {
+		return {
+			status: 500,
+			error: true,
+			message: error instanceof Error ? error.message : `${error}`,
+			data: null,
+		} as ErrorResponse;
+	}
+}
+
+function buildUrl(endpoint: string, path: string) {
+	const validEndpoint = endpoint.endsWith("/")
+		? endpoint.substring(0, endpoint.length - 1)
+		: endpoint;
+	const validPath = path.startsWith("/") ? path : "/".concat(path);
+	return validEndpoint + validPath;
+}
+
+export interface IServiceOptions {
+	tenant_id: string;
+	endpoint: string;
+	fetcher?: Fetcher;
+}
+
+export interface ICommitmentStatus {
+	commitment_id: string;
+	status: string;
+	message: string;
+}
+
+export class Service {
+	private readonly fetcher: Fetcher;
+
+	constructor(private readonly options: IServiceOptions) {
+		if (!options.fetcher && !globalThis.fetch) {
+			throw new Error(
+				'fetch is not available in environment, pass "fetcher" option with satisfies fetch interface',
+			);
+		}
+
+		this.fetcher = this.options.fetcher ?? globalThis.fetch;
+	}
+
+	async createCommitment(
+		reference_id: string,
+		amount: number,
+		currency: string,
+	): Promise<ICommitment> {
+		const response = await request<ICommitment>(
+			buildUrl(this.options.endpoint, "/commitment"),
+			{
+				method: "POST",
+				body: JSON.stringify({
+					tenant_id: this.options.tenant_id,
+					reference_id,
+					currency: currency,
+					amount,
+				}),
+			},
+			this.fetcher,
+		);
+
+		if (response.error) {
+			throw new Error(response.message);
+		}
+
+		if (!response.data) {
+			throw new Error("Bad response");
+		}
+
+		return response.data;
+	}
+
+	async checkCommitment(commitment: string): Promise<ICommitmentStatus> {
+		const response = await request<ICommitmentStatus>(
+			buildUrl(this.options.endpoint, `/commitment/${commitment}`),
+			{
+				method: "GET",
+			},
+			this.fetcher,
+		);
+
+		switch (response.status) {
+			case 410:
+				return {
+					commitment_id: commitment,
+					message: response.message || "Expired",
+					status: "expired",
+				};
+		}
+
+		if (response.error) {
+			throw new Error(response.message);
+		}
+
+		if (!response.data) {
+			throw new Error("Bad response");
+		}
+
+		return response.data;
+	}
+}

package/src/test_utils/mock_fetcher.ts

@@ -0,0 +1,24 @@
+export const mockFetch = () => ({
+	__responses: [] as Response[],
+	next(status: number, body: null | string | object, headers: object = {}) {
+		this.__responses.push(
+			new Response(typeof body === "object" ? JSON.stringify(body) : body, {
+				status,
+				headers: {
+					"Content-Type":
+						typeof body === "object" ? "application/json" : "plain/text",
+					...headers,
+				},
+			}),
+		);
+	},
+	async fetcher() {
+		const next = this.__responses.shift();
+
+		if (!next) {
+			throw new Error("not found mock item");
+		}
+
+		return next;
+	},
+});