@nest-yalc-2/utils 1.0.0

package/src/__tests__/object.helper.spec.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from '@jest/globals';
+import {
+  _deepMerge,
+  deepMerge,
+  deepMergeWithoutArrayConcat,
+  getObjectId,
+  isObject,
+  isObjectStrict,
+  objectsHaveSameKeys,
+  objectSetProp,
+} from '../object.helper.js';
+
+describe('test object.helper.ts', () => {
+  it('should set a property correctly', () => {
+    const obj: any = {};
+    objectSetProp(obj, 'test', 1);
+    expect(obj.test).toBe(1);
+  });
+
+  it('should set a subproperty correctly', () => {
+    const obj: any = {};
+    const res = objectSetProp(obj, 'test.foo', 1);
+    expect(obj.test.foo).toBe(1);
+    expect(res.test.foo).toBe(1);
+  });
+
+  it('should set a subproperty on an existing parent object', () => {
+    const obj: any = { test: {} };
+    const res = objectSetProp(obj, 'test.foo', 1);
+    expect(res.test.foo).toBe(1);
+  });
+
+  it('should merge 2 objects correctly', () => {
+    const obj1 = { test: 1, sub: { test2: 2 }, array: [1, 2, 4] };
+    const obj2 = {
+      test: 2,
+      sub: { test3: 3 },
+      new: {
+        test4: 4,
+      },
+      array: [3, 4, 5],
+    };
+
+    const res = deepMerge(obj1, obj2);
+
+    expect(res).toStrictEqual({
+      test: 2,
+      sub: {
+        test2: 2,
+        test3: 3,
+      },
+      new: {
+        test4: 4,
+      },
+      array: [1, 2, 4, 3, 5],
+    });
+  });
+
+  it('should merge objects  correctly (last undefined)', () => {
+    const obj1 = { test: 1, sub: { test2: 2 } };
+
+    const res = deepMerge(obj1);
+
+    expect(res).toStrictEqual({
+      test: 1,
+      sub: {
+        test2: 2,
+      },
+    });
+  });
+
+  it('should skip merge work for non-object targets and sources', () => {
+    const inherited = Object.create({ inherited: true });
+    expect(_deepMerge(true, null as any, { test: 1 })).toBeNull();
+    expect(deepMerge({}, undefined as any)).toStrictEqual({});
+    expect(deepMerge({}, inherited)).toStrictEqual({});
+  });
+
+  it('should merge objects  correctly with array concat', () => {
+    const obj1 = { test: 1, sub: { test2: ['1', '2'] } };
+    const obj2 = { test: 2, sub: { test2: ['3','2'] } };
+
+    const res = deepMerge(obj1,obj2);
+
+    expect(res).toStrictEqual({
+      test: 2,
+      sub: {
+        test2: ['1', '2', '3'],
+      },
+    });
+  });
+
+  it('should merge objects  correctly without array concat', () => {
+    const obj1 = { test: 1, sub: { test2: ['1', '2'] } };
+    const obj2 = { test: 2, sub: { test2: ['3','2'] } };
+
+    const res = deepMergeWithoutArrayConcat(obj1,obj2);
+
+    expect(res).toStrictEqual({
+      test: 2,
+      sub: {
+        test2: ['3', '2'],
+      },
+    });
+  });
+
+  it('should merge objects  correctly with functions', () => {
+    const obj1 = { test: 1};
+    const obj2 = { test: 2, sub: { test2: () => {} } };
+
+    const res = deepMerge(obj1,obj2);
+
+    expect(res).toStrictEqual({
+      test: 2,
+      sub: {
+        test2: expect.any(Function),
+      },
+    });
+  });
+
+  it('should isObjectStrict return true', () => {
+    expect(isObjectStrict({})).toBe(true);
+    expect(isObjectStrict({ test: 1 })).toBe(true);
+    expect(isObjectStrict({ test: 1, sub: { test2: 2 } })).toBe(true);
+    expect(isObjectStrict(new Object('something'))).toBe(true);
+  });
+
+  it('should isObjectStrict return false', () => {
+    expect(isObjectStrict(null)).toBe(false);
+    expect(isObjectStrict(undefined)).toBe(false);
+    expect(isObjectStrict(1)).toBe(false);
+    expect(isObjectStrict('string')).toBe(false);
+    expect(isObjectStrict(true)).toBe(false);
+    expect(isObjectStrict(false)).toBe(false);
+    expect(isObjectStrict([1, 2, 3])).toBe(false);
+    expect(isObjectStrict(new Date())).toBe(false);
+    expect(isObjectStrict(() => {})).toBe(false);
+  });
+
+  it('should isObject return true', () => {
+    expect(isObject({})).toBe(true);
+    expect(isObject({ test: 1 })).toBe(true);
+    expect(isObject({ test: 1, sub: { test2: 2 } })).toBe(true);
+    expect(isObject(new Object('something'))).toBe(true);
+    expect(isObject(null)).toBe(false);
+    expect(isObject(() => {})).toBe(true);
+  });
+
+  it('should isObject return false', () => {
+    expect(isObject(undefined)).toBe(false);
+    expect(isObject(1)).toBe(false);
+    expect(isObject('string')).toBe(false);
+    expect(isObject(true)).toBe(false);
+    expect(isObject(false)).toBe(false);
+    expect(isObject([1, 2, 3])).toBe(false);
+  });
+
+
+  it('should getObjectId return the correct id', () => {
+    const obj = { id: 1 };
+    let res = getObjectId(obj);
+    expect(res).toBeGreaterThan(0);
+    // it should give the same result
+    expect(getObjectId(obj)).toBe(res);
+    // different objects instead should give different results
+    expect(getObjectId({ id: 1 })).not.toBe(1);
+  });
+
+
+  it('should objectsHaveSameKeys return true', () => {
+    const obj1 = { test: 1, sub: { test2: 2 } };
+    const obj2 = { test: 1, sub: { test2: 2 } };
+    expect(objectsHaveSameKeys(obj1, obj2)).toBe(true);
+  });
+
+  it('should objectsHaveSameKeys return false', () => {
+    const obj1 = { test: 1, sub: { test2: 2 } };
+    const obj2 = { test: 1, sub2: { test2: 2 } };
+    expect(objectsHaveSameKeys(obj1, obj2)).toBe(false);
+  });
+});

