nestjs-httpf 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2022 Kamil Mysliwiec
+
+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,324 @@
+# nestjs-httpf
+
+> Functional-style HTTP client for NestJS
+
+[![npm version](https://img.shields.io/npm/v/nestjs-httpf.svg)](https://www.npmjs.com/package/nestjs-httpf)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- **Functional Style**: Handle complex API requests safely and declaratively
+- **Language-Friendly**: Promise-based instead of Observable, enabling direct use of async/await
+- **AsyncIterable-Based**: Leverages FxTS's [AsyncIterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols) for efficient data processing through lazy evaluation and function composition
+- **Retry Support**: Automatically retry failed requests
+- **Error Handling**: Use `catchError` to treat errors as values instead of try-catch
+- **FxTS Integration**: Access various helper functions from the [FxTS](https://fxts.dev/) library
+- **Got-Based**: Uses the powerful and reliable [Got](https://github.com/sindresorhus/got) HTTP client
+
+## Background
+
+NestJS's built-in HTTP module provides an excellent way to safely handle complex API processing by applying RxJS's reactive programming. However, since it returns RxJS Observable objects, you need to extract values through operators like `firstValueFrom`, which can be cumbersome.
+
+**nestjs-httpf** solves this inconvenience and allows you to handle asynchronous operations in a more language-friendly way:
+
+- ✅ Directly work with Promises, enabling `await` usage
+- ✅ Write asynchronous processing declaratively with functional style
+- ✅ Compose functions with the FxTS library for various features
+
+## Installation
+
+```bash
+npm install nestjs-httpf @fxts/core
+```
+
+or
+
+```bash
+yarn add nestjs-httpf @fxts/core
+```
+
+or
+
+```bash
+pnpm add nestjs-httpf @fxts/core
+```
+
+## Quick Start
+
+### 1. Register the Module
+
+```typescript
+import { Module } from '@nestjs/common';
+import { HttpfModule } from 'nestjs-httpf';
+
+@Module({
+  imports: [HttpfModule],
+})
+export class AppModule {}
+```
+
+### 2. Use in a Service
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { HttpfService } from 'nestjs-httpf';
+
+@Injectable()
+export class UserService {
+  constructor(private readonly httpfService: HttpfService) {}
+
+  async getUser(id: string) {
+    const user = await this.httpfService
+      .get<User>(`https://api.example.com/users/${id}`)
+      .map((response) => response.body)
+      .head();
+
+    return user;
+  }
+}
+```
+
+## Usage Examples
+
+### Basic HTTP Requests
+
+```typescript
+// GET request
+const data = await this.httpfService
+  .get<{ message: string }>('https://api.example.com/hello')
+  .map((response) => response.body)
+  .head();
+
+// POST request
+const result = await this.httpfService
+  .post<{ id: string }>('https://api.example.com/users', {
+    json: { name: 'John', email: 'john@example.com' },
+  })
+  .map((response) => response.body)
+  .head();
+
+// PUT request
+await this.httpfService
+  .put('https://api.example.com/users/123', {
+    json: { name: 'Jane' },
+  })
+  .head();
+
+// PATCH request
+await this.httpfService
+  .patch('https://api.example.com/users/123', {
+    json: { email: 'jane@example.com' },
+  })
+  .head();
+
+// DELETE request
+await this.httpfService.delete('https://api.example.com/users/123').head();
+```
+
+### Error Handling
+
+Use `catchError` to treat errors as values:
+
+```typescript
+const result = await this.httpfService
+  .get<User>('https://api.example.com/users/123')
+  .catchError((error) => ({
+    body: null,
+    statusCode: 500,
+    error: error.message,
+  }))
+  .map((response) => response.body)
+  .head();
+
+// Transform and handle errors
+const user = await this.httpfService
+  .get<User>('https://api.example.com/users/123')
+  .catchError((error) => {
+    console.error('Failed to fetch user:', error);
+    return { body: { id: '0', name: 'Unknown' } };
+  })
+  .map((response) => response.body)
+  .head();
+```
+
+### Retry
+
+Automatically retry failed requests:
+
+```typescript
+// Retry up to 3 times
+const data = await this.httpfService
+  .get<Data>('https://api.example.com/unstable-endpoint')
+  .retry(3)
+  .map((response) => response.body)
+  .head();
+
+// Using retry with catchError
+const result = await this.httpfService
+  .get<Data>('https://api.example.com/data')
+  .retry(2)
+  .catchError((error) => ({
+    body: { fallback: true },
+    statusCode: 200,
+  }))
+  .map((response) => response.body)
+  .head();
+```
+
+### Using FxTS Methods
+
+You can use various helper functions from FxTS:
+
+```typescript
+// filter: Process only responses that match conditions
+const successResponse = await this.httpfService
+  .get<Data>('https://api.example.com/data')
+  .filter((response) => response.statusCode === 200)
+  .map((response) => response.body)
+  .head();
+
+// take: Get only the first N items
+const items = await this.httpfService
+  .get<Item[]>('https://api.example.com/items')
+  .map((response) => response.body)
+  .take(5)
+  .toArray();
+
+// Complex chaining
+const processedData = await this.httpfService
+  .get<RawData>('https://api.example.com/data')
+  .retry(2)
+  .catchError(() => ({ body: [] }))
+  .filter((response) => response.statusCode === 200)
+  .map((response) => response.body)
+  .map((data) => data.map((item) => ({ ...item, processed: true })))
+  .head();
+```
+
+### Flattening Data with mergeMap
+
+```typescript
+const allItems = await this.httpfService
+  .get<{ items: Item[] }>('https://api.example.com/data')
+  .map((response) => response.body)
+  .mergeMap((data) => data.items)
+  .toArray();
+```
+
+## Advanced Configuration
+
+### Global Configuration
+
+```typescript
+import { Module } from '@nestjs/common';
+import { HttpfModule } from 'nestjs-httpf';
+
+@Module({
+  imports: [
+    HttpfModule.register({
+      global: true,
+      timeout: 5000,
+      retry: {
+        limit: 2,
+      },
+      headers: {
+        'User-Agent': 'my-app/1.0.0',
+      },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Async Configuration
+
+```typescript
+import { Module } from '@nestjs/common';
+import { HttpfModule } from 'nestjs-httpf';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+
+@Module({
+  imports: [
+    HttpfModule.registerAsync({
+      imports: [ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        timeout: configService.get('HTTP_TIMEOUT'),
+        headers: {
+          'API-Key': configService.get('API_KEY'),
+        },
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Configuration with useClass
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { HttpfModuleOptionsFactory, HttpfModuleOptions } from 'nestjs-httpf';
+
+@Injectable()
+class HttpConfigService implements HttpfModuleOptionsFactory {
+  createHttpOptions(): HttpfModuleOptions {
+    return {
+      timeout: 5000,
+      retry: {
+        limit: 3,
+      },
+    };
+  }
+}
+
+@Module({
+  imports: [
+    HttpfModule.registerAsync({
+      useClass: HttpConfigService,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+## API Reference
+
+### HttpfService
+
+#### Methods
+
+- `get<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>`
+- `post<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>`
+- `put<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>`
+- `patch<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>`
+- `delete<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>`
+- `head<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>`
+
+### HttpfAsyncIterable
+
+`HttpfAsyncIterable` provides all FxTS methods along with the following additional methods:
+
+#### Additional Methods
+
+- `catchError<E>(handler: (error: unknown) => E): HttpfAsyncIterable<T | E>` - Catch errors and return a fallback value
+- `retry(retries: number): HttpfAsyncIterable<T>` - Retry the specified number of times on failure
+- `mergeMap<U>(mapper: (value: T) => Iterable<U>): HttpfAsyncIterable<U>` - Flatten values
+
+#### FxTS Methods and Helper Functions
+
+See the [FxTS documentation](https://fxts.dev/docs/index) for more information.
+
+## License
+
+[MIT](LICENSE)
+
+## Contributing
+
+Issues and pull requests are always welcome!
+
+## Related Projects
+
+- [NestJS](https://nestjs.com/) - Progressive Node.js framework
+- [Got](https://github.com/sindresorhus/got) - Human-friendly and powerful HTTP request library
+- [FxTS](https://fxts.dev/) - Functional library for TypeScript/JavaScript

package/dist/create-httpf-async-iterable.d.ts

@@ -0,0 +1,2 @@
+import { HttpfAsyncIterable } from './httpf-async-iterable.interface';
+export declare function createHttpfAsyncIterable<T>(source: AsyncIterable<T>): HttpfAsyncIterable<T>;

package/dist/create-httpf-async-iterable.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpfAsyncIterable = createHttpfAsyncIterable;
+const core_1 = require("@fxts/core");
+function createHttpfAsyncIterable(source) {
+    const fxIterable = (0, core_1.fx)(source);
+    const handler = {
+        get(target, prop, receiver) {
+            if (prop === 'catchError') {
+                return function (errorHandler) {
+                    const catchError = (async function* () {
+                        try {
+                            for await (const value of source) {
+                                yield value;
+                            }
+                        }
+                        catch (error) {
+                            yield errorHandler(error);
+                        }
+                    })();
+                    return createHttpfAsyncIterable(catchError);
+                };
+            }
+            if (prop === 'retry') {
+                return function (retries) {
+                    const retry = (async function* () {
+                        let attempt = 0;
+                        let lastError;
+                        while (attempt <= retries) {
+                            try {
+                                for await (const value of source) {
+                                    yield value;
+                                }
+                                return;
+                            }
+                            catch (error) {
+                                lastError = error;
+                                attempt++;
+                            }
+                        }
+                        throw lastError;
+                    })();
+                    return createHttpfAsyncIterable(retry);
+                };
+            }
+            if (prop === 'mergeMap') {
+                return function (mapper) {
+                    const mergeMap = (async function* () {
+                        for await (const value of source) {
+                            for (const innerValue of mapper(value)) {
+                                yield innerValue;
+                            }
+                        }
+                    })();
+                    return createHttpfAsyncIterable(mergeMap);
+                };
+            }
+            const value = Reflect.get(target, prop, receiver);
+            if (typeof value === 'function') {
+                return function (...args) {
+                    const result = value.apply(target, args);
+                    if (result &&
+                        typeof result === 'object' &&
+                        Symbol.asyncIterator in result &&
+                        typeof result.map === 'function') {
+                        return createHttpfAsyncIterable(result);
+                    }
+                    return result;
+                };
+            }
+            return value;
+        },
+    };
+    return new Proxy(fxIterable, handler);
+}
+//# sourceMappingURL=create-httpf-async-iterable.js.map

package/dist/create-httpf-async-iterable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-httpf-async-iterable.js","sourceRoot":"","sources":["../lib/create-httpf-async-iterable.ts"],"names":[],"mappings":";;AASA,4DAyFC;AAlGD,qCAAgC;AAShC,SAAgB,wBAAwB,CACtC,MAAwB;IAExB,MAAM,UAAU,GAAG,IAAA,SAAE,EAAC,MAAM,CAAC,CAAC;IAE9B,MAAM,OAAO,GAAqC;QAChD,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ;YACxB,IAAI,IAAI,KAAK,YAAY,EAAE,CAAC;gBAC1B,OAAO,UACL,YAAmC;oBAEnC,MAAM,UAAU,GAAG,CAAC,KAAK,SAAS,CAAC;wBACjC,IAAI,CAAC;4BACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;gCACjC,MAAM,KAAK,CAAC;4BACd,CAAC;wBACH,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,MAAM,YAAY,CAAC,KAAK,CAAC,CAAC;wBAC5B,CAAC;oBACH,CAAC,CAAC,EAAE,CAAC;oBACL,OAAO,wBAAwB,CAAQ,UAAU,CAAC,CAAC;gBACrD,CAAC,CAAC;YACJ,CAAC;YAED,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;gBACrB,OAAO,UAAU,OAAe;oBAC9B,MAAM,KAAK,GAAG,CAAC,KAAK,SAAS,CAAC;wBAC5B,IAAI,OAAO,GAAG,CAAC,CAAC;wBAChB,IAAI,SAAkB,CAAC;wBACvB,OAAO,OAAO,IAAI,OAAO,EAAE,CAAC;4BAC1B,IAAI,CAAC;gCACH,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;oCACjC,MAAM,KAAK,CAAC;gCACd,CAAC;gCACD,OAAO;4BACT,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,SAAS,GAAG,KAAK,CAAC;gCAClB,OAAO,EAAE,CAAC;4BACZ,CAAC;wBACH,CAAC;wBACD,MAAM,SAAS,CAAC;oBAClB,CAAC,CAAC,EAAE,CAAC;oBACL,OAAO,wBAAwB,CAAI,KAAK,CAAC,CAAC;gBAC5C,CAAC,CAAC;YACJ,CAAC;YAED,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;gBACxB,OAAO,UACL,MAAiC;oBAEjC,MAAM,QAAQ,GAAG,CAAC,KAAK,SAAS,CAAC;wBAC/B,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;4BACjC,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;gCACvC,MAAM,UAAU,CAAC;4BACnB,CAAC;wBACH,CAAC;oBACH,CAAC,CAAC,EAAE,CAAC;oBACL,OAAO,wBAAwB,CAAI,QAAQ,CAAC,CAAC;gBAC/C,CAAC,CAAC;YACJ,CAAC;YAED,MAAM,KAAK,GAAY,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;YAG3D,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;gBAChC,OAAO,UAAyB,GAAG,IAAe;oBAChD,MAAM,MAAM,GACV,KACD,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;oBAGtB,IACE,MAAM;wBACN,OAAO,MAAM,KAAK,QAAQ;wBAC1B,MAAM,CAAC,aAAa,IAAI,MAAM;wBAC9B,OAAQ,MAAmC,CAAC,GAAG,KAAK,UAAU,EAC9D,CAAC;wBACD,OAAO,wBAAwB,CAAC,MAAgC,CAAC,CAAC;oBACpE,CAAC;oBAED,OAAO,MAAM,CAAC;gBAChB,CAAC,CAAC;YACJ,CAAC;YAED,OAAO,KAAK,CAAC;QACf,CAAC;KACF,CAAC;IAEF,OAAO,IAAI,KAAK,CAAC,UAAU,EAAE,OAAO,CAA0B,CAAC;AACjE,CAAC"}

package/dist/fx-async-iterable.interface.d.ts

@@ -0,0 +1,2 @@
+import { fx } from '@fxts/core';
+export type FxAsyncIterable<T> = ReturnType<typeof fx<AsyncIterable<T>>>;

package/dist/fx-async-iterable.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fx-async-iterable.interface.js.map

package/dist/fx-async-iterable.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fx-async-iterable.interface.js","sourceRoot":"","sources":["../lib/fx-async-iterable.interface.ts"],"names":[],"mappings":""}

package/dist/httpf-async-iterable.interface.d.ts

@@ -0,0 +1,6 @@
+import { FxAsyncIterable } from './fx-async-iterable.interface';
+export interface HttpfAsyncIterable<T> extends FxAsyncIterable<T> {
+    catchError<E>(handler: (error: unknown) => E): HttpfAsyncIterable<T | E>;
+    retry(retries: number): HttpfAsyncIterable<T>;
+    mergeMap<U>(mapper: (value: T) => Iterable<U>): HttpfAsyncIterable<U>;
+}

package/dist/httpf-async-iterable.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=httpf-async-iterable.interface.js.map

package/dist/httpf-async-iterable.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpf-async-iterable.interface.js","sourceRoot":"","sources":["../lib/httpf-async-iterable.interface.ts"],"names":[],"mappings":""}

package/dist/httpf-module-option.interface.d.ts

@@ -0,0 +1,16 @@
+import { FactoryProvider, ModuleMetadata, Provider, Type } from '@nestjs/common';
+import { Options } from 'got';
+export interface HttpfModuleOptions extends Options {
+    global?: boolean;
+}
+export interface HttpfModuleOptionsFactory {
+    createHttpOptions(): Promise<HttpfModuleOptions> | HttpfModuleOptions;
+}
+export interface HttpfModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<HttpfModuleOptionsFactory>;
+    useClass?: Type<HttpfModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<HttpfModuleOptions> | HttpfModuleOptions;
+    inject?: FactoryProvider['inject'];
+    extraProviders?: Provider[];
+    global?: boolean;
+}

package/dist/httpf-module-option.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=httpf-module-option.interface.js.map

package/dist/httpf-module-option.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpf-module-option.interface.js","sourceRoot":"","sources":["../lib/httpf-module-option.interface.ts"],"names":[],"mappings":""}

package/dist/httpf.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const GOT = "GOT";
+export declare const HTTPF_MODULE_OPTIONS = "HTTPF_MODULE_OPTIONS";

package/dist/httpf.constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPF_MODULE_OPTIONS = exports.GOT = void 0;
+exports.GOT = 'GOT';
+exports.HTTPF_MODULE_OPTIONS = 'HTTPF_MODULE_OPTIONS';
+//# sourceMappingURL=httpf.constants.js.map

package/dist/httpf.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpf.constants.js","sourceRoot":"","sources":["../lib/httpf.constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,GAAG,GAAG,KAAK,CAAC;AACZ,QAAA,oBAAoB,GAAG,sBAAsB,CAAC"}

package/dist/httpf.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { HttpfModuleAsyncOptions, HttpfModuleOptions } from './httpf-module-option.interface';
+export declare class HttpfModule {
+    static register(config: HttpfModuleOptions): DynamicModule;
+    static registerAsync(options: HttpfModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

package/dist/httpf.module.js

@@ -0,0 +1,91 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var HttpfModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpfModule = void 0;
+const common_1 = require("@nestjs/common");
+const httpf_service_1 = require("./httpf.service");
+const got_1 = require("got");
+const httpf_constants_1 = require("./httpf.constants");
+let HttpfModule = HttpfModule_1 = class HttpfModule {
+    static register(config) {
+        return {
+            module: HttpfModule_1,
+            global: config.global,
+            providers: [
+                {
+                    provide: httpf_constants_1.GOT,
+                    useValue: got_1.default.extend(config),
+                },
+            ],
+        };
+    }
+    static registerAsync(options) {
+        return {
+            module: HttpfModule_1,
+            global: options.global,
+            imports: options.imports,
+            providers: [
+                ...this.createAsyncProviders(options),
+                {
+                    provide: httpf_constants_1.GOT,
+                    useFactory: (config) => got_1.default.extend(config),
+                    inject: [httpf_constants_1.HTTPF_MODULE_OPTIONS],
+                },
+                ...(options.extraProviders || []),
+            ],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        if (!options.useClass) {
+            throw new Error('Invalid configuration. Must provide useClass, useExisting or useFactory');
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: httpf_constants_1.HTTPF_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        const inject = options.useExisting || options.useClass;
+        if (!inject) {
+            throw new Error('Invalid configuration. Must provide useClass, useExisting or useFactory');
+        }
+        return {
+            provide: httpf_constants_1.HTTPF_MODULE_OPTIONS,
+            useFactory: async (optionsFactory) => optionsFactory.createHttpOptions(),
+            inject: [inject],
+        };
+    }
+};
+exports.HttpfModule = HttpfModule;
+exports.HttpfModule = HttpfModule = HttpfModule_1 = __decorate([
+    (0, common_1.Module)({
+        providers: [
+            httpf_service_1.HttpfService,
+            {
+                provide: httpf_constants_1.GOT,
+                useValue: got_1.default,
+            },
+        ],
+        exports: [httpf_service_1.HttpfService],
+    })
+], HttpfModule);
+//# sourceMappingURL=httpf.module.js.map

package/dist/httpf.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpf.module.js","sourceRoot":"","sources":["../lib/httpf.module.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAAiE;AACjE,mDAA+C;AAM/C,6BAAsB;AACtB,uDAA8D;AAYvD,IAAM,WAAW,mBAAjB,MAAM,WAAW;IACtB,MAAM,CAAC,QAAQ,CAAC,MAA0B;QACxC,OAAO;YACL,MAAM,EAAE,aAAW;YACnB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,qBAAG;oBACZ,QAAQ,EAAE,aAAG,CAAC,MAAM,CAAC,MAAM,CAAC;iBAC7B;aACF;SACF,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,OAAgC;QACnD,OAAO;YACL,MAAM,EAAE,aAAW;YACnB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,SAAS,EAAE;gBACT,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;gBACrC;oBACE,OAAO,EAAE,qBAAG;oBACZ,UAAU,EAAE,CAAC,MAA0B,EAAE,EAAE,CAAC,aAAG,CAAC,MAAM,CAAC,MAAM,CAAC;oBAC9D,MAAM,EAAE,CAAC,sCAAoB,CAAC;iBAC/B;gBACD,GAAG,CAAC,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC;aAClC;SACF,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,oBAAoB,CACjC,OAAgC;QAEhC,IAAI,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YAC9C,OAAO,CAAC,IAAI,CAAC,0BAA0B,CAAC,OAAO,CAAC,CAAC,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CACb,yEAAyE,CAC1E,CAAC;QACJ,CAAC;QACD,OAAO;YACL,IAAI,CAAC,0BAA0B,CAAC,OAAO,CAAC;YACxC;gBACE,OAAO,EAAE,OAAO,CAAC,QAAQ;gBACzB,QAAQ,EAAE,OAAO,CAAC,QAAQ;aAC3B;SACF,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,0BAA0B,CACvC,OAAgC;QAEhC,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YACvB,OAAO;gBACL,OAAO,EAAE,sCAAoB;gBAC7B,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,EAAE;aAC7B,CAAC;QACJ,CAAC;QACD,MAAM,MAAM,GAAG,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,QAAQ,CAAC;QACvD,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CACb,yEAAyE,CAC1E,CAAC;QACJ,CAAC;QACD,OAAO;YACL,OAAO,EAAE,sCAAoB;YAC7B,UAAU,EAAE,KAAK,EAAE,cAAyC,EAAE,EAAE,CAC9D,cAAc,CAAC,iBAAiB,EAAE;YACpC,MAAM,EAAE,CAAC,MAAM,CAAC;SACjB,CAAC;IACJ,CAAC;CACF,CAAA;AA1EY,kCAAW;sBAAX,WAAW;IAVvB,IAAA,eAAM,EAAC;QACN,SAAS,EAAE;YACT,4BAAY;YACZ;gBACE,OAAO,EAAE,qBAAG;gBACZ,QAAQ,EAAE,aAAG;aACd;SACF;QACD,OAAO,EAAE,CAAC,4BAAY,CAAC;KACxB,CAAC;GACW,WAAW,CA0EvB"}

package/dist/httpf.service.d.ts

@@ -0,0 +1,14 @@
+import { Got, OptionsOfJSONResponseBody, Response } from 'got';
+import { HttpfAsyncIterable } from './httpf-async-iterable.interface';
+import { createHttpfAsyncIterable } from './create-httpf-async-iterable';
+export declare class HttpfService {
+    protected readonly httpClient: Got;
+    constructor(httpClient: Got);
+    get<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>;
+    post<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>;
+    patch<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>;
+    put<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>;
+    delete<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>;
+    head<T>(url: string | URL, options?: OptionsOfJSONResponseBody): HttpfAsyncIterable<Response<T>>;
+}
+export { HttpfAsyncIterable, createHttpfAsyncIterable };