@nest-yalc-2/api-strategy 2.2.2 → 2.2.4

package/src/strategies/nest-http-call.strategy.ts

@@ -1,121 +1,121 @@
-import { ClassType } from '@node-yalc/types/globals.js';
-import { HttpService } from '@nestjs/axios';
-import {
-  HttpAbstractStrategy,
-  IHttpCallStrategyResponse,
-  HttpOptions,
-  IHttpCallStrategyOptions,
-} from './http-abstract-call.strategy.js';
-import { AxiosRequestConfig } from 'axios';
-import { YalcGlobalClsService } from '@nest-yalc-2/app/cls.module.js';
-import { filterHeaders } from '../header-whitelist.helper.js';
-import type { OutgoingHttpHeaders } from 'node:http2';
-
-export type NestHttpCallStrategyOptions = IHttpCallStrategyOptions & {
-  internalRequestHeader?: string;
-  internalRequestToken?: string;
-};
-
-export class NestHttpCallStrategy extends HttpAbstractStrategy {
-  private readonly internalHeader: string;
-  private readonly internalToken?: string;
-
-  constructor(
-    protected readonly httpService: HttpService,
-    protected readonly clsService: YalcGlobalClsService,
-    private baseUrl = '',
-    protected readonly options: NestHttpCallStrategyOptions = {},
-  ) {
-    super();
-    this.internalHeader =
-      options.internalRequestHeader ?? 'x-internal-request-token';
-    this.internalToken = options.internalRequestToken;
-  }
-
-  async call<TOptData, TParams extends Record<string, any>, TResData>(
-    path: string,
-    options?: HttpOptions<TOptData, TParams>,
-  ): Promise<IHttpCallStrategyResponse<TResData>> {
-    const clsHeaders = filterHeaders(
-      this.clsService.get('headers'),
-      this.options.headersWhitelist,
-    );
-    const headers: Record<string, any> = {
-      ...clsHeaders,
-      ...(options?.headers ?? {}),
-    };
-    if (
-      this.internalHeader &&
-      this.internalToken &&
-      !headers[this.internalHeader]
-    ) {
-      headers[this.internalHeader] = this.internalToken;
-    }
-    /**
-     * We need this to do a type check on the options and
-     * implement the mapping from HttpOptions to AxiosRequestConfig
-     */
-    const _options:
-      | {
-          [k: string | number | symbol]: never;
-        }
-      | AxiosRequestConfig = {
-      headers,
-      method: options?.method,
-      signal: options?.signal,
-      data: options?.data,
-    };
-
-    if (options?.parameters) {
-      _options.params = new URLSearchParams(options.parameters);
-    }
-
-    const { data, ...res } = await this.httpService.axiosRef.request({
-      headers: _options?.headers as any,
-      method: _options?.method,
-      signal: _options?.signal,
-      data: _options?.data,
-      params: _options?.params,
-      url: `${this.baseUrl}${path}`,
-    });
-
-    return {
-      ...res,
-      headers: res.headers as OutgoingHttpHeaders,
-      data,
-    };
-  }
-}
-
-export interface NestHttpCallStrategyProviderOptions {
-  baseUrl?: string;
-  NestHttpStrategy?: ClassType<NestHttpCallStrategy>;
-  headersWhitelist?: string[];
-  internalRequestHeader?: string;
-  internalRequestToken?: string;
-}
-
-/**
- * Just a convenient provider to inject the NestLocalCallStrategy
- */
-export const NestHttpCallStrategyProvider = (
-  provide: string,
-  options: NestHttpCallStrategyProviderOptions = {},
-) => ({
-  provide,
-  useFactory: (httpAdapter: HttpService, clsService: YalcGlobalClsService) => {
-    const _options = {
-      baseUrl: '',
-      NestHttpStrategy: NestHttpCallStrategy,
-      ...options,
-    };
-
-    return new _options.NestHttpStrategy(
-      httpAdapter,
-      clsService,
-      _options.baseUrl,
-      _options,
-    );
-  },
-  inject: [HttpService, YalcGlobalClsService],
-});
+import { ClassType } from '@node-yalc/types/globals.js';
+import { HttpService } from '@nestjs/axios';
+import {
+  HttpAbstractStrategy,
+  IHttpCallStrategyResponse,
+  HttpOptions,
+  IHttpCallStrategyOptions,
+} from './http-abstract-call.strategy.js';
+import { AxiosRequestConfig } from 'axios';
+import { YalcGlobalClsService } from '@nest-yalc-2/app/cls.module.js';
+import { filterHeaders } from '../header-whitelist.helper.js';
+import type { OutgoingHttpHeaders } from 'node:http2';
+
+export type NestHttpCallStrategyOptions = IHttpCallStrategyOptions & {
+  internalRequestHeader?: string;
+  internalRequestToken?: string;
+};
+
+export class NestHttpCallStrategy extends HttpAbstractStrategy {
+  private readonly internalHeader: string;
+  private readonly internalToken?: string;
+
+  constructor(
+    protected readonly httpService: HttpService,
+    protected readonly clsService: YalcGlobalClsService,
+    private baseUrl = '',
+    protected readonly options: NestHttpCallStrategyOptions = {},
+  ) {
+    super();
+    this.internalHeader =
+      options.internalRequestHeader ?? 'x-internal-request-token';
+    this.internalToken = options.internalRequestToken;
+  }
+
+  async call<TOptData, TParams extends Record<string, any>, TResData>(
+    path: string,
+    options?: HttpOptions<TOptData, TParams>,
+  ): Promise<IHttpCallStrategyResponse<TResData>> {
+    const clsHeaders = filterHeaders(
+      this.clsService.get('headers'),
+      this.options.headersWhitelist,
+    );
+    const headers: Record<string, any> = {
+      ...clsHeaders,
+      ...(options?.headers ?? {}),
+    };
+    if (
+      this.internalHeader &&
+      this.internalToken &&
+      !headers[this.internalHeader]
+    ) {
+      headers[this.internalHeader] = this.internalToken;
+    }
+    /**
+     * We need this to do a type check on the options and
+     * implement the mapping from HttpOptions to AxiosRequestConfig
+     */
+    const _options:
+      | {
+          [k: string | number | symbol]: never;
+        }
+      | AxiosRequestConfig = {
+      headers,
+      method: options?.method,
+      signal: options?.signal,
+      data: options?.data,
+    };
+
+    if (options?.parameters) {
+      _options.params = new URLSearchParams(options.parameters);
+    }
+
+    const { data, ...res } = await this.httpService.axiosRef.request({
+      headers: _options?.headers as any,
+      method: _options?.method,
+      signal: _options?.signal,
+      data: _options?.data,
+      params: _options?.params,
+      url: `${this.baseUrl}${path}`,
+    });
+
+    return {
+      ...res,
+      headers: res.headers as OutgoingHttpHeaders,
+      data,
+    };
+  }
+}
+
+export interface NestHttpCallStrategyProviderOptions {
+  baseUrl?: string;
+  NestHttpStrategy?: ClassType<NestHttpCallStrategy>;
+  headersWhitelist?: string[];
+  internalRequestHeader?: string;
+  internalRequestToken?: string;
+}
+
+/**
+ * Just a convenient provider to inject the NestLocalCallStrategy
+ */
+export const NestHttpCallStrategyProvider = (
+  provide: string,
+  options: NestHttpCallStrategyProviderOptions = {},
+) => ({
+  provide,
+  useFactory: (httpAdapter: HttpService, clsService: YalcGlobalClsService) => {
+    const _options = {
+      baseUrl: '',
+      NestHttpStrategy: NestHttpCallStrategy,
+      ...options,
+    };
+
+    return new _options.NestHttpStrategy(
+      httpAdapter,
+      clsService,
+      _options.baseUrl,
+      _options,
+    );
+  },
+  inject: [HttpService, YalcGlobalClsService],
+});