package/src/__tests__/plugin.helper.spec.ts

@@ -0,0 +1,85 @@
+import { WithPluginSystem, Plugin, PluginMethods } from '../plugin.helper.js';
+import { describe, it, expect, beforeEach, jest } from '@jest/globals';
+
+describe('WithPluginSystem', () => {
+  class TestMethods implements PluginMethods {
+    [key: string]: { (...args: any[]): void } | undefined;
+    testMethod1?: (...args: any[]) => void;
+    testMethod2?: (...args: any[]) => void;
+  }
+
+  class TestBase {}
+
+  it('should create a PluginSystemWrapper with default base class', () => {
+    const PluginSystemWrapper = WithPluginSystem<TestMethods>();
+    expect(new PluginSystemWrapper()).toBeInstanceOf(PluginSystemWrapper);
+  });
+
+  it('should create a PluginSystemWrapper with a custom base class', () => {
+    const PluginSystemWrapper = WithPluginSystem<TestMethods>(TestBase);
+    expect(new PluginSystemWrapper()).toBeInstanceOf(TestBase);
+  });
+
+  describe('PluginSystemWrapper', () => {
+    let PluginSystemWrapper: any;
+    let pluginSystem: any;
+
+    beforeEach(() => {
+      PluginSystemWrapper = WithPluginSystem<TestMethods>();
+      pluginSystem = new PluginSystemWrapper();
+    });
+
+    describe('registerPlugin', () => {
+      it('should register a plugin', () => {
+        const plugin: Plugin<TestMethods> = { pluginMethods: {} };
+        pluginSystem.registerPlugin(plugin);
+        expect(pluginSystem.plugins).toContain(plugin);
+      });
+    });
+
+    describe('unregisterPlugin', () => {
+      it('should unregister a plugin', () => {
+        const plugin: Plugin<TestMethods> = { pluginMethods: {} };
+        pluginSystem.registerPlugin(plugin);
+        pluginSystem.unregisterPlugin(plugin);
+        expect(pluginSystem.plugins).not.toContain(plugin);
+      });
+    });
+
+    describe('invokePlugins', () => {
+      it('should invoke the correct method on all plugins', () => {
+        const plugin1: Plugin<TestMethods> = {
+          pluginMethods: {
+            testMethod1: jest.fn(),
+          },
+        };
+        const plugin2: Plugin<TestMethods> = {
+          pluginMethods: {
+            testMethod1: jest.fn(),
+          },
+        };
+        pluginSystem.registerPlugin(plugin1);
+        pluginSystem.registerPlugin(plugin2);
+        pluginSystem.invokePlugins('testMethod1', 'arg1', 'arg2');
+
+        expect(plugin1.pluginMethods.testMethod1).toHaveBeenCalledWith(
+          'arg1',
+          'arg2',
+        );
+        expect(plugin2.pluginMethods.testMethod1).toHaveBeenCalledWith(
+          'arg1',
+          'arg2',
+        );
+      });
+
+      it('should not throw if a method is undefined', () => {
+        const plugin: Plugin<TestMethods> = { pluginMethods: {} };
+        pluginSystem.registerPlugin(plugin);
+
+        expect(() =>
+          pluginSystem.invokePlugins('testMethod1', 'arg1'),
+        ).not.toThrow();
+      });
+    });
+  });
+});

