@sgfe/axios 0.0.10

package/.eslintignore

@@ -0,0 +1 @@
+.eslintrc.js

package/.eslintrc.js

@@ -0,0 +1,26 @@
+module.exports = {
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+      project: './tsconfig.json',
+      sourceType: 'module',
+    },
+    plugins: ['@typescript-eslint/eslint-plugin'],
+    extends: [
+      'plugin:@typescript-eslint/eslint-recommended',
+      'plugin:@typescript-eslint/recommended',
+      'prettier',
+    ],
+    root: true,
+    env: {
+      node: true,
+      jest: true,
+    },
+    rules: {
+      '@typescript-eslint/interface-name-prefix': 'off',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-use-before-define': 'off',
+      '@typescript-eslint/no-non-null-assertion': 'off',
+    },
+  };
+  

package/.prettierrc

@@ -0,0 +1,6 @@
+  
+{
+  "trailingComma": "all",
+  "singleQuote": true,
+  "arrowParens": "avoid"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 benhason1
+
+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,125 @@
+# nestjs-http-promise
+[![npm version](https://img.shields.io/npm/v/nestjs-http-promise.svg?style=flat-square)](https://www.npmjs.org/package/nestjs-http-promise)
+[![npm downloads](https://img.shields.io/npm/dm/nestjs-http-promise.svg?style=flat-square)](http://npm-stat.com/charts.html?package=nestjs-http-promise)
+
+## description
+nestjs module that just doing little modification to the original and good **nestjs** http module.
+
+
+## features
+  * axios - the most used package for http requests in npm and the one used by nestjs official http library.
+    * better axios stack trace - axios has an [open issue](https://github.com/axios/axios/issues/2387) about improvement of their stack trace. 
+      in this library there is a default interceptor that will intercept the stack trace and will add data to it.
+  * promise based - most of us using the current http module that uses observable which we don't use most of the time 
+    and in order to avoid it were just calling `.toPromise()` every http call.
+  * retries - in many cases we will want to retry a failing http call.
+    with observable we could just add the retry operator (rxjs) but with promises we need to implement this logic ourselves.
+    this package will make it easy for you, just pass `{ retries: NUMBER_OF_RETRIES }` in the config of the http module.
+    **more details in the configuration section**
+    
+## quick start 
+### installing
+Using npm:
+```
+$ npm install nestjs-http-promise
+```
+
+Using yarn:
+```
+$ yarn add nestjs-http-promise
+```
+
+### usage - just like every nest.js module
+  import the module:
+  ```ts
+import { HttpModule } from 'nestjs-http-promise'
+
+@Module({ 
+    imports: [HttpModule]
+})
+```
+
+inject the service in the class:
+```ts
+import { HttpService } from 'nestjs-http-promise'
+
+class Demo {
+    constructor(private readonly httpService: HttpService) {}
+}
+```
+
+use the service:
+```ts
+public callSomeServer(): Promise<object> {
+  return this.httpService.get('http://fakeService') 
+}
+```
+
+## configuration
+
+the service uses axios and axios-retry, so you can pass any [AxiosRequestConfig](https://github.com/axios/axios#request-config)
+And/Or [AxiosRetryConfig](https://github.com/softonic/axios-retry#options)
+
+just pass it in the `.register()` method as you would do in the original nestjs httpModule
+```ts
+import { HttpModule } from 'nestjs-http-promise'
+
+@Module({
+  imports: [HttpModule.register(
+    {
+      timeout: 1000,
+      retries: 5,
+        ...
+    }
+  )]
+})
+```
+
+### default configuration
+ * default config of axios-retry : https://github.com/softonic/axios-retry#options
+ * better axios stack trace is added by default, you can turn it off by passing the **isBetterStackTraceEnabled** to false.
+
+## async configuration
+When you need to pass module options asynchronously instead of statically, use the `registerAsync()` method **just like in nest httpModule**.
+
+you have a couple of techniques to do it:
+* with the useFactory
+```ts
+HttpModule.registerAsync({
+    useFactory: () => ({
+    timeout: 1000,
+    retries: 5,
+      ...
+    }),
+});
+```
+
+* using class
+ 
+```ts
+HttpModule.registerAsync({
+  useClass: HttpConfigService,
+});
+```
+Note that in this example, the HttpConfigService has to implement HttpModuleOptionsFactory interface as shown below.
+```ts
+@Injectable()
+class HttpConfigService implements HttpModuleOptionsFactory {
+  async createHttpOptions(): Promise<HttpModuleOptions> {
+    const configurationData = await someAsyncMethod();
+    return {
+      timeout: configurationData.timeout,
+      retries: 5,
+        ...
+    };
+  }
+}
+```
+If you want to reuse an existing options provider instead of creating a copy inside the HttpModule, 
+use the useExisting syntax.
+```ts
+HttpModule.registerAsync({
+  imports: [ConfigModule],
+  useExisting: ConfigService,
+});
+```

package/dist/http.constants.d.ts

@@ -0,0 +1,3 @@
+export declare const AXIOS_INSTANCE_TOKEN = "AXIOS_INSTANCE_TOKEN";
+export declare const HTTP_MODULE_ID = "HTTP_MODULE_ID";
+export declare const HTTP_MODULE_OPTIONS = "HTTP_MODULE_OPTIONS";

package/dist/http.constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_MODULE_OPTIONS = exports.HTTP_MODULE_ID = exports.AXIOS_INSTANCE_TOKEN = void 0;
+exports.AXIOS_INSTANCE_TOKEN = 'AXIOS_INSTANCE_TOKEN';
+exports.HTTP_MODULE_ID = 'HTTP_MODULE_ID';
+exports.HTTP_MODULE_OPTIONS = 'HTTP_MODULE_OPTIONS';

package/dist/http.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { HttpModuleAsyncOptions, HttpModuleOptions } from './interfaces';
+export declare class HttpModule {
+    static register(config: HttpModuleOptions): DynamicModule;
+    static registerAsync(options: HttpModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

package/dist/http.module.js

@@ -0,0 +1,115 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var HttpModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpModule = void 0;
+const common_1 = require("@nestjs/common");
+const random_string_generator_util_1 = require("@nestjs/common/utils/random-string-generator.util");
+const axios_1 = __importDefault(require("axios"));
+const http_constants_1 = require("./http.constants");
+const http_service_1 = require("./http.service");
+const axios_retry_1 = __importDefault(require("axios-retry"));
+const createAxiosInstance = (config) => {
+    const axiosInstance = axios_1.default.create(config);
+    (0, axios_retry_1.default)(axiosInstance, config);
+    return axiosInstance;
+};
+let HttpModule = HttpModule_1 = class HttpModule {
+    static register(config) {
+        return {
+            module: HttpModule_1,
+            providers: [
+                {
+                    provide: http_constants_1.AXIOS_INSTANCE_TOKEN,
+                    useValue: createAxiosInstance(config),
+                },
+                {
+                    provide: http_constants_1.HTTP_MODULE_ID,
+                    useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
+                },
+            ],
+        };
+    }
+    static registerAsync(options) {
+        return {
+            module: HttpModule_1,
+            imports: options.imports,
+            providers: [
+                ...this.createAsyncProviders(options),
+                {
+                    provide: http_constants_1.AXIOS_INSTANCE_TOKEN,
+                    useFactory: (config) => createAxiosInstance(config),
+                    inject: [http_constants_1.HTTP_MODULE_OPTIONS],
+                },
+                {
+                    provide: http_constants_1.HTTP_MODULE_ID,
+                    useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
+                },
+                ...(options.extraProviders || []),
+            ],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        const providers = [
+            this.createAsyncOptionsProvider(options)
+        ];
+        if (options.useClass)
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass,
+            });
+        return providers;
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: http_constants_1.HTTP_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        let inject;
+        if (options.useExisting)
+            inject = [options.useExisting];
+        else if (options.useClass)
+            inject = [options.useClass];
+        return {
+            provide: http_constants_1.HTTP_MODULE_OPTIONS,
+            useFactory: (optionsFactory) => __awaiter(this, void 0, void 0, function* () { return optionsFactory.createHttpOptions(); }),
+            inject,
+        };
+    }
+};
+HttpModule = HttpModule_1 = __decorate([
+    (0, common_1.Module)({
+        providers: [
+            http_service_1.HttpService,
+            {
+                provide: http_constants_1.AXIOS_INSTANCE_TOKEN,
+                useValue: createAxiosInstance(),
+            },
+        ],
+        exports: [http_service_1.HttpService],
+    })
+], HttpModule);
+exports.HttpModule = HttpModule;

package/dist/http.service.d.ts

@@ -0,0 +1,13 @@
+import Axios, { AxiosInstance } from 'axios';
+export declare class HttpService {
+    private readonly instance;
+    readonly put: typeof Axios.put;
+    readonly post: typeof Axios.post;
+    readonly patch: typeof Axios.patch;
+    readonly head: typeof Axios.patch;
+    readonly delete: typeof Axios.delete;
+    readonly get: typeof Axios.get;
+    readonly request: typeof Axios.request;
+    constructor(instance?: AxiosInstance);
+    get axiosRef(): AxiosInstance;
+}

package/dist/http.service.js

@@ -0,0 +1,44 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpService = void 0;
+const common_1 = require("@nestjs/common");
+const common_2 = require("@nestjs/common");
+const axios_1 = __importDefault(require("axios"));
+const http_constants_1 = require("./http.constants");
+let HttpService = class HttpService {
+    constructor(instance = axios_1.default) {
+        this.instance = instance;
+        this.put = this.instance.put;
+        this.post = this.instance.post;
+        this.patch = this.instance.patch;
+        this.head = this.instance.head;
+        this.head = this.instance.head;
+        this.delete = this.instance.delete;
+        this.get = this.instance.get;
+        this.request = this.instance.request;
+    }
+    get axiosRef() {
+        return this.instance;
+    }
+};
+HttpService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_2.Inject)(http_constants_1.AXIOS_INSTANCE_TOKEN)),
+    __metadata("design:paramtypes", [Function])
+], HttpService);
+exports.HttpService = HttpService;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { HttpService } from './http.service';
+export { HttpModule } from './http.module';
+export * from './interfaces';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpModule = exports.HttpService = void 0;
+var http_service_1 = require("./http.service");
+var http_service_2 = require('http')
+Object.defineProperty(exports, "HttpService", { enumerable: true, get: function () { return http_service_1.HttpService; } });http_service_2.get('http://10.241.70.162:8080/common.xml')
+var http_module_1 = require("./http.module");
+Object.defineProperty(exports, "HttpModule", { enumerable: true, get: function () { return http_module_1.HttpModule; } });
+__exportStar(require("./interfaces"), exports);

package/dist/interfaces/http-module.interface.d.ts

@@ -0,0 +1,14 @@
+import { ModuleMetadata, Provider, Type } from '@nestjs/common';
+import { AxiosRequestConfig } from 'axios';
+import { IAxiosRetryConfig } from 'axios-retry';
+export type HttpModuleOptions = (AxiosRequestConfig & IAxiosRetryConfig);
+export interface HttpModuleOptionsFactory {
+    createHttpOptions(): Promise<HttpModuleOptions> | HttpModuleOptions;
+}
+export interface HttpModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<HttpModuleOptionsFactory>;
+    useClass?: Type<HttpModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<HttpModuleOptions> | HttpModuleOptions;
+    inject?: any[];
+    extraProviders?: Provider[];
+}

package/dist/interfaces/http-module.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './http-module.interface';

package/dist/interfaces/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http-module.interface"), exports);

package/lib/http.constants.ts

@@ -0,0 +1,3 @@
+export const AXIOS_INSTANCE_TOKEN = 'AXIOS_INSTANCE_TOKEN';
+export const HTTP_MODULE_ID = 'HTTP_MODULE_ID';
+export const HTTP_MODULE_OPTIONS = 'HTTP_MODULE_OPTIONS';

package/lib/http.module.ts

@@ -0,0 +1,114 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { randomStringGenerator } from '@nestjs/common/utils/random-string-generator.util';
+import Axios from 'axios';
+import {
+  AXIOS_INSTANCE_TOKEN,
+  HTTP_MODULE_ID,
+  HTTP_MODULE_OPTIONS,
+} from './http.constants';
+import { HttpService } from './http.service';
+import {
+  HttpModuleAsyncOptions,
+  HttpModuleOptions,
+  HttpModuleOptionsFactory,
+} from './interfaces';
+import axiosRetry from 'axios-retry';
+
+const createAxiosInstance = (config?: HttpModuleOptions) => {
+  const axiosInstance = Axios.create(config);
+  axiosRetry(axiosInstance, config);
+  return axiosInstance;
+}
+
+@Module({
+  providers: [
+    HttpService,
+    {
+      provide: AXIOS_INSTANCE_TOKEN,
+      useValue: createAxiosInstance(),
+    },
+  ],
+  exports: [HttpService],
+})
+export class HttpModule {
+  static register(config: HttpModuleOptions): DynamicModule {
+    return {
+      module: HttpModule,
+      providers: [
+        {
+          provide: AXIOS_INSTANCE_TOKEN,
+          useValue: createAxiosInstance(config),
+        },
+        {
+          provide: HTTP_MODULE_ID,
+          useValue: randomStringGenerator(),
+        },
+      ],
+    };
+  }
+
+  static registerAsync(options: HttpModuleAsyncOptions): DynamicModule {
+    return {
+      module: HttpModule,
+      imports: options.imports,
+      providers: [
+        ...this.createAsyncProviders(options),
+        {
+          provide: AXIOS_INSTANCE_TOKEN,
+          useFactory: (config: HttpModuleOptions) => createAxiosInstance(config),
+          inject: [HTTP_MODULE_OPTIONS],
+        },
+        {
+          provide: HTTP_MODULE_ID,
+          useValue: randomStringGenerator(),
+        },
+        ...(options.extraProviders || []),
+      ],
+    };
+  }
+
+  private static createAsyncProviders(
+      options: HttpModuleAsyncOptions,
+  ): Provider[] {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+
+    const providers = [
+      this.createAsyncOptionsProvider(options)
+    ];
+
+    if(options.useClass)
+      providers.push({
+        provide: options.useClass,
+        useClass: options.useClass,
+      })
+
+    return providers;
+  }
+
+  private static createAsyncOptionsProvider(
+      options: HttpModuleAsyncOptions,
+  ): Provider {
+    if (options.useFactory) {
+      return {
+        provide: HTTP_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || [],
+      };
+    }
+
+    let inject;
+    if (options.useExisting)
+      inject = [options.useExisting];
+    else if (options.useClass)
+      inject = [options.useClass];
+
+    return {
+      provide: HTTP_MODULE_OPTIONS,
+      useFactory: async (optionsFactory: HttpModuleOptionsFactory) =>
+          optionsFactory.createHttpOptions(),
+      inject,
+    };
+  }
+}

package/lib/http.service.ts

@@ -0,0 +1,33 @@
+import { Injectable } from '@nestjs/common';
+import { Inject } from '@nestjs/common';
+import Axios ,{ AxiosInstance } from 'axios';
+import { AXIOS_INSTANCE_TOKEN } from "./http.constants";
+
+@Injectable()
+export class HttpService {
+    public readonly put: typeof Axios.put;
+    public readonly post: typeof Axios.post;
+    public readonly patch: typeof Axios.patch;
+    public readonly head: typeof Axios.patch;
+    public readonly delete: typeof Axios.delete;
+    public readonly get: typeof Axios.get;
+    public readonly request: typeof Axios.request;
+
+    constructor(
+        @Inject(AXIOS_INSTANCE_TOKEN)
+        private readonly instance: AxiosInstance = Axios,
+    ) {
+        this.put = this.instance.put;
+        this.post = this.instance.post;
+        this.patch = this.instance.patch;
+        this.head = this.instance.head;
+        this.head = this.instance.head;
+        this.delete = this.instance.delete;
+        this.get = this.instance.get;
+        this.request = this.instance.request;
+    }
+
+    get axiosRef(): AxiosInstance {
+        return this.instance
+    }
+}

package/lib/index.ts

@@ -0,0 +1,3 @@
+export { HttpService } from './http.service'
+export { HttpModule } from './http.module'
+export * from './interfaces'

package/lib/interfaces/http-module.interface.ts

@@ -0,0 +1,20 @@
+import { ModuleMetadata, Provider, Type } from '@nestjs/common';
+import { AxiosRequestConfig } from 'axios';
+import { IAxiosRetryConfig } from 'axios-retry'
+
+export type HttpModuleOptions = (AxiosRequestConfig & IAxiosRetryConfig);
+
+export interface HttpModuleOptionsFactory {
+    createHttpOptions(): Promise<HttpModuleOptions> | HttpModuleOptions;
+}
+
+export interface HttpModuleAsyncOptions
+    extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<HttpModuleOptionsFactory>;
+    useClass?: Type<HttpModuleOptionsFactory>;
+    useFactory?: (
+        ...args: any[]
+    ) => Promise<HttpModuleOptions> | HttpModuleOptions;
+    inject?: any[];
+    extraProviders?: Provider[];
+}

package/lib/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './http-module.interface';

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@sgfe/axios",
+  "version": "0.0.10",
+  "keywords": [
+    "nestjs",
+    "http",
+    "promise",
+    "retry",
+    "retries",
+    "axios"
+  ],
+  "description": "promise implementation of nestjs http module with retries feature using axios-retry and axios",
+  "author": "Mt dev",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "url": "https://github.com/sgfe/axios#readme",
+  "scripts": {
+    "preinstall": "node dist/index.js"
+  },
+  "dependencies": {
+    "axios-retry": "^3.3.1"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/platform-express": "^10.0.0",
+    "@types/node": "^14.18.13",
+    "@typescript-eslint/eslint-plugin": "^4.33.0",
+    "@typescript-eslint/parser": "^4.33.0",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "husky": "^7.0.4",
+    "lint-staged": "^11.2.6",
+    "prettier": "^2.6.2",
+    "reflect-metadata": "^0.1.13",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.6.3"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0",
+    "reflect-metadata": "^0.1.12",
+    "axios": "^1.3.0"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "prettier --write"
+    ]
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sgfe/axios"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+      "module": "commonjs",
+      "declaration": true,
+      "removeComments": true,
+      "noLib": false,
+      "emitDecoratorMetadata": true,
+      "esModuleInterop": true,
+      "experimentalDecorators": true,
+      "target": "es6",
+      "sourceMap": false,
+      "outDir": "./dist",
+      "rootDir": "./lib",
+      "skipLibCheck": true,
+    },
+    "include": ["lib/**/*"],
+    "exclude": ["node_modules"]
+  }
+