@vyriy/request 0.1.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vyriy contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# @vyriy/request
+
+Shared request utility for Vyriy projects.
+
+## Purpose
+
+This package provides a small wrapper around `fetch` with timeout handling, retry behavior for retryable failures, and basic response parsing for JSON and text payloads.
+
+## Install
+
+With npm:
+
+```bash
+npm install @vyriy/request
+```
+
+With Yarn:
+
+```bash
+yarn add @vyriy/request
+```
+
+## Usage
+
+```ts
+import { request } from '@vyriy/request';
+
+const profile = await request<{ id: string; name: string }>('/api/profile');
+
+const html = await request<string>('https://example.com', null, {
+  retries: 1,
+  timeout: 5000,
+});
+```
+
+## API
+
+- `request(input, init?, options?)` performs a `fetch` call and returns parsed JSON or text.
+- `init` may be `null` when you want to skip request init and pass `options` as the third argument.
+- `options.timeout` sets the per-attempt timeout in milliseconds.
+- `options.retries` controls how many retry attempts are allowed after the initial request.
+- `options.retryDelay` sets the base delay in milliseconds between retry attempts.
+- `options.retryMethods` overrides which HTTP methods are allowed to retry.
+- `options.retryStatuses` overrides which HTTP status codes are considered retryable.

package/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_RETRY_METHODS: string[];
+export declare const DEFAULT_RETRY_STATUSES: number[];

package/constants.js

@@ -0,0 +1,15 @@
+export const DEFAULT_RETRY_METHODS = [
+    'GET',
+    'HEAD',
+    'OPTIONS',
+    'DELETE',
+];
+export const DEFAULT_RETRY_STATUSES = [
+    408,
+    425,
+    429,
+    500,
+    502,
+    503,
+    504,
+];

package/error.d.ts

@@ -0,0 +1,9 @@
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly url: string;
+    constructor(response: Response);
+}
+export declare class TimeoutError extends Error {
+    readonly timeout: number;
+    constructor(timeout: number);
+}

package/error.js

@@ -0,0 +1,19 @@
+export class HttpError extends Error {
+    status;
+    url;
+    constructor(response) {
+        const details = response.statusText ? ` ${response.statusText}` : '';
+        super(`Request failed with status ${response.status}${details}`);
+        this.name = 'HttpError';
+        this.status = response.status;
+        this.url = response.url;
+    }
+}
+export class TimeoutError extends Error {
+    timeout;
+    constructor(timeout) {
+        super(`Request timed out after ${timeout}ms`);
+        this.name = 'TimeoutError';
+        this.timeout = timeout;
+    }
+}

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './request.js';
+export type * from './types.js';

package/index.js

@@ -0,0 +1 @@
+export * from './request.js';

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@vyriy/request",
+  "version": "0.1.9",
+  "description": "Shared request utility for Vyriy projects",
+  "type": "module",
+  "main": "./index.js",
+  "license": "MIT",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./constants": {
+      "types": "./constants.d.ts",
+      "import": "./constants.js",
+      "default": "./constants.js"
+    },
+    "./constants.js": {
+      "types": "./constants.d.ts",
+      "import": "./constants.js",
+      "default": "./constants.js"
+    },
+    "./error": {
+      "types": "./error.d.ts",
+      "import": "./error.js",
+      "default": "./error.js"
+    },
+    "./error.js": {
+      "types": "./error.d.ts",
+      "import": "./error.js",
+      "default": "./error.js"
+    },
+    "./index": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./index.js": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./request": {
+      "types": "./request.d.ts",
+      "import": "./request.js",
+      "default": "./request.js"
+    },
+    "./request.js": {
+      "types": "./request.d.ts",
+      "import": "./request.js",
+      "default": "./request.js"
+    },
+    "./response": {
+      "types": "./response.d.ts",
+      "import": "./response.js",
+      "default": "./response.js"
+    },
+    "./response.js": {
+      "types": "./response.d.ts",
+      "import": "./response.js",
+      "default": "./response.js"
+    },
+    "./retry": {
+      "types": "./retry.d.ts",
+      "import": "./retry.js",
+      "default": "./retry.js"
+    },
+    "./retry.js": {
+      "types": "./retry.d.ts",
+      "import": "./retry.js",
+      "default": "./retry.js"
+    },
+    "./timeout": {
+      "types": "./timeout.d.ts",
+      "import": "./timeout.js",
+      "default": "./timeout.js"
+    },
+    "./timeout.js": {
+      "types": "./timeout.d.ts",
+      "import": "./timeout.js",
+      "default": "./timeout.js"
+    }
+  }
+}

package/request.d.ts

@@ -0,0 +1,2 @@
+import type { Request } from './types.js';
+export declare const request: Request;

package/request.js