package/src/__tests__/promise.helper.spec.ts

@@ -0,0 +1,76 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+  test,
+} from '@jest/globals';
+import { PromiseTracker, promiseMap } from '../promise.helper.js';
+
+describe('promise helper test', () => {
+  const elements = [1, 2];
+
+  it('It should resolve promises correctly with explicit options', async () => {
+    const result = await promiseMap(elements, async (element) => element, {
+      concurrency: 10,
+      stopOnError: false,
+    });
+
+    expect(result).toEqual(elements);
+  });
+
+  it('It should resolve promises correctly with implicit options', async () => {
+    const result = await promiseMap(elements, async (element) => element);
+
+    expect(result).toEqual(elements);
+  });
+});
+
+describe('promise tracker test', () => {
+  it('It should wait for all promises to resolve', async () => {
+    const promiseTracker = new PromiseTracker();
+
+    const promises = [Promise.resolve(1), Promise.resolve(2)];
+
+    promises.forEach((promise) => promiseTracker.add(promise));
+
+    await promiseTracker.waitForAll();
+
+    expect(promiseTracker['promises']).toHaveLength(0);
+  });
+
+  it('It should run deferred callbacks after tracked promises', async () => {
+    const promiseTracker = new PromiseTracker();
+    const calls: string[] = [];
+
+    promiseTracker.add(
+      Promise.resolve('ok').then((value) => {
+        calls.push(value);
+        return value;
+      }),
+    );
+
+    promiseTracker.addDeferred(() => {
+      calls.push('deferred');
+    });
+
+    await promiseTracker.waitForAll();
+
+    expect(calls).toEqual(['ok', 'deferred']);
+    expect(promiseTracker['promises']).toHaveLength(0);
+  });
+
+  it('It should clean up tracked promises when they reject', async () => {
+    const promiseTracker = new PromiseTracker();
+    const error = new Error('boom');
+
+    promiseTracker.add(Promise.reject(error));
+
+    await expect(promiseTracker.waitForAll()).rejects.toThrow(error);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(promiseTracker['promises']).toHaveLength(0);
+  });
+});

