Merge pull request #26 from openfetch-js/dev

Enhance supply chain metadata and improve secure defaults

Author: hamdymohamedak

dist/domain/error.d.ts

@@ -55,4 +55,8 @@ export declare class OpenFetchError<T = unknown> extends Error {
     toJSON(): OpenFetchErrorShape;
 }
 export declare function isOpenFetchError(err: unknown): err is OpenFetchError;
+/** `OpenFetchError` with `code === "ERR_BAD_RESPONSE"` and a populated `response`. */
+export declare function isHTTPError(err: unknown): err is OpenFetchError;
+/** Per-attempt fetch timeout (`ERR_TIMEOUT`) or retry budget exceeded (`ERR_RETRY_TIMEOUT`). */
+export declare function isTimeoutError(err: unknown): err is OpenFetchError;
 //# sourceMappingURL=error.d.ts.map

dist/domain/error.d.ts.map

@@ -65,3 +65,14 @@ export class OpenFetchError extends Error {
 export function isOpenFetchError(err) {
     return err instanceof OpenFetchError;
 }
+/** `OpenFetchError` with `code === "ERR_BAD_RESPONSE"` and a populated `response`. */
+export function isHTTPError(err) {
+    return (err instanceof OpenFetchError &&
+        err.code === "ERR_BAD_RESPONSE" &&
+        err.response != null);
+}
+/** Per-attempt fetch timeout (`ERR_TIMEOUT`) or retry budget exceeded (`ERR_RETRY_TIMEOUT`). */
+export function isTimeoutError(err) {
+    return (err instanceof OpenFetchError &&
+        (err.code === "ERR_TIMEOUT" || err.code === "ERR_RETRY_TIMEOUT"));
+}

dist/domain/error.js

@@ -0,0 +1,10 @@
+/**
+ * Throw from `retry.onAfterResponse` / hooks `onAfterResponse` (when wired through retry)
+ * to force another fetch attempt (same semantics as Ky’s `ForceRetryError`).
+ */
+export declare class OpenFetchForceRetry extends Error {
+    name: "OpenFetchForceRetry";
+    constructor(message?: string);
+}
+export declare function isOpenFetchForceRetry(err: unknown): err is OpenFetchForceRetry;
+//# sourceMappingURL=forceRetry.d.ts.map

dist/domain/forceRetry.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Throw from `retry.onAfterResponse` / hooks `onAfterResponse` (when wired through retry)
+ * to force another fetch attempt (same semantics as Ky’s `ForceRetryError`).
+ */
+export class OpenFetchForceRetry extends Error {
+    name = "OpenFetchForceRetry";
+    constructor(message = "Force retry") {
+        super(message);
+    }
+}
+export function isOpenFetchForceRetry(err) {
+    return err instanceof OpenFetchForceRetry;
+}

dist/domain/forceRetry.d.ts.map

@@ -0,0 +1,12 @@
+import type { StandardSchemaV1Issue } from "./standardSchema.js";
+/**
+ * Thrown when {@link OpenFetchConfig.jsonSchema} / fluent `.json(schema)` validation fails.
+ * Does not extend {@link OpenFetchError} — the HTTP round-trip succeeded; the schema rejected the payload.
+ */
+export declare class SchemaValidationError extends Error {
+    name: "SchemaValidationError";
+    readonly issues: readonly StandardSchemaV1Issue[];
+    constructor(issues: readonly StandardSchemaV1Issue[]);
+}
+export declare function isSchemaValidationError(err: unknown): err is SchemaValidationError;
+//# sourceMappingURL=schemaValidationError.d.ts.map

dist/domain/forceRetry.js

@@ -0,0 +1,15 @@
+/**
+ * Thrown when {@link OpenFetchConfig.jsonSchema} / fluent `.json(schema)` validation fails.
+ * Does not extend {@link OpenFetchError} — the HTTP round-trip succeeded; the schema rejected the payload.
+ */
+export class SchemaValidationError extends Error {
+    name = "SchemaValidationError";
+    issues;
+    constructor(issues) {
+        super("Response schema validation failed");
+        this.issues = issues;
+    }
+}
+export function isSchemaValidationError(err) {
+    return err instanceof SchemaValidationError;
+}

dist/domain/schemaValidationError.d.ts

@@ -0,0 +1,35 @@
+/** [Standard Schema](https://github.com/standard-schema/standard-schema) v1 surface (types only). */
+export type StandardSchemaV1Issue = {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }> | undefined;
+};
+export type StandardSchemaV1SuccessResult<OutputType> = {
+    readonly value: OutputType;
+    readonly issues?: undefined;
+};
+export type StandardSchemaV1FailureResult = {
+    readonly issues: readonly StandardSchemaV1Issue[];
+    readonly value?: undefined;
+};
+export type StandardSchemaV1Result<OutputType> = StandardSchemaV1SuccessResult<OutputType> | StandardSchemaV1FailureResult;
+export type StandardSchemaV1Types<InputType, OutputType> = {
+    readonly input: InputType;
+    readonly output: OutputType;
+};
+export type StandardSchemaV1Options = {
+    readonly libraryOptions?: Readonly<Record<string, unknown>> | undefined;
+};
+export type StandardSchemaV1<InputType = unknown, OutputType = InputType> = {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown, options?: StandardSchemaV1Options) => StandardSchemaV1Result<OutputType> | Promise<StandardSchemaV1Result<OutputType>>;
+        readonly types?: StandardSchemaV1Types<InputType, OutputType> | undefined;
+    };
+};
+export type StandardSchemaV1InferOutput<Schema extends StandardSchemaV1> = Schema["~standard"] extends {
+    readonly types: StandardSchemaV1Types<unknown, infer OutputType>;
+} ? OutputType : Extract<Awaited<ReturnType<Schema["~standard"]["validate"]>>, StandardSchemaV1SuccessResult<unknown>> extends StandardSchemaV1SuccessResult<infer OutputType> ? OutputType : unknown;
+//# sourceMappingURL=standardSchema.d.ts.map