@@ -0,0 +1,33 @@
+import { DEFAULT_RETRY_METHODS, DEFAULT_RETRY_STATUSES } from './constants.js';
+import { TimeoutError } from './error.js';
+import { assertSuccessfulResponse, parseResponse } from './response.js';
+import { isRetryableError, isRetryableMethod, wait } from './retry.js';
+import { withTimeoutSignal } from './timeout.js';
+export const request = async (input, init = {}, options = {}) => {
+    const normalizedInit = init ?? {};
+    const { retries = 2, retryDelay = 300, retryMethods = DEFAULT_RETRY_METHODS, retryStatuses = DEFAULT_RETRY_STATUSES, timeout = 25000, } = options;
+    const method = normalizedInit.method?.toUpperCase() ?? 'GET';
+    const run = async (attempt = 0) => {
+        const { cleanup, signal, timeoutSignal } = withTimeoutSignal(timeout, normalizedInit.signal);
+        try {
+            const response = await fetch(input, { ...normalizedInit, signal });
+            assertSuccessfulResponse(response);
+            const result = await parseResponse(response);
+            cleanup();
+            return result;
+        }
+        catch (error) {
+            const canRetry = attempt < retries &&
+                isRetryableMethod(method, retryMethods) &&
+                isRetryableError(error, normalizedInit.signal, retryStatuses);
+            if (!canRetry) {
+                cleanup();
+                throw timeoutSignal.aborted && timeoutSignal.reason instanceof TimeoutError ? timeoutSignal.reason : error;
+            }
+            await wait(retryDelay * (attempt + 1));
+            cleanup();
+            return run(attempt + 1);
+        }
+    };
+    return run();
+};

package/response.d.ts

@@ -0,0 +1,3 @@
+export declare const isJsonResponse: (response: Response) => boolean;
+export declare const parseResponse: <R>(response: Response) => Promise<R>;
+export declare const assertSuccessfulResponse: (response: Response) => void;

package/response.js

@@ -0,0 +1,18 @@
+import { HttpError } from './error.js';
+export const isJsonResponse = (response) => {
+    const contentType = response.headers.get('content-type');
+    return contentType?.includes('application/json') === true || contentType?.includes('+json') === true;
+};
+export const parseResponse = async (response) => {
+    if (isJsonResponse(response)) {
+        const result = await response.json();
+        return result;
+    }
+    const result = await response.text();
+    return result;
+};
+export const assertSuccessfulResponse = (response) => {
+    if (response.type !== 'opaque' && !response.ok) {
+        throw new HttpError(response);
+    }
+};

package/retry.d.ts

@@ -0,0 +1,4 @@
+export declare const isAbortError: (error: unknown) => boolean;
+export declare const isRetryableMethod: (method: string, retryMethods: string[]) => boolean;
+export declare const isRetryableError: (error: unknown, signal: AbortSignal | null | undefined, retryStatuses: number[]) => boolean;
+export declare const wait: (delay: number) => Promise<void>;

package/retry.js

@@ -0,0 +1,23 @@
+import { HttpError, TimeoutError } from './error.js';
+export const isAbortError = (error) => error instanceof DOMException ? error.name === 'AbortError' : false;
+export const isRetryableMethod = (method, retryMethods) => retryMethods.includes(method.toUpperCase());
+export const isRetryableError = (error, signal, retryStatuses) => {
+    if (signal?.aborted) {
+        return false;
+    }
+    if (error instanceof TimeoutError) {
+        return true;
+    }
+    if (error instanceof HttpError) {
+        return retryStatuses.includes(error.status);
+    }
+    return !isAbortError(error);
+};
+export const wait = async (delay) => {
+    if (delay <= 0) {
+        return;
+    }
+    await new Promise((resolve) => {
+        setTimeout(resolve, delay);
+    });
+};

package/timeout.d.ts

@@ -0,0 +1,5 @@
+export declare const withTimeoutSignal: (timeout: number, signal?: AbortSignal | null) => {
+    cleanup: () => void;
+    signal: AbortSignal;
+    timeoutSignal: AbortSignal;
+};

package/timeout.js

@@ -0,0 +1,24 @@
+import { TimeoutError } from './error.js';
+export const withTimeoutSignal = (timeout, signal) => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(new TimeoutError(timeout)), timeout);
+    const abortFromSource = () => {
+        controller.abort(signal?.reason);
+    };
+    if (signal) {
+        if (signal.aborted) {
+            abortFromSource();
+        }
+        else {
+            signal.addEventListener('abort', abortFromSource, { once: true });
+        }
+    }
+    return {
+        cleanup: () => {
+            clearTimeout(timeoutId);
+            signal?.removeEventListener('abort', abortFromSource);
+        },
+        signal: controller.signal,
+        timeoutSignal: controller.signal,
+    };
+};

package/types.d.ts

@@ -0,0 +1,8 @@
+export type Options = {
+    retries?: number;
+    timeout?: number;
+    retryDelay?: number;
+    retryMethods?: string[];
+    retryStatuses?: number[];
+};
+export type Request = <R = Record<string, unknown>>(input: RequestInfo | URL, init?: RequestInit | null, options?: Options) => Promise<R>;