package/src/__tests__/returnValue.spec.ts

@@ -0,0 +1,49 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+  test,
+} from '@jest/globals';
+
+import returnValue, { returnAsyncValue, returnProperty } from '../returnValue.js';
+
+test('returnValue should return a constant function', () => {
+  class TypeTest {}
+
+  const testArgSamples = [
+    'pass',
+    [],
+    TypeTest,
+    undefined,
+    null,
+    () => 'Another Function',
+  ];
+
+  testArgSamples.forEach((value) => {
+    const returnTypeTest = returnValue(value);
+    expect(returnTypeTest).toBeInstanceOf(Function);
+    expect(returnTypeTest()).toEqual(value);
+  });
+});
+
+test('returnAsyncValue should resolve the provided value', async () => {
+  const fn = returnAsyncValue('async-value');
+  await expect(fn()).resolves.toBe('async-value');
+});
+
+test('returnProperty should return a property of a class', () => {
+  class TypeTest {
+    validProperty = 'something';
+  }
+
+  const returnTypeTest = returnProperty<TypeTest>('validProperty');
+  expect(returnTypeTest(new TypeTest())).toBe('something');
+
+  const returnTypeBadTest = returnProperty<any>('invalidProperty');
+  expect(returnTypeBadTest(new TypeTest())).toBeUndefined();
+});

package/src/__tests__/rxjs.helper.spec.ts

@@ -0,0 +1,79 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import * as rxjs from 'rxjs';
+
+import * as rxjsHelper from '../rxjs.helper.js';
+
+describe('test rxjs helper', () => {
+  it('should execute switchTap', async () => {
+    const subject = rxjs.of(1).pipe(
+      rxjsHelper.switchTap(async (value: any, index: number) => {
+        return value;
+      }),
+    );
+
+    await expect(rxjs.lastValueFrom(subject)).resolves.toEqual(1);
+  });
+
+  it('should execute switchTap without return any values', async () => {
+    const subject = rxjs
+      .of(1)
+      .pipe(rxjsHelper.switchTap(async (value: any, index: number) => {}));
+
+    await expect(rxjs.lastValueFrom(subject)).resolves.toEqual(1);
+  });
+
+  it('should execute switchTap returning a null value', async () => {
+    const subject = rxjs
+      .of(1)
+      .pipe(rxjsHelper.switchTap(async (value: any, index: number) => null));
+
+    await expect(rxjs.lastValueFrom(subject)).resolves.toEqual(null);
+  });
+
+  it('should execute wrapIntoObservable', () => {
+    const subject = rxjsHelper.wrapIntoObservable(new rxjs.Observable());
+    expect(subject).toBeDefined();
+  });
+
+  it('should execute wrapIntoObservable with async function', () => {
+    const subject = rxjsHelper.wrapIntoObservable(async () => {});
+    expect(subject).toBeDefined();
+  });
+
+  it('should execute wrapIntoObservable with non-async function', () => {
+    const subject = rxjsHelper.wrapIntoObservable(() => {});
+    expect(subject).toBeDefined();
+  });
+
+  it('should execute wrapIntoObservable with null', () => {
+    const subject = rxjsHelper.wrapIntoObservable(null);
+    expect(subject).toBeDefined();
+  });
+
+  it('should execute wrapIntoAnOperator', () => {
+    const subject = rxjsHelper.wrapIntoAnOperator(
+      (value: any, index: number) => {
+        return value;
+      },
+    );
+    expect(subject(new rxjs.Observable())).toBeDefined();
+  });
+
+  it('should execute wrapIntoAnOperator with async function', () => {
+    const subject = rxjsHelper.wrapIntoAnOperator(
+      async (value: any, index: number) => {
+        return value;
+      },
+    );
+    expect(subject(new rxjs.Observable())).toBeDefined();
+  });
+});

