@duckity/js 0.1.1 → 0.1.3

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@duckity/js",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "module": "src/index.ts",
   "collaborators": [
     "Rafael Bradley <rafabradleyrb@gmail.com>"
   ],
   "files": [
+    "src",
     "dist"
   ],
   "exports": {

package/src/index.ts

@@ -0,0 +1,58 @@
+import wrapper from "./processing/wrapper";
+import { post } from "./requests";
+
+/**
+ * Options for getting a Duckity challenge from the API.
+ */
+export interface GetDuckityChallengeOptions {
+  /**
+   * The custom-context threat correlation keys to be sent with the request.
+   */
+  keys?: { [key: string]: string };
+
+  /**
+   * The base URL to the API endpoint. Defaults to `https://quack.duckity.com` if not provided.
+   *
+   * Update this when self-hosting a Duckling. No trailing slash must be included in the URL.
+   */
+  api?: string;
+}
+
+/**
+ * The response from the Duckling API when requesting a challenge.
+ */
+interface ChallengeResponse {
+  /**
+   * The encoded challenge string returned by the Duckling API.
+   */
+  challenge: string;
+}
+
+/**
+ * Fetches, solves, and returns the solution to a Duckity challenge for the given protection
+ * profile ID.
+ *
+ * @param protectionProfileId The ID of the protection profile to get the challenge for.
+ * @param options Optional parameters for the challenge issuance.
+ * @returns The solution to the challenge issued by Duckity.
+ */
+export async function solve(
+  protectionProfileId: string,
+  options?: GetDuckityChallengeOptions,
+): Promise<string> {
+  let response: ChallengeResponse = await post(
+    `${options?.api || "https://quack.duckity.com"}/v1/challenge`,
+    {
+      body: {
+        id: protectionProfileId,
+        keys: options?.keys || {},
+      },
+    },
+  );
+
+  let solution = await wrapper.solve(response.challenge);
+
+  return solution;
+}
+
+export default { solve }

package/src/processing/worker.ts

@@ -0,0 +1,16 @@
+import * as Comlink from "comlink";
+import { process } from "@duckity/wasm";
+
+/**
+ * Expose the `process` function from the WASM module to the main thread via Comlink.
+ *
+ * This allows the main thread to call the `process` function in the worker thread, which will
+ * handle the processing of the challenges without blocking the main thread.
+ */
+const api = {
+  async process(challenge: string) {
+    return process(challenge);
+  },
+};
+
+Comlink.expose(api);

package/src/processing/wrapper.ts

@@ -0,0 +1,18 @@
+import wasm from "@duckity/wasm/worker.wasm";
+import * as Comlink from "comlink";
+
+/**
+ * Web Worker that handles the processing of the challenges.
+ */
+const worker = new Worker(wasm, {
+  type: "module",
+});
+
+/**
+ * Wrap the worker with Comlink to allow for easy communication between the main thread and the
+ * worker thread. The worker exposes a `solve` function that takes a challenge string and returns a
+ * promise that resolves to the solution string.
+ */
+export default Comlink.wrap<{
+  solve(challenge: string): Promise<string>;
+}>(worker);

package/src/requests.ts

@@ -0,0 +1,74 @@
+/**
+ * Error schema for API responses. This is used to extract error messages from failed requests.
+ */
+interface ErrorMessage {
+  title: string;
+  message: string;
+}
+
+/**
+ * Wrapper function for making HTTP requests using the Fetch API. It handles JSON parsing and error
+ * handling, throwing an error with a message extracted from the response if the request fails.
+ *
+ * @param url The URL to make the request to.
+ * @param options Extra options to pass to the Fetch API, such as method, headers, and body.
+ * @returns The parsed JSON response from the server if the request is successful.
+ */
+async function request<T>(url: string, options?: RequestInit): Promise<T> {
+  const response = await fetch(url, options);
+
+  let data;
+
+  try {
+    data = await response.json();
+  } catch {
+    data = await response.text();
+  }
+
+  if (!response.ok) {
+    throw new Error(
+      (data as ErrorMessage | undefined)?.message || "Request failed",
+    );
+  }
+
+  return data as T;
+}
+
+/**
+ * Makes a GET request to the specified URL and returns the parsed JSON response.
+ *
+ * If the request fails, it throws an error with a message extracted from the response if
+ * available, or a generic message if not.
+ *
+ * @param url The URL to make the request to.
+ * @param options Extra options to pass to the Fetch API, such as headers and body.
+ * @returns The parsed JSON response from the server if the request is successful.
+ */
+export function get<T>(url: string, options?: RequestInit): Promise<T> {
+  return request(url, {
+    method: "GET",
+    ...options,
+  });
+}
+
+/**
+ * Makes a POST request to the specified URL and returns the parsed JSON response.
+ *
+ * If the request fails, it throws an error with a message extracted from the response if
+ * available, or a generic message if not.
+ *
+ * @param url The URL to make the request to.
+ * @param options Extra options to pass to the Fetch API, such as headers and body.
+ * @returns The parsed JSON response from the server if the request is successful.
+ */
+export function post<T>(url: string, options?: Omit<RequestInit, "body"> & { body: any }): Promise<T> {
+  return request(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers,
+    },
+    body: options?.body ? JSON.stringify(options.body) : undefined,
+    ...options,
+  });
+}