package/src/strategies/nest-local-call.strategy.ts

@@ -1,153 +1,153 @@
-import { HttpAdapterHost } from '@nestjs/core';
-import {
-  HttpAbstractStrategy,
-  HttpOptions,
-  IHttpCallStrategyOptions,
-  IHttpCallStrategyResponse,
-} from './http-abstract-call.strategy.js';
-import { FastifyAdapter } from '@nestjs/platform-fastify';
-import { ClassType } from '@node-yalc/types/globals.js';
-import { InjectOptions } from 'fastify';
-import { YalcGlobalClsService } from '@nest-yalc-2/app/cls.module.js';
-import { filterHeaders } from '../header-whitelist.helper.js';
-import { AppConfigService } from '@nest-yalc-2/app/app-config.service.js';
-import { MAIN_APP_CONFIG_SERVICE } from '@nest-yalc-2/app/def.const.js';
-
-export type NestLocalCallStrategyOptions = IHttpCallStrategyOptions & {
-  internalRequestHeader?: string;
-  internalRequestToken?: string;
-};
-
-export class NestLocalCallStrategy extends HttpAbstractStrategy {
-  private readonly internalHeader: string;
-  private readonly internalToken?: string;
-
-  constructor(
-    protected readonly adapterHost: HttpAdapterHost,
-    protected readonly clsService: YalcGlobalClsService,
-    protected readonly configService: AppConfigService,
-    private baseUrl = '',
-    protected readonly options: NestLocalCallStrategyOptions = {},
-  ) {
-    super();
-    this.internalHeader =
-      options.internalRequestHeader ?? 'x-internal-request-token';
-    this.internalToken =
-      options.internalRequestToken ??
-      (configService as any)?.values?.internalRequestToken;
-  }
-
-  async call<
-    TOptData extends string | object | Buffer | NodeJS.ReadableStream,
-    TParams extends Record<string, any>,
-    TResData,
-  >(
-    path: string,
-    options?: HttpOptions<TOptData, TParams>,
-  ): Promise<IHttpCallStrategyResponse<TResData>> {
-    const instance: FastifyAdapter = this.adapterHost.httpAdapter.getInstance();
-    const clsHeaders = filterHeaders(
-      this.clsService.get('headers'),
-      this.options.headersWhitelist,
-    );
-    const headers: Record<string, any> = {
-      ...clsHeaders,
-      ...(options?.headers ?? {}),
-    };
-    if (
-      this.internalHeader &&
-      this.internalToken &&
-      !headers[this.internalHeader]
-    ) {
-      headers[this.internalHeader] = this.internalToken;
-    }
-    /**
-     * We need this to do a type check on the options and
-     * implement the mapping from HttpOptions to InjectOptions;
-     */
-    const _options:
-      | {
-          [k: string | number | symbol]: never;
-        }
-      | InjectOptions = {
-      headers,
-      method: options?.method,
-      /**@todo investigate where to set thi */
-      // signal: options?.signal,
-      payload: options?.data, // map data to payload
-    };
-
-    const args: InjectOptions = {
-      ..._options,
-      url: `${this.baseUrl}${path}`,
-    };
-
-    if (options?.parameters) {
-      args.query = Object.fromEntries(new URLSearchParams(options.parameters));
-    }
-
-    const result = await instance.inject(args);
-
-    let data;
-    try {
-      if (
-        this.options.shouldSkipJsonParse &&
-        this.options.shouldSkipJsonParse(result.body)
-      ) {
-        data = result.body;
-      } else {
-        data = result.json();
-      }
-    } catch (_e) {
-      //The content-type of the response is not application/json
-      // if so, we use the body instead
-      data = result.body;
-    }
-
-    return {
-      data,
-      headers: result.headers,
-      status: result.statusCode,
-      statusText: result.statusMessage,
-      request: result.payload, // TODO: double check if it's the correct value
-    };
-  }
-}
-
-export interface NestLocalCallStrategyProviderOptions {
-  baseUrl?: string;
-  NestLocalStrategy?: ClassType<NestLocalCallStrategy>;
-  headersWhitelist?: string[];
-  internalRequestHeader?: string;
-  internalRequestToken?: string;
-}
-
-/**
- * Just a convenient provider to inject the NestLocalCallStrategy
- */
-export const NestLocalCallStrategyProvider = (
-  provide: string,
-  options: NestLocalCallStrategyProviderOptions = {},
-) => ({
-  provide,
-  useFactory: (
-    httpAdapter: HttpAdapterHost,
-    clsService: YalcGlobalClsService,
-    configService: AppConfigService,
-  ) => {
-    const _options = {
-      baseUrl: '',
-      NestLocalStrategy: NestLocalCallStrategy,
-      ...options,
-    };
-
-    return new _options.NestLocalStrategy(
-      httpAdapter,
-      clsService,
-      configService,
-      _options.baseUrl,
-      _options,
-    );
-  },
-  inject: [HttpAdapterHost, YalcGlobalClsService, MAIN_APP_CONFIG_SERVICE],
-});
+import { HttpAdapterHost } from '@nestjs/core';
+import {
+  HttpAbstractStrategy,
+  HttpOptions,
+  IHttpCallStrategyOptions,
+  IHttpCallStrategyResponse,
+} from './http-abstract-call.strategy.js';
+import { FastifyAdapter } from '@nestjs/platform-fastify';
+import { ClassType } from '@node-yalc/types/globals.js';
+import { InjectOptions } from 'fastify';
+import { YalcGlobalClsService } from '@nest-yalc-2/app/cls.module.js';
+import { filterHeaders } from '../header-whitelist.helper.js';
+import { AppConfigService } from '@nest-yalc-2/app/app-config.service.js';
+import { MAIN_APP_CONFIG_SERVICE } from '@nest-yalc-2/app/def.const.js';
+
+export type NestLocalCallStrategyOptions = IHttpCallStrategyOptions & {
+  internalRequestHeader?: string;
+  internalRequestToken?: string;
+};
+
+export class NestLocalCallStrategy extends HttpAbstractStrategy {
+  private readonly internalHeader: string;
+  private readonly internalToken?: string;
+
+  constructor(
+    protected readonly adapterHost: HttpAdapterHost,
+    protected readonly clsService: YalcGlobalClsService,
+    protected readonly configService: AppConfigService,
+    private baseUrl = '',
+    protected readonly options: NestLocalCallStrategyOptions = {},
+  ) {
+    super();
+    this.internalHeader =
+      options.internalRequestHeader ?? 'x-internal-request-token';
+    this.internalToken =
+      options.internalRequestToken ??
+      (configService as any)?.values?.internalRequestToken;
+  }
+
+  async call<
+    TOptData extends string | object | Buffer | NodeJS.ReadableStream,
+    TParams extends Record<string, any>,
+    TResData,
+  >(
+    path: string,
+    options?: HttpOptions<TOptData, TParams>,
+  ): Promise<IHttpCallStrategyResponse<TResData>> {
+    const instance: FastifyAdapter = this.adapterHost.httpAdapter.getInstance();
+    const clsHeaders = filterHeaders(
+      this.clsService.get('headers'),
+      this.options.headersWhitelist,
+    );
+    const headers: Record<string, any> = {
+      ...clsHeaders,
+      ...(options?.headers ?? {}),
+    };
+    if (
+      this.internalHeader &&
+      this.internalToken &&
+      !headers[this.internalHeader]
+    ) {
+      headers[this.internalHeader] = this.internalToken;
+    }
+    /**
+     * We need this to do a type check on the options and
+     * implement the mapping from HttpOptions to InjectOptions;
+     */
+    const _options:
+      | {
+          [k: string | number | symbol]: never;
+        }
+      | InjectOptions = {
+      headers,
+      method: options?.method,
+      /**@todo investigate where to set thi */
+      // signal: options?.signal,
+      payload: options?.data, // map data to payload
+    };
+
+    const args: InjectOptions = {
+      ..._options,
+      url: `${this.baseUrl}${path}`,
+    };
+
+    if (options?.parameters) {
+      args.query = Object.fromEntries(new URLSearchParams(options.parameters));
+    }
+
+    const result = await instance.inject(args);
+
+    let data;
+    try {
+      if (
+        this.options.shouldSkipJsonParse &&
+        this.options.shouldSkipJsonParse(result.body)
+      ) {
+        data = result.body;
+      } else {
+        data = result.json();
+      }
+    } catch (_e) {
+      //The content-type of the response is not application/json
+      // if so, we use the body instead
+      data = result.body;
+    }
+
+    return {
+      data,
+      headers: result.headers,
+      status: result.statusCode,
+      statusText: result.statusMessage,
+      request: result.payload, // TODO: double check if it's the correct value
+    };
+  }
+}
+
+export interface NestLocalCallStrategyProviderOptions {
+  baseUrl?: string;
+  NestLocalStrategy?: ClassType<NestLocalCallStrategy>;
+  headersWhitelist?: string[];
+  internalRequestHeader?: string;
+  internalRequestToken?: string;
+}
+
+/**
+ * Just a convenient provider to inject the NestLocalCallStrategy
+ */
+export const NestLocalCallStrategyProvider = (
+  provide: string,
+  options: NestLocalCallStrategyProviderOptions = {},
+) => ({
+  provide,
+  useFactory: (
+    httpAdapter: HttpAdapterHost,
+    clsService: YalcGlobalClsService,
+    configService: AppConfigService,
+  ) => {
+    const _options = {
+      baseUrl: '',
+      NestLocalStrategy: NestLocalCallStrategy,
+      ...options,
+    };
+
+    return new _options.NestLocalStrategy(
+      httpAdapter,
+      clsService,
+      configService,
+      _options.baseUrl,
+      _options,
+    );
+  },
+  inject: [HttpAdapterHost, YalcGlobalClsService, MAIN_APP_CONFIG_SERVICE],
+});

