@wdft/micropayments-sdk 0.0.4 → 0.0.6

package/src/index.test.ts

@@ -3,64 +3,64 @@ import { getViaMsg } from "./index.js";
 import { mockFetch } from "./test_utils/mock_fetcher.js";
 
 it("getViaMsg", async () => {
-	const mock = mockFetch();
+  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",
-		});
+  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: "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",
-		});
+    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;
-				}
+    getViaMsg(
+      {
+        amount: 10,
+        reference_id: "ref",
+        currency: "PLN",
+        tenant_id: "testing_dev_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;
+        const { status } = payload;
 
-				switch (status) {
-					case "waiting":
-					case "created":
-					case "duplicated":
-					case "expired":
-						console.log(payload);
-						break;
-					case "resolved":
-						resolve(status);
-				}
-			},
-		);
-	});
+        switch (status) {
+          case "waiting":
+          case "created":
+          case "duplicated":
+          case "expired":
+            console.log(payload);
+            break;
+          case "resolved":
+            resolve(status);
+        }
+      },
+    );
+  });
 });

package/src/index.ts

@@ -4,23 +4,23 @@ 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;
+  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,
-	});
+  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);
+  client.create(init.reference_id, init.amount, callback);
 }

package/src/mock_fetcher.test.ts

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

package/src/service.test.ts

@@ -4,50 +4,53 @@ 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",
-	});
+  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",
-	});
+  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",
+  }, {
+    'Retry-After': '5'
+  });
+
+  const status = await my.checkCommitment("sample_commitment_id");
+
+  expect(status).toMatchObject({
+    message: "waiting for sms",
+    status: "waiting",
+    retry_after: 5000,
+    commitment_id: "sample_commitment_id",
+  });
 });

package/src/service.ts

@@ -1,177 +1,215 @@
 interface CustomResponse {
-	status: number;
-	error: boolean;
+  status: number;
+  error: boolean;
 }
 
 interface SuccessResponse<T> extends CustomResponse {
-	error: false;
-	message: null;
-	data: T;
+  error: false;
+  retry_after: number;
+  message: null;
+  data: T;
 }
 
 interface ErrorResponse extends CustomResponse {
-	error: true;
-	message: string;
-	data: null;
+  error: true;
+  message: string;
+  data: null;
 }
 
 interface ICommitment {
-	click_url: string;
-	incoming_message_device: string;
-	expires_at: number;
-	commitment_id: string;
+  click_url: string;
+  incoming_message_device: string;
+  expires_at: number;
+  commitment_id: string;
+}
+
+export interface ICommitmentMetadata {
+  title: string;
+  url: 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;
+  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,
+  input: RequestInfo | URL,
+  init?: RequestInit,
 ) => Promise<Response>;
 
+function randomBetween(min: number, max: number) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function parseRetryAfter(retryAfter: string | undefined | null | number): number {
+  let retryAfterParsed = 0;
+
+  if (!retryAfter) {
+    return retryAfterParsed;
+  }
+
+  const retryAfterSeconds = typeof retryAfter === 'number' ? retryAfter : parseInt(retryAfter, 10);
+
+  if (!isNaN(retryAfterSeconds) && isFinite(retryAfterSeconds)) {
+    retryAfterParsed = retryAfterSeconds * 1000;
+  } else {
+    retryAfterParsed = 0;
+  }
+
+  return retryAfterParsed;
+}
+
 async function request<T = unknown>(
-	path: string,
-	req: RequestInit,
-	fetcher: Fetcher,
+  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;
-	}
+  try {
+    const response = await fetcher(new Request(path, req));
+    if (response.ok) {
+      const retryAfter = response.headers.get('Retry-After');
+      return {
+        status: response.status,
+        error: false,
+        retry_after: parseRetryAfter(response.headers.get('Retry-After')),
+        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,
+      retry_after: parseRetryAfter(response.headers.get('Retry-After')),
+      data: null,
+    } as ResponseDTO<T>;
+  } catch (error) {
+    return {
+      status: 500,
+      error: true,
+      message: error instanceof Error ? error.message : `${error}`,
+      retry_after: randomBetween(10_000, 30_000),
+      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;
+  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;
+  tenant_id: string;
+  endpoint: string;
+  fetcher?: Fetcher;
 }
 
 export interface ICommitmentStatus {
-	commitment_id: string;
-	status: string;
-	message: string;
+  commitment_id: string;
+  status: string;
+  message: string;
+  retry_after?: number;
 }
 
 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 402:
-				return {
-					commitment_id: commitment,
-					message: response.message || "Payment required - you are over limit",
-					status: "rejected",
-				};
-			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;
-	}
+  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,
+    metadata?: ICommitmentMetadata
+  ): 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,
+          metadata: metadata ?? {title: "", url: ""},
+          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 402:
+        return {
+          commitment_id: commitment,
+          message: response.message || "Payment required - you are over limit",
+          status: "rejected",
+        };
+      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 {
+      commitment_id: response.data.commitment_id,
+      message: response.data.message,
+      status: response.data.status,
+      retry_after: response.retry_after
+    };
+  }
 }