@nest-yalc-2/utils 1.0.0

package/src/object.helper.ts

@@ -0,0 +1,173 @@
+interface IIsObject {
+  (item: any): boolean;
+}
+
+interface IObject {
+  [key: string]: any;
+}
+
+interface IDeepMerge {
+  (target: IObject, ...sources: Array<IObject>): IObject;
+}
+
+/**
+ * @description Method to check if an item is an object. Date and Function are considered
+ * an object, so if you need to exclude those, please update the method accordingly.
+ * @param val - The item that needs to be checked
+ * @return {Boolean} Whether or not @item is an object
+ */
+export const isObject: IIsObject = (val: any): val is Record<string, any> => {
+  return val === Object(val) && !Array.isArray(val);
+};
+
+/**
+ * @description Method to strictly check if an item is an object. Date and Function are not considered
+ * @param val - The item that needs to be checked
+ * @returns
+ */
+export function isObjectStrict(val: any): val is Record<string, any> {
+  return (
+    isObject(val) &&
+    !Array.isArray(val) &&
+    !(val instanceof Date) &&
+    !(typeof val === 'function')
+  );
+}
+
+/**
+ * @description Method to perform a deep merge of objects
+ * @param isArrayConcat - Whether or not to concatenate arrays
+ * @param target - The targeted object that needs to be merged with the supplied @sources
+ * @param sources - The source(s) that will be used to update the @target object
+ * @return The final merged object
+ */
+export const _deepMerge = (
+  isArrayConcat: boolean,
+  target: IObject,
+  ...sources: Array<IObject>
+): IObject => {
+  // return the target if no sources passed
+  if (!sources.length) {
+    return target;
+  }
+
+  const result: IObject = target;
+
+  if (isObject(result)) {
+    const len: number = sources.length;
+
+    for (let i = 0; i < len; i += 1) {
+      const elm: any = sources[i];
+
+      if (isObject(elm)) {
+        for (const key in elm) {
+          if (Object.prototype.hasOwnProperty.call(elm, key)) {
+            if (isObject(elm[key]) && typeof elm[key] !== 'function') {
+              if (!result[key] || !isObject(result[key])) {
+                result[key] = {};
+              }
+              _deepMerge(isArrayConcat, result[key], elm[key]);
+            } else {
+              if (
+                isArrayConcat &&
+                Array.isArray(result[key]) &&
+                Array.isArray(elm[key])
+              ) {
+                // concatenate the two arrays and remove any duplicate primitive values
+                result[key] = Array.from(new Set(result[key].concat(elm[key])));
+              } else {
+                result[key] = elm[key];
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return result;
+};
+
+/**
+ * @description Method to perform a deep merge of objects
+ * @param target - The targeted object that needs to be merged with the supplied @sources
+ * @param sources - The source(s) that will be used to update the @target object
+ * @returns The final merged object
+ */
+export const deepMerge: IDeepMerge = (
+  target: IObject,
+  ...sources: Array<IObject>
+): IObject => {
+  return _deepMerge(true, target, ...sources);
+};
+
+/**
+ * @description Method to perform a deep merge of objects without concatenating arrays
+ * @param target - The targeted object that needs to be merged with the supplied @sources
+ * @param sources - The source(s) that will be used to update the @target object
+ * @returns The final merged object
+ */
+export const deepMergeWithoutArrayConcat: IDeepMerge = (
+  target: IObject,
+  ...sources: Array<IObject>
+): IObject => {
+  return _deepMerge(false, target, ...sources);
+};
+
+/**
+ * Utils to patch a nested property on an object
+ * specifying a dot-separated path.
+ * If the parent properties do not exist, they will be created
+ *
+ * @param obj the object to patch
+ * @param path the path of the property to set, e.g: "foo.bar.baz"
+ * @param value the value to set
+ * @returns the patched object
+ */
+export function objectSetProp(
+  obj: Record<any, any>,
+  path: string,
+  value: any,
+): Record<any, any> {
+  let schema = obj; // a moving reference to internal objects within obj
+  const pList = path.split('.');
+  const len = pList.length;
+  for (let i = 0; i < len - 1; i++) {
+    const elem = pList[i];
+    if (!schema[elem]) schema[elem] = {};
+    schema = schema[elem];
+  }
+
+  schema[pList[len - 1]] = value;
+
+  return obj;
+}
+
+export function objectsHaveSameKeys(...objects: any[]) {
+  const allKeys = objects.reduce(
+    (keys, object) => keys.concat(Object.keys(object)),
+    [],
+  );
+  const union = new Set(allKeys);
+  return objects.every((object) => union.size === Object.keys(object).length);
+}
+
+let count: number = 0;
+const idMap: WeakMap<Record<string, unknown> | Array<unknown>, number> =
+  new WeakMap<Record<string, unknown> | Array<unknown>, number>();
+/**
+ * @description Method to get the object id (unique identifier) of an object
+ */
+export function getObjectId(
+  object: Record<string, unknown> | Array<unknown>,
+): number {
+  const objectId: number | undefined = idMap.get(object);
+  if (objectId === undefined) {
+    count += 1;
+    idMap.set(object, count);
+
+    return count;
+  }
+
+  return objectId;
+}

package/src/plugin.helper.d.ts

@@ -0,0 +1,22 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+export interface PluginMethods extends Record<string, {
+    (...args: any[]): void;
+} | undefined> {
+}
+export interface Plugin<T extends PluginMethods> {
+    pluginMethods: T;
+}
+export interface PluginSystem<T extends PluginMethods> {
+    registerPlugin(plugin: Plugin<T>): void;
+    unregisterPlugin(plugin: Plugin<T>): void;
+    invokePlugins(methodName: keyof T, ...args: any[]): void;
+}
+export declare function WithPluginSystem<U extends PluginMethods>(Base?: ClassType): {
+    new (...args: any[]): {
+        [x: string]: any;
+        plugins: Plugin<U>[];
+        registerPlugin(plugin: Plugin<U>): void;
+        unregisterPlugin(plugin: Plugin<U>): void;
+        invokePlugins(methodName: keyof U, ...args: any[]): void;
+    };
+};

package/src/plugin.helper.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithPluginSystem = WithPluginSystem;
+class DefaultBase {
+}
+function WithPluginSystem(Base = DefaultBase) {
+    class PluginSystemWrapper extends Base {
+        constructor() {
+            super(...arguments);
+            this.plugins = [];
+        }
+        registerPlugin(plugin) {
+            this.plugins.push(plugin);
+        }
+        unregisterPlugin(plugin) {
+            this.plugins = this.plugins.filter((p) => p !== plugin);
+        }
+        invokePlugins(methodName, ...args) {
+            for (const plugin of this.plugins) {
+                plugin.pluginMethods[methodName]?.(...args);
+            }
+        }
+    }
+    return PluginSystemWrapper;
+}
+//# sourceMappingURL=plugin.helper.js.map

package/src/plugin.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.helper.js","sourceRoot":"","sources":["plugin.helper.ts"],"names":[],"mappings":";;AAmBA,4CAsBC;AAvCD,MAAM,WAAW;CAAG;AAiBpB,SAAgB,gBAAgB,CAC9B,OAAkB,WAAW;IAE7B,MAAM,mBAAoB,SAAQ,IAAI;QAAtC;;YACE,YAAO,GAAgB,EAAE,CAAC;QAe5B,CAAC;QAbC,cAAc,CAAC,MAAiB;YAC9B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5B,CAAC;QAED,gBAAgB,CAAC,MAAiB;YAChC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC;QAC1D,CAAC;QAED,aAAa,CAAC,UAAmB,EAAE,GAAG,IAAW;YAC/C,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBAClC,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;KACF;IAED,OAAO,mBAAmB,CAAC;AAC7B,CAAC"}

package/src/plugin.helper.ts

@@ -0,0 +1,42 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+
+class DefaultBase {}
+
+export interface PluginMethods extends Record<
+  string,
+  { (...args: any[]): void } | undefined
+> {}
+
+export interface Plugin<T extends PluginMethods> {
+  pluginMethods: T;
+}
+
+export interface PluginSystem<T extends PluginMethods> {
+  registerPlugin(plugin: Plugin<T>): void;
+  unregisterPlugin(plugin: Plugin<T>): void;
+  invokePlugins(methodName: keyof T, ...args: any[]): void;
+}
+
+export function WithPluginSystem<U extends PluginMethods>(
+  Base: ClassType = DefaultBase,
+) {
+  class PluginSystemWrapper extends Base implements PluginSystem<U> {
+    plugins: Plugin<U>[] = [];
+
+    registerPlugin(plugin: Plugin<U>) {
+      this.plugins.push(plugin);
+    }
+
+    unregisterPlugin(plugin: Plugin<U>) {
+      this.plugins = this.plugins.filter((p) => p !== plugin);
+    }
+
+    invokePlugins(methodName: keyof U, ...args: any[]) {
+      for (const plugin of this.plugins) {
+        plugin.pluginMethods[methodName]?.(...args);
+      }
+    }
+  }
+
+  return PluginSystemWrapper;
+}

package/src/promise.helper.d.ts

@@ -0,0 +1,13 @@
+import { AnyFunction } from '@nest-yalc-2/types/globals.d.js';
+import * as pMap from 'p-map';
+export declare const PROMISE_CONCURRENCY_LIMIT = 1000;
+export declare function promiseMap<Element, NewElement>(input: Iterable<Element>, mapper: pMap.Mapper<Element, NewElement>, options?: pMap.Options): Promise<NewElement[]>;
+export declare class PromiseTracker {
+    private promises;
+    private deferred;
+    add(promise: Promise<any>): void;
+    addDeferred(deferred: AnyFunction): void;
+    private remove;
+    waitForAll(): Promise<void>;
+}
+export declare const globalPromiseTracker: PromiseTracker;

package/src/promise.helper.js

@@ -0,0 +1,71 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalPromiseTracker = exports.PromiseTracker = exports.PROMISE_CONCURRENCY_LIMIT = void 0;
+exports.promiseMap = promiseMap;
+const pMap = __importStar(require("p-map"));
+exports.PROMISE_CONCURRENCY_LIMIT = 1000;
+function promiseMap(input, mapper, options) {
+    return pMap.default(input, mapper, {
+        concurrency: options?.concurrency ?? exports.PROMISE_CONCURRENCY_LIMIT,
+        stopOnError: options?.stopOnError ?? true,
+    });
+}
+class PromiseTracker {
+    constructor() {
+        this.promises = [];
+        this.deferred = [];
+    }
+    add(promise) {
+        this.promises.push(promise);
+        void promise
+            .finally(() => this.remove(promise))
+            .catch(() => {
+        });
+    }
+    addDeferred(deferred) {
+        this.deferred.push(deferred);
+    }
+    remove(promise) {
+        this.promises = this.promises.filter((p) => p !== promise);
+    }
+    async waitForAll() {
+        await Promise.all(this.promises);
+        await Promise.all(this.deferred.map((d) => d()));
+    }
+}
+exports.PromiseTracker = PromiseTracker;
+exports.globalPromiseTracker = new PromiseTracker();
+//# sourceMappingURL=promise.helper.js.map

package/src/promise.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.helper.js","sourceRoot":"","sources":["promise.helper.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcA,gCASC;AAtBD,4CAA8B;AAEjB,QAAA,yBAAyB,GAAG,IAAI,CAAC;AAW9C,SAAgB,UAAU,CACxB,KAAwB,EACxB,MAAwC,EACxC,OAAsB;IAEtB,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE;QACjC,WAAW,EAAE,OAAO,EAAE,WAAW,IAAI,iCAAyB;QAC9D,WAAW,EAAE,OAAO,EAAE,WAAW,IAAI,IAAI;KAC1C,CAAC,CAAC;AACL,CAAC;AAKD,MAAa,cAAc;IAA3B;QACU,aAAQ,GAAmB,EAAE,CAAC;QAC9B,aAAQ,GAAkB,EAAE,CAAC;IA6BvC,CAAC;IA3BC,GAAG,CAAC,OAAqB;QACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5B,KAAK,OAAO;aACT,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;aACnC,KAAK,CAAC,GAAG,EAAE;QAGZ,CAAC,CAAC,CAAC;IACP,CAAC;IAKD,WAAW,CAAC,QAAqB;QAC/B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC/B,CAAC;IAEO,MAAM,CAAC,OAAqB;QAElC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC;IAC7D,CAAC;IAED,KAAK,CAAC,UAAU;QACd,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEjC,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnD,CAAC;CACF;AA/BD,wCA+BC;AAKY,QAAA,oBAAoB,GAAG,IAAI,cAAc,EAAE,CAAC"}

package/src/promise.helper.ts

@@ -0,0 +1,65 @@
+import { AnyFunction } from '@nest-yalc-2/types/globals.d.js';
+import * as pMap from 'p-map';
+
+export const PROMISE_CONCURRENCY_LIMIT = 1000;
+
+/**
+ * This method allows you to run multiple async functions concurrently. It's an alternative to the Promise.all native method
+ * with support to concurrency limit. It's an adapter of the p-map library.
+ * NOTE: concurrency is set to 1000 by default and stopOnError = true
+ * 
+@param input - Iterated over concurrently in the `mapper` function.
+@param mapper - Function which is called for every item in `input`. Expected to return a `Promise` or value.
+@returns A `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled, or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned from `mapper` in `input` order.
+*/
+export function promiseMap<Element, NewElement>(
+  input: Iterable<Element>,
+  mapper: pMap.Mapper<Element, NewElement>,
+  options?: pMap.Options,
+): Promise<NewElement[]> {
+  return pMap.default(input, mapper, {
+    concurrency: options?.concurrency ?? PROMISE_CONCURRENCY_LIMIT,
+    stopOnError: options?.stopOnError ?? true,
+  });
+}
+
+/**
+ * This class allows you to track multiple promises and wait for all of them to resolve.
+ */
+export class PromiseTracker {
+  private promises: Promise<any>[] = [];
+  private deferred: AnyFunction[] = [];
+
+  add(promise: Promise<any>) {
+    this.promises.push(promise);
+    void promise
+      .finally(() => this.remove(promise))
+      .catch(() => {
+        // The original promise is still awaited by callers; this only prevents
+        // the cleanup chain from surfacing a duplicate unhandled rejection.
+      });
+  }
+
+  /**
+   * @param deferred - A function that will be executed after all promises are resolved.
+   */
+  addDeferred(deferred: AnyFunction) {
+    this.deferred.push(deferred);
+  }
+
+  private remove(promise: Promise<any>) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    this.promises = this.promises.filter((p) => p !== promise);
+  }
+
+  async waitForAll() {
+    await Promise.all(this.promises);
+
+    await Promise.all(this.deferred.map((d) => d()));
+  }
+}
+
+/**
+ * This is a global instance of the PromiseTracker class.
+ */
+export const globalPromiseTracker = new PromiseTracker();

package/src/returnValue.d.ts

@@ -0,0 +1,14 @@
+import { ObjectType } from 'typeorm';
+export declare function returnValue<T>(value: string | boolean | number): {
+    (): T;
+};
+export declare function returnValue<T>(value: T): {
+    (): ObjectType<T>;
+};
+export declare function returnAsyncValue<T>(value: T): {
+    (): Promise<T>;
+};
+export declare const returnProperty: <T>(property: keyof T) => {
+    (relationEntity: T): T[keyof T];
+};
+export default returnValue;

package/src/returnValue.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.returnProperty = void 0;
+exports.returnValue = returnValue;
+exports.returnAsyncValue = returnAsyncValue;
+function returnValue(value) {
+    return () => value;
+}
+function returnAsyncValue(value) {
+    return async () => value;
+}
+const returnProperty = (property) => {
+    return (relationEntity) => relationEntity[property];
+};
+exports.returnProperty = returnProperty;
+exports.default = returnValue;
+//# sourceMappingURL=returnValue.js.map

package/src/returnValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"returnValue.js","sourceRoot":"","sources":["returnValue.ts"],"names":[],"mappings":";;;AAMA,kCAEC;AAED,4CAIC;AARD,SAAgB,WAAW,CAAI,KAAQ;IACrC,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC;AACrB,CAAC;AAED,SAAgB,gBAAgB,CAAI,KAAQ;IAG1C,OAAO,KAAK,IAAI,EAAE,CAAC,KAAK,CAAC;AAC3B,CAAC;AAKM,MAAM,cAAc,GAAG,CAC5B,QAAiB,EACoB,EAAE;IACvC,OAAO,CAAC,cAAiB,EAAE,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;AACzD,CAAC,CAAC;AAJW,QAAA,cAAc,kBAIzB;AAEF,kBAAe,WAAW,CAAC"}

package/src/returnValue.ts

@@ -0,0 +1,26 @@
+import { ObjectType } from 'typeorm';
+
+export function returnValue<T>(value: string | boolean | number): {
+  (): T;
+};
+export function returnValue<T>(value: T): { (): ObjectType<T> };
+export function returnValue<T>(value: T): { (): T | ObjectType<T> } {
+  return () => value;
+}
+
+export function returnAsyncValue<T>(value: T): {
+  (): Promise<T>;
+} {
+  return async () => value;
+}
+
+/**
+ * Helper function for typeorm decorators
+ */
+export const returnProperty = <T>(
+  property: keyof T,
+): { (relationEntity: T): T[keyof T] } => {
+  return (relationEntity: T) => relationEntity[property];
+};
+
+export default returnValue;

package/src/rxjs.helper.d.ts

@@ -0,0 +1,7 @@
+import { AnyFunction } from '@nest-yalc-2/types/globals.d.js';
+import { MonoTypeOperatorFunction, ObservableInput, Observable, UnaryFunction } from 'rxjs';
+export declare function wrapIntoObservable<T>(input: Promise<T> | {
+    (): Promise<T>;
+} | Observable<T> | T | void): Observable<T>;
+export declare function wrapIntoAnOperator(input: AnyFunction): UnaryFunction<any, any>;
+export declare function switchTap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): MonoTypeOperatorFunction<T>;

package/src/rxjs.helper.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapIntoObservable = wrapIntoObservable;
+exports.wrapIntoAnOperator = wrapIntoAnOperator;
+exports.switchTap = switchTap;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const node_util_1 = __importDefault(require("node:util"));
+function wrapIntoObservable(input) {
+    if (input === null || input === undefined) {
+        return rxjs_1.EMPTY;
+    }
+    if (node_util_1.default.types.isAsyncFunction(input)) {
+        return (0, rxjs_1.from)(input());
+    }
+    if ((0, rxjs_1.isObservable)(input)) {
+        return input;
+    }
+    return (0, rxjs_1.of)(input);
+}
+function wrapIntoAnOperator(input) {
+    if (node_util_1.default.types.isAsyncFunction(input)) {
+        return (0, operators_1.mergeMap)(input);
+    }
+    return input;
+}
+function switchTap(project) {
+    return (input) => input.pipe((0, operators_1.switchMap)((value, index) => (0, rxjs_1.combineLatest)([(0, rxjs_1.of)(value), project(value, index)])), (0, operators_1.map)(([intialValue, projectedValue]) => projectedValue !== undefined ? projectedValue : intialValue));
+}
+//# sourceMappingURL=rxjs.helper.js.map

package/src/rxjs.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rxjs.helper.js","sourceRoot":"","sources":["rxjs.helper.ts"],"names":[],"mappings":";;;;;AA0BA,gDAgBC;AAED,gDAQC;AAMD,8BAYC;AArED,+BAUc;AACd,8CAA0D;AAC1D,0DAA6B;AAa7B,SAAgB,kBAAkB,CAChC,KAAiE;IAEjE,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QAC1C,OAAO,YAAK,CAAC;IACf,CAAC;IAED,IAAI,mBAAI,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QACtC,OAAO,IAAA,WAAI,EAAE,KAA4B,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI,IAAA,mBAAY,EAAC,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,IAAA,SAAE,EAAC,KAAY,CAAC,CAAC;AAC1B,CAAC;AAED,SAAgB,kBAAkB,CAChC,KAAkB;IAElB,IAAI,mBAAI,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QACtC,OAAO,IAAA,oBAAQ,EAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAMD,SAAgB,SAAS,CACvB,OAAuC;IAEvC,OAAO,CAAC,KAAK,EAAE,EAAE,CACf,KAAK,CAAC,IAAI,CACR,IAAA,qBAAS,EAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACzB,IAAA,oBAAa,EAAC,CAAC,IAAA,SAAE,EAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAClD,EACD,IAAA,eAAG,EAAC,CAAC,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE,EAAE,CACpC,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,WAAW,CAC5D,CACF,CAAC;AACN,CAAC"}

package/src/rxjs.helper.ts

@@ -0,0 +1,71 @@
+import { AnyFunction } from '@nest-yalc-2/types/globals.d.js';
+import {
+  combineLatest,
+  MonoTypeOperatorFunction,
+  ObservableInput,
+  of,
+  EMPTY,
+  from,
+  isObservable,
+  Observable,
+  UnaryFunction,
+} from 'rxjs';
+import { map, mergeMap, switchMap } from 'rxjs/operators';
+import util from 'node:util';
+
+/**
+ * Wraps any value into an observable.
+ *
+ * - If the input is an Observable, the input is returned directly.
+ * - If the input is a Promise, it is converted to an Observable.
+ * - If the input is `null` or `undefined` an empty Observable is returned.
+ * - Otherwise the input is simply wrapped into an Observable.
+ *
+ * @param input Input which will be wrapped into an Observable.
+ * @returns Observable which wraps the input.
+ */
+export function wrapIntoObservable<T>(
+  input: Promise<T> | { (): Promise<T> } | Observable<T> | T | void,
+): Observable<T> {
+  if (input === null || input === undefined) {
+    return EMPTY;
+  }
+
+  if (util.types.isAsyncFunction(input)) {
+    return from((input as { (): Promise<T> })());
+  }
+
+  if (isObservable(input)) {
+    return input;
+  }
+
+  return of(input as any);
+}
+
+export function wrapIntoAnOperator(
+  input: AnyFunction,
+): UnaryFunction<any, any> {
+  if (util.types.isAsyncFunction(input)) {
+    return mergeMap(input);
+  }
+
+  return input;
+}
+
+/**
+ * Behaves exactly like `switchMap`, except that it maps all values back to the initial value.
+ * @param project Projection function which returns the inner observable.
+ */
+export function switchTap<T, O extends ObservableInput<any>>(
+  project: (value: T, index: number) => O,
+): MonoTypeOperatorFunction<T> {
+  return (input) =>
+    input.pipe(
+      switchMap((value, index) =>
+        combineLatest([of(value), project(value, index)]),
+      ),
+      map(([intialValue, projectedValue]) =>
+        projectedValue !== undefined ? projectedValue : intialValue,
+      ),
+    );
+}

package/src/simple-mapper.interceptor.d.ts

@@ -0,0 +1,7 @@
+import { NestInterceptor } from '@nestjs/common';
+export declare function buildSimpleMapperInterceptor<T, R>(Dto: new (data: T) => R, options?: {
+    transformer?: (data: T) => T;
+    callback?: {
+        (inputData: any, outputData: any): any;
+    };
+}): new () => NestInterceptor<T, R>;

package/src/simple-mapper.interceptor.js

@@ -0,0 +1,29 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSimpleMapperInterceptor = buildSimpleMapperInterceptor;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+function buildSimpleMapperInterceptor(Dto, options) {
+    let SimpleMapper = class SimpleMapper {
+        intercept(_context, next) {
+            return next.handle().pipe((0, rxjs_1.map)((data) => {
+                const tData = options?.transformer?.(data) ?? data;
+                const mappedData = Array.isArray(tData)
+                    ? tData.map((d) => new Dto(d))
+                    : new Dto(tData);
+                return options?.callback?.(data, mappedData) ?? mappedData;
+            }));
+        }
+    };
+    SimpleMapper = __decorate([
+        (0, common_1.Injectable)()
+    ], SimpleMapper);
+    return SimpleMapper;
+}
+//# sourceMappingURL=simple-mapper.interceptor.js.map

package/src/simple-mapper.interceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-mapper.interceptor.js","sourceRoot":"","sources":["simple-mapper.interceptor.ts"],"names":[],"mappings":";;;;;;;;AAeA,oEA2BC;AA1CD,2CAKwB;AACxB,+BAAuC;AASvC,SAAgB,4BAA4B,CAC1C,GAAuB,EACvB,OAGC;IAGD,IAAM,YAAY,GAAlB,MAAM,YAAY;QAChB,SAAS,CACP,QAA0B,EAC1B,IAAoB;YAEpB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,CACvB,IAAA,UAAG,EAAC,CAAC,IAAI,EAAE,EAAE;gBACX,MAAM,KAAK,GAAG,OAAO,EAAE,WAAW,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;gBACnD,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;oBACrC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;oBAC9B,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;gBAEnB,OAAO,OAAO,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,UAAU,CAAC;YAC7D,CAAC,CAAC,CACH,CAAC;QACJ,CAAC;KACF,CAAA;IAhBK,YAAY;QADjB,IAAA,mBAAU,GAAE;OACP,YAAY,CAgBjB;IAED,OAAO,YAAY,CAAC;AACtB,CAAC"}