http-kit - npm Package Compare versions

Comparing version 0.2.1 to 0.2.2

dist/exception.d.ts

@@ -1,8 +0,3 @@
-export declare abstract class Err {
+export declare class HttpError {
     readonly message: string;
-    abstract readonly _tag: string;
-    constructor(message: string);
-}
-export declare class HttpError extends Err {
-    readonly message: string;
     readonly originalError?: unknown;
@@ -9,0 +4,0 @@ readonly _tag = "HttpError";

dist/exception.js

@@ -1,13 +0,12 @@
-export class Err {
-    constructor(message) {
-        this.message = message;
-    }
-}
-export class HttpError extends Err {
+// export abstract class Err {
+//   abstract readonly _tag: string;
+//   constructor(readonly message: string) {}
+// }
+export class HttpError {
     constructor(message, originalError) {
-        super(message);
         this.message = message;
         this.originalError = originalError;
         this._tag = "HttpError";
+        // super(message);
     }
 }

dist/executor/mod.d.ts

 import * as E from "@effect/io/Effect";
-import { Interpreter } from "../interpreter.js";
+import * as L from "@effect/io/Layer";
+import { Adapter } from "../interpreter.js";
 import { Req } from "../types.js";
 import { Interceptor } from "./types.js";
-export declare function execute(request: Req, interceptors?: Array<Interceptor>): E.Effect<Interpreter, import("../exception.js").Err, Response>;
-export declare function provide(interpreter: Interpreter, ...interceptors: Array<Interceptor>): <R, E, A>(fx: E.Effect<Interpreter | R, E, A>) => E.Effect<Exclude<R, Interpreter>, E, A>;
+export declare function execute(request: Req, interceptors?: Array<Interceptor>): E.Effect<Adapter, import("../exception.js").HttpError, Response>;
+export declare function makeLayer(adapter: Adapter, ...interceptors: Array<Interceptor>): L.Layer<never, never, Adapter>;
+export declare function provide(adapter: Adapter, ...interceptors: Array<Interceptor>): <R, E, A>(self: E.Effect<R, E, A>) => E.Effect<Exclude<R, Adapter>, E, A>;

dist/executor/mod.js

 import { pipe } from "@effect/data/Function";
 import * as E from "@effect/io/Effect";
-import { Interpreter } from "../interpreter.js";
+import * as L from "@effect/io/Layer";
+import { Adapter } from "../interpreter.js";
 export function execute(request, interceptors) {
@@ -8,3 +9,3 @@ return E.gen(function* (s) {
         let request_response = request;
-        const interpreter = yield* s(Interpreter);
+        const interpreter = yield* s(Adapter);
         if (interceptors) {
@@ -42,8 +43,9 @@ for (const interceptor of interceptors) {
 }
-export function provide(interpreter, ...interceptors) {
-    return (fx) => {
-        return pipe(fx, E.provideService(Interpreter, Object.assign(Object.assign({}, interpreter), { execute(request) {
-                return pipe(execute(request, interceptors), E.provideService(Interpreter, interpreter));
-            } })));
-    };
+export function makeLayer(adapter, ...interceptors) {
+    return L.succeed(Adapter, Object.assign(Object.assign({}, adapter), { execute(request) {
+            return pipe(execute(request, interceptors), E.provideService(Adapter, adapter));
+        } }));
 }
+export function provide(adapter, ...interceptors) {
+    return E.provideSomeLayer(makeLayer(adapter, ...interceptors));
+}

dist/executor/types.d.ts

 import * as Effect from "@effect/io/Effect";
 import type { Req, Res } from "../types.js";
-import type { Interpreter } from "../interpreter.js";
-import { Err } from "../exception.js";
+import type { Adapter } from "../interpreter.js";
+import { HttpError } from "../exception.js";
 import { HttpRequest } from "../request/Request.js";
 export interface RequestInterceptor {
-    (req: HttpRequest): Effect.Effect<Interpreter, Err, Req | Res>;
+    (req: HttpRequest): Effect.Effect<Adapter, HttpError, Req | Res>;
 }
 export interface ResponseInterceptor {
-    (res: Res, req: HttpRequest): Effect.Effect<Interpreter, Err, Res>;
+    (res: Res, req: HttpRequest): Effect.Effect<Adapter, HttpError, Res>;
 }
@@ -12,0 +12,0 @@ export type Interceptor = {

dist/fetch/mod.d.ts

@@ -1,2 +0,2 @@
-import { Interpreter } from "../interpreter.js";
-export declare const adapter: Interpreter;
+import { Adapter } from "../interpreter.js";
+export declare const adapter: Adapter;

dist/index.d.ts

@@ -5,3 +5,4 @@ export * from "./function.js";
 export * from "./request/mod.js";
+export * from "./response.js";
 export type * from "./types.js";
 export type * from "./executor/types.js";

dist/index.js

@@ -5,1 +5,2 @@ export * from "./function.js";
 export * from "./request/mod.js";
+export * from "./response.js";

dist/interpreter.d.ts

 import * as Ctx from "@effect/data/Context";
 import * as Effect from "@effect/io/Effect";
 import { Res, Req } from "./types.js";
-import { Err } from "./exception.js";
-export type Executor = (request: Req) => Effect.Effect<never, Err, Res>;
-export interface Interpreter {
+import { HttpError } from "./exception.js";
+export type Executor = (request: Req) => Effect.Effect<never, HttpError, Res>;
+export interface Adapter {
     execute: Executor;
@@ -11,2 +11,2 @@ isResponse: (response: unknown) => response is Response;
 }
-export declare const Interpreter: Ctx.Tag<Interpreter, Interpreter>;
+export declare const Adapter: Ctx.Tag<Adapter, Adapter>;

dist/interpreter.js

 import * as Ctx from "@effect/data/Context";
-export const Interpreter = Ctx.Tag();
+export const Adapter = Ctx.Tag();

dist/request/mod.js

 import * as Effect from "@effect/io/Effect";
 import { isBody } from "../body/util.js";
-import { Interpreter } from "../interpreter.js";
+import { Adapter } from "../interpreter.js";
 import { HttpRequest } from "./Request.js";
 export function request(input, init = {}) {
-    return Effect.flatMap(Interpreter, (interpreter) => {
+    return Effect.flatMap(Adapter, (adapter) => {
         let url = input instanceof HttpRequest
@@ -18,3 +18,3 @@ ? input.url
             const body = init_.body;
-            const headers = interpreter.newHeaders(init_.headers);
+            const headers = adapter.newHeaders(init_.headers);
             for (const key in body.headers) {
@@ -29,3 +29,3 @@ if (Object.prototype.hasOwnProperty.call(body.headers, key)) {
         }
-        return interpreter.execute(new HttpRequest(url, init_));
+        return adapter.execute(new HttpRequest(url, init_));
     });
@@ -32,0 +32,0 @@ }

dist/response.d.ts

 import * as Predicate from "@effect/data/Predicate";
 import * as Effect from "@effect/io/Effect";
-import { Err } from "./exception.js";
+import { HttpError } from "./exception.js";
 import { Res } from "./types.js";
-export declare class JsonParseError extends Err {
+export declare class JsonParseError {
     readonly response: Response;
@@ -11,3 +11,3 @@ readonly message: string;
 }
-export declare class StatusError extends Err {
+export declare class StatusError {
     readonly response: Response;
@@ -19,3 +19,6 @@ readonly message: string;
 export declare function toJson<T>(): <R, E, A extends Response>(fx: Effect.Effect<R, E, A>) => Effect.Effect<R, JsonParseError | E, T>;
+export declare const toText: () => <R, E, A extends Response>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, HttpError | E, string>;
+export declare const toArrayBuffer: () => <R, E, A extends Response>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, HttpError | E, ArrayBuffer>;
+export declare const toBlob: () => <R, E, A extends Response>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, HttpError | E, Blob>;
 export declare function filterStatus<A extends Res>(func: Predicate.Predicate<number>): <R, E>(fx: Effect.Effect<R, E, A>) => Effect.Effect<R, StatusError | E, A>;
 export declare function filterStatusOk(): <R, E>(fx: Effect.Effect<R, E, Response>) => Effect.Effect<R, StatusError | E, Response>;

dist/response.js

 import { pipe } from "@effect/data/Function";
 import * as Effect from "@effect/io/Effect";
-import { Err } from "./exception.js";
-export class JsonParseError extends Err {
+import { HttpError } from "./exception.js";
+export class JsonParseError {
     constructor(response, message) {
-        super(message);
         this.response = response;
         this.message = message;
         this._tag = "JsonParseError";
+        // super(message);
     }
 }
-export class StatusError extends Err {
+export class StatusError {
     constructor(response, message) {
-        super(message);
         this.response = response;
         this.message = message;
         this._tag = "StatusError";
+        // super(message);
     }
@@ -30,2 +30,13 @@ }
 }
+function to(fn) {
+    return () => (effect) => {
+        return pipe(effect, Effect.flatMap((res) => Effect.tryPromise({
+            try: () => fn(res),
+            catch: (e) => new HttpError("Decode error", e),
+        })));
+    };
+}
+export const toText = to((res) => res.text());
+export const toArrayBuffer = to((res) => res.arrayBuffer());
+export const toBlob = to((res) => res.blob());
 export function filterStatus(func) {
@@ -32,0 +43,0 @@ return (fx) => {

dist/types.d.ts

 import type * as Effect from "@effect/io/Effect";
-import { Interpreter } from "./interpreter.js";
-import { Err } from "./exception.js";
+import { HttpError } from "./exception.js";
+import { Adapter } from "./interpreter.js";
 import { HttpRequest } from "./request/Request.js";
 export type Req = HttpRequest;
 export type Res = Response;
-export type RequestEffectT<E = any, A = any> = Effect.Effect<Interpreter, E, A>;
-export type RequestEffect = RequestEffectT<Err, Response>;
+export type RequestEffectT<E = any, A = any> = Effect.Effect<Adapter, E, A>;
+export type RequestEffect = RequestEffectT<HttpError, Response>;

package.json

 {
   "name": "http-kit",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
@@ -5,0 +5,0 @@ "description": "Platform agnostic fetch kit for the Effect package",

No alert changes

Improved metrics

Total package byte prevSize

19148

4.98%

Lines of code

396

3.66%

No dependency changes