package/src/strategies/nest-local-event.strategy.d.ts

@@ -13,5 +13,5 @@ export interface NestLocalEventStrategyProviderOptions {
 export declare const NestLocalEventStrategyProvider: (provide: string, options?: NestLocalEventStrategyProviderOptions) => {
     provide: string;
     useFactory: (eventEmitter: EventEmitter2) => NestLocalEventStrategy<any, any>;
-    inject: (typeof EventEmitter2)[];
+    inject: typeof import("eventemitter2").EventEmitter2[];
 };

package/src/strategies/nest-local-event.strategy.ts

@@ -1,42 +1,42 @@
-import { IEventStrategy } from '../context-event.interface.js';
-import { EventEmitter2 } from '@nestjs/event-emitter';
-import { ClassType } from '@node-yalc/types/globals.js';
-
-export class NestLocalEventStrategy<
-  P = any,
-  O = any,
-> implements IEventStrategy {
-  constructor(private eventEmitter: EventEmitter2) {}
-
-  emit(path: string, payload: P, options?: O): boolean {
-    return this.eventEmitter.emit(path, payload, options);
-  }
-
-  emitAsync(path: string, payload: P, options?: O): Promise<any> {
-    return this.eventEmitter.emitAsync(path, payload, options);
-  }
-}
-
-export interface NestLocalEventStrategyProviderOptions {
-  NestLocalStrategy?: ClassType<NestLocalEventStrategy>;
-}
-
-/**
- * Just a convenient provider to inject the NestLocalCallStrategy
- */
-export const NestLocalEventStrategyProvider = (
-  provide: string,
-  options: NestLocalEventStrategyProviderOptions = {},
-) => ({
-  provide,
-  useFactory: (eventEmitter: EventEmitter2) => {
-    const _options = {
-      baseUrl: '',
-      NestLocalStrategy: NestLocalEventStrategy,
-      ...options,
-    };
-
-    return new _options.NestLocalStrategy(eventEmitter);
-  },
-  inject: [EventEmitter2],
-});
+import { IEventStrategy } from '../context-event.interface.js';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { ClassType } from '@node-yalc/types/globals.js';
+
+export class NestLocalEventStrategy<
+  P = any,
+  O = any,
+> implements IEventStrategy {
+  constructor(private eventEmitter: EventEmitter2) {}
+
+  emit(path: string, payload: P, options?: O): boolean {
+    return this.eventEmitter.emit(path, payload, options);
+  }
+
+  emitAsync(path: string, payload: P, options?: O): Promise<any> {
+    return this.eventEmitter.emitAsync(path, payload, options);
+  }
+}
+
+export interface NestLocalEventStrategyProviderOptions {
+  NestLocalStrategy?: ClassType<NestLocalEventStrategy>;
+}
+
+/**
+ * Just a convenient provider to inject the NestLocalCallStrategy
+ */
+export const NestLocalEventStrategyProvider = (
+  provide: string,
+  options: NestLocalEventStrategyProviderOptions = {},
+) => ({
+  provide,
+  useFactory: (eventEmitter: EventEmitter2) => {
+    const _options = {
+      baseUrl: '',
+      NestLocalStrategy: NestLocalEventStrategy,
+      ...options,
+    };
+
+    return new _options.NestLocalStrategy(eventEmitter);
+  },
+  inject: [EventEmitter2],
+});