package/src/__tests__/simple-mapper.interceptor.spec.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it, jest, beforeEach } from '@jest/globals';
+import { ExecutionContext, CallHandler, NestInterceptor } from '@nestjs/common';
+import { of } from 'rxjs';
+import { buildSimpleMapperInterceptor } from '../simple-mapper.interceptor.js';
+
+describe('SimpleMapperInterceptor', () => {
+  let interceptor: NestInterceptor;
+
+  class TestDto {
+    prop1: string;
+    prop2: number;
+
+    constructor(data: { prop1: string; prop2: number }) {
+      this.prop1 = data.prop1;
+      this.prop2 = data.prop2;
+    }
+  }
+
+  const rawTestObject = { prop1: 'test', prop2: 123 };
+
+  beforeEach(() => {
+    interceptor = new (buildSimpleMapperInterceptor(TestDto))();
+  });
+
+  it('should be defined', () => {
+    expect(interceptor).toBeDefined();
+  });
+
+  it('should map raw data to DTO', (done) => {
+    const executionContext = {
+      switchToHttp: jest.fn().mockReturnThis(),
+      getRequest: jest.fn(),
+    } as unknown as ExecutionContext;
+
+    const next: CallHandler = {
+      handle: () => of(rawTestObject),
+    };
+
+    interceptor.intercept(executionContext, next).subscribe((result) => {
+      expect(result).toBeInstanceOf(TestDto);
+      expect(result).toMatchObject(rawTestObject);
+      done();
+    });
+  });
+
+  it('should map arrays with transformer and callback', (done) => {
+    const transformer = jest.fn((data: any) =>
+      data.map((item: any) => ({ ...item, prop2: item.prop2 + 1 })),
+    );
+    const callback = jest.fn((input: any, output: any) => ({
+      input,
+      output,
+    }));
+    const ArrayInterceptor = buildSimpleMapperInterceptor(TestDto, {
+      transformer,
+      callback,
+    });
+    interceptor = new ArrayInterceptor();
+
+    const executionContext = {
+      switchToHttp: jest.fn().mockReturnThis(),
+      getRequest: jest.fn(),
+    } as unknown as ExecutionContext;
+
+    const next: CallHandler = {
+      handle: () =>
+        of([
+          rawTestObject,
+          { prop1: 'second', prop2: 321 },
+        ] as { prop1: string; prop2: number }[]),
+    };
+
+    interceptor.intercept(executionContext, next).subscribe((result) => {
+      expect(transformer).toHaveBeenCalled();
+      expect(callback).toHaveBeenCalled();
+      expect(result.input).toHaveLength(2);
+      expect(result.output[0]).toBeInstanceOf(TestDto);
+      expect(result.output[0]).toMatchObject({ prop1: 'test', prop2: 124 });
+      done();
+    });
+  });
+});

package/src/__tests__/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../tsconfig.test.json"
+}

package/src/__tests__/validator-helper.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from '@jest/globals';
+import {
+  stringIsInEnum,
+  stringIsInEnumOrThrow,
+} from '../validator-helper.js';
+
+enum TestEnum {
+  FOO = 'FOO',
+  BAR = 'BAR',
+}
+
+describe('validator-helper', () => {
+  it('should match enum values case-insensitively', () => {
+    expect(stringIsInEnum('foo', TestEnum)).toBe(true);
+    expect(stringIsInEnum('Bar', TestEnum)).toBe(true);
+    expect(stringIsInEnum('baz', TestEnum)).toBe(false);
+  });
+
+  it('should throw with default message when value is invalid', () => {
+    expect(() => stringIsInEnumOrThrow('missing', TestEnum)).toThrow(
+      'Invalid value missing',
+    );
+  });
+
+  it('should allow custom error messages', () => {
+    expect(() =>
+      stringIsInEnumOrThrow('invalid', TestEnum, 'custom message'),
+    ).toThrow('custom message');
+  });
+
+  it('should return true when value is valid', () => {
+    expect(stringIsInEnumOrThrow('foo', TestEnum)).toBe(true);
+  });
+});

package/src/__tests__/zlib.helper.spec.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from '@jest/globals';
+import { inflate, deflate } from '../zlib.helper.js';
+
+describe('zlib helpers', () => {
+  it('should return input when inflate/deflate fail', () => {
+    const plain = 'not-base64';
+    expect(inflate(plain)).toBe(plain);
+
+    const invalidInput: any = { invalid: true };
+    expect(deflate(invalidInput)).toBe(invalidInput);
+  });
+
+  it('should deflate and inflate valid payloads', () => {
+    const payload = 'hello';
+    const deflated = deflate(payload) as Buffer;
+    expect(deflated).toBeInstanceOf(Buffer);
+    const inflated = inflate(deflated.toString('base64'));
+    expect(inflated).toBe(payload);
+  });
+});

package/src/class.helper.d.ts

@@ -0,0 +1,4 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+export declare function isNativeClass<T = any>(func: any, className?: string): func is ClassType<T>;
+export declare function isES6Class<T = any>(func: any, className?: string): func is ClassType<T>;
+export declare function isClass<T = any>(func: any, className?: string): func is ClassType<T>;

package/src/class.helper.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNativeClass = isNativeClass;
+exports.isES6Class = isES6Class;
+exports.isClass = isClass;
+function isNativeClass(func, className) {
+    return (typeof func === 'function' &&
+        func.prototype?.constructor === func &&
+        (className ? func.name === className : true));
+}
+function isES6Class(func, className) {
+    return (typeof func === 'function' &&
+        /^class\s/.test(func.toString()) &&
+        (className ? func.name === className : true));
+}
+function isClass(func, className) {
+    return isNativeClass(func, className) || isES6Class(func, className);
+}
+//# sourceMappingURL=class.helper.js.map

package/src/class.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"class.helper.js","sourceRoot":"","sources":["class.helper.ts"],"names":[],"mappings":";;AAGA,sCASC;AAGD,gCASC;AAGD,0BAKC;AA7BD,SAAgB,aAAa,CAC3B,IAAS,EACT,SAAkB;IAElB,OAAO,CACL,OAAO,IAAI,KAAK,UAAU;QAC1B,IAAI,CAAC,SAAS,EAAE,WAAW,KAAK,IAAI;QACpC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAC7C,CAAC;AACJ,CAAC;AAGD,SAAgB,UAAU,CACxB,IAAS,EACT,SAAkB;IAElB,OAAO,CACL,OAAO,IAAI,KAAK,UAAU;QAC1B,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAC7C,CAAC;AACJ,CAAC;AAGD,SAAgB,OAAO,CACrB,IAAS,EACT,SAAkB;IAElB,OAAO,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,UAAU,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;AACvE,CAAC"}

package/src/class.helper.ts

@@ -0,0 +1,33 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+
+// Check if the class is a native class (like Error, Array, etc.)
+export function isNativeClass<T = any>(
+  func: any,
+  className?: string,
+): func is ClassType<T> {
+  return (
+    typeof func === 'function' &&
+    func.prototype?.constructor === func && // Native class constructors have this prototype constructor link
+    (className ? func.name === className : true)
+  );
+}
+
+// Check if the class is an ES6-style class
+export function isES6Class<T = any>(
+  func: any,
+  className?: string,
+): func is ClassType<T> {
+  return (
+    typeof func === 'function' &&
+    /^class\s/.test(func.toString()) && // ES6 classes start with the keyword "class"
+    (className ? func.name === className : true)
+  );
+}
+
+// Check if the class is either native or ES6
+export function isClass<T = any>(
+  func: any,
+  className?: string,
+): func is ClassType<T> {
+  return isNativeClass(func, className) || isES6Class(func, className);
+}

package/src/command.helper.d.ts

@@ -0,0 +1 @@
+export declare const commandWithErrors: (command: (...args: any[]) => Promise<any>) => (...args: any[]) => Promise<void>;