@node-c/core 1.0.0-alpha9 → 1.0.0-beta0

package/src/common/utils/getNested/getNested.spec.ts

@@ -0,0 +1,151 @@
+import { strict as assert } from 'assert';
+
+import { getNested } from '../../dist';
+
+describe('getNested', function () {
+  it('should execute successfully and return undefined if an undefined parent argument is provided', function () {
+    const result = getNested(undefined, 'test');
+    assert.strictEqual(result, undefined, `bad value ${result} for the method execution result, expected undefined`);
+  });
+  it('should execute successfully and return undefined if a null parent argument is provided', function () {
+    const result = getNested(null, 'test');
+    assert.strictEqual(result, undefined, `bad value ${result} for the method execution result, expected undefined`);
+  });
+  it('should execute successfully and return undefined if an empty string field argument is provided', function () {
+    const result = getNested({}, '');
+    assert.strictEqual(result, undefined, `bad value ${result} for the method execution result, expected undefined`);
+  });
+  it('should execute successfully and return undefined if the field does not exist in the parent at the top level', function () {
+    const result = getNested({}, 'foo.bar');
+    assert.strictEqual(result, undefined, `bad value ${result} for the method execution result, expected undefined`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent and there are no arrays in the path', function () {
+    const result = getNested({ foo: { bar: 'test' } }, 'foo.bar');
+    assert.strictEqual(result, 'test', `bad value ${result} for the method execution result, expected ${'test'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, there are arrays in the path and an index is provided', function () {
+    const result = getNested(
+      { foo: [{ bar: 'test' }, { bar: 'test2' }, { bar: 'test' }, { bar: 'test3' }] },
+      'foo.0.bar'
+    );
+    assert.strictEqual(result, 'test', `bad value ${result} for result, expected ${'test'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, there are arrays in the path, no index is provided and arrayItemsShouldBeUnique is not provided', function () {
+    const result = getNested(
+      { foo: [{ bar: 'test' }, { bar: 'test2' }, { bar: 'test' }, { bar: 'test3' }, { ab: 'test4' }] },
+      'foo.bar'
+    );
+    assert.strictEqual(result.length, 4, `bad value ${result.length} for result.length, expected ${4}`);
+    assert.strictEqual(result[0], 'test', `bad value ${result[0]} for result[0], expected ${'test'}`);
+    assert.strictEqual(result[1], 'test2', `bad value ${result[1]} for result[1], expected ${'test2'}`);
+    assert.strictEqual(result[2], 'test', `bad value ${result[2]} for result[2], expected ${'test'}`);
+    assert.strictEqual(result[3], 'test3', `bad value ${result[3]} for result[3], expected ${'test3'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, there are arrays in the path, no index is provided and arrayItemsShouldBeUnique is set to true', function () {
+    const result = getNested(
+      { foo: [{ bar: 'test' }, { bar: 'test2' }, { bar: 'test' }, { bar: 'test3' }] },
+      'foo.bar',
+      {
+        arrayItemsShouldBeUnique: true
+      }
+    );
+    assert.strictEqual(result.length, 3, `bad value ${result.length} for result.length, expected ${3}`);
+    assert.strictEqual(result[0], 'test', `bad value ${result[0]} for result[0], expected ${'test'}`);
+    assert.strictEqual(result[1], 'test2', `bad value ${result[1]} for result[1], expected ${'test2'}`);
+    assert.strictEqual(result[2], 'test3', `bad value ${result[2]} for result[2], expected ${'test3'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, it has an $ in the field name and there are no arrays in the path', function () {
+    const result = getNested({ foo: { $bar: { q: 'test' } } }, 'foo.$bar.q');
+    assert.strictEqual(result, 'test', `bad value ${result} for the method execution result, expected ${'test'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, it has an $ in the field name, there are arrays in the path and arrayItemsShouldBeUnique is not provided', function () {
+    const result = getNested(
+      { foo: [{ $bar: { q: 'test' } }, { $bar: { q: 'test2' } }, { $bar: { q: 'test' } }, { $bar: { q: 'test3' } }] },
+      'foo.$bar.q'
+    );
+    assert.strictEqual(result.length, 4, `bad value ${result.length} for result.length, expected ${4}`);
+    assert.strictEqual(result[0], 'test', `bad value ${result[0]} for result[0], expected ${'test'}`);
+    assert.strictEqual(result[1], 'test2', `bad value ${result[1]} for result[1], expected ${'test2'}`);
+    assert.strictEqual(result[2], 'test', `bad value ${result[2]} for result[2], expected ${'test'}`);
+    assert.strictEqual(result[3], 'test3', `bad value ${result[3]} for result[3], expected ${'test3'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, it has an $ in the field name, there are arrays in the path and arrayItemsShouldBeUnique is set to true', function () {
+    const result = getNested(
+      { foo: [{ $bar: { q: 'test' } }, { $bar: { q: 'test2' } }, { $bar: { q: 'test' } }, { $bar: { q: 'test3' } }] },
+      'foo.$bar.q',
+      { arrayItemsShouldBeUnique: true }
+    );
+    assert.strictEqual(result.length, 3, `bad value ${result.length} for result.length, expected ${3}`);
+    assert.strictEqual(result[0], 'test', `bad value ${result[0]} for result[0], expected ${'test'}`);
+    assert.strictEqual(result[1], 'test2', `bad value ${result[1]} for result[1], expected ${'test2'}`);
+    assert.strictEqual(result[2], 'test3', `bad value ${result[2]} for result[2], expected ${'test3'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, it has an $$ in the field name and there are no arrays in the path', function () {
+    const result = getNested({ foo: { '$bar.baz$': { q: 'test' } } }, 'foo.$bar.baz$.q');
+    assert.strictEqual(result, 'test', `bad value ${result} for the method execution result, expected ${'test'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, it has an $$ in the field name, there are no arrays in the path and there is a $ variable name', function () {
+    const result = getNested({ foo: { $bar: { '$p.baz$': { q: 'test' } } } }, 'foo.$bar.$p.baz$.q');
+    assert.strictEqual(result, 'test', `bad value ${result} for the method execution result, expected ${'test'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, it has an $$ in the field name, there are arrays in the path and arrayItemsShouldBeUnique is not provided', function () {
+    const result = getNested(
+      {
+        foo: [
+          { '$bar.baz$': { q: 'test' } },
+          { '$bar.baz$': { q: 'test2' } },
+          { '$bar.baz$': { q: 'test' } },
+          { '$bar.baz$': { q: 'test3' } }
+        ]
+      },
+      'foo.$bar.baz$.q'
+    );
+    assert.strictEqual(result.length, 4, `bad value ${result.length} for result.length, expected ${4}`);
+    assert.strictEqual(result[0], 'test', `bad value ${result[0]} for result[0], expected ${'test'}`);
+    assert.strictEqual(result[1], 'test2', `bad value ${result[1]} for result[1], expected ${'test2'}`);
+    assert.strictEqual(result[2], 'test', `bad value ${result[2]} for result[2], expected ${'test'}`);
+    assert.strictEqual(result[3], 'test3', `bad value ${result[3]} for result[3], expected ${'test3'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, it has an $$ in the field name, there are arrays in the path and arrayItemsShouldBeUnique is set to true', function () {
+    const result = getNested(
+      {
+        foo: [
+          { '$bar.baz$': { q: 'test' } },
+          { '$bar.baz$': { q: 'test2' } },
+          { '$bar.baz$': { q: 'test' } },
+          { '$bar.baz$': { q: 'test3' } }
+        ]
+      },
+      'foo.$bar.baz$.q',
+      { arrayItemsShouldBeUnique: true }
+    );
+    assert.strictEqual(result.length, 3, `bad value ${result.length} for result.length, expected ${3}`);
+    assert.strictEqual(result[0], 'test', `bad value ${result[0]} for result[0], expected ${'test'}`);
+    assert.strictEqual(result[1], 'test2', `bad value ${result[1]} for result[1], expected ${'test2'}`);
+    assert.strictEqual(result[2], 'test3', `bad value ${result[2]} for result[2], expected ${'test3'}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent and the last element is an array', function () {
+    const result = getNested({ foo: { bar: [] } }, 'foo.bar');
+    assert(result instanceof Array, `bad value ${result} for the method execution result, expected an array`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, an inner element is an array and arrayItemsShouldBeUnique is not provided', function () {
+    const result = getNested({ foo: { bar: [{ baz: [{ q: 10 }] }, { baz: { q: 11 } }] } }, 'foo.bar.baz.q');
+    assert(result instanceof Array, `bad value ${result} for the method execution result, expected an array`);
+    assert.strictEqual(result.length, 2, `bad value ${result.length} for result.length, expected ${2}`);
+    assert.strictEqual(result[0], 10, `bad value ${result[0]} for result[0], expected ${10}`);
+    assert.strictEqual(result[1], 11, `bad value ${result[1]} for result[1], expected ${11}`);
+  });
+  it('should execute successfully and return the child field if the field does exist in the parent, an inner element is an array and arrayItemsShouldBeUnique is set to true', function () {
+    const result = getNested(
+      { foo: { bar: [{ baz: [{ q: 10 }, { q: 12 }, { q: 13 }, { q: 12 }] }, { baz: { q: 11 } }] } },
+      'foo.bar.baz.q',
+      { arrayItemsShouldBeUnique: true }
+    );
+    assert(result instanceof Array, `bad value ${result} for the method execution result, expected an array`);
+    assert.strictEqual(result.length, 4, `bad value ${result.length} for result.length, expected ${2}`);
+    assert.strictEqual(result[0], 10, `bad value ${result[0]} for result[0], expected ${10}`);
+    assert.strictEqual(result[1], 12, `bad value ${result[1]} for result[1], expected ${12}`);
+    assert.strictEqual(result[2], 13, `bad value ${result[2]} for result[2], expected ${13}`);
+    assert.strictEqual(result[3], 11, `bad value ${result[3]} for result[3], expected ${11}`);
+  });
+});

package/src/common/utils/getNested/index.ts

@@ -0,0 +1,2 @@
+export * from './getNested.definitions';
+export * from './getNested.method';

package/src/common/utils/httpRequest/httpRequest.definitions.ts

@@ -0,0 +1,22 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+
+import { GenericObject, HttpMethod } from '../../definitions';
+
+export interface HTTPRequestData {
+  axiosConfig?: Partial<AxiosRequestConfig>;
+  body?: GenericObject<unknown>;
+  headers?: GenericObject<unknown>;
+  isFormData?: boolean;
+  isJSON?: boolean;
+  method?: HttpMethod;
+  query?: GenericObject<unknown>;
+  returnFullResponse?: boolean;
+  throwOnError?: boolean;
+}
+
+export interface HTTPRequestResponseData<Data = unknown> {
+  data?: Data;
+  fullResponse?: Omit<AxiosResponse, 'config' | 'request'>;
+  hasError: boolean;
+  statusCode: number;
+}

package/src/common/utils/httpRequest/httpRequest.method.ts

@@ -0,0 +1,46 @@
+import axios, { AxiosHeaders } from 'axios';
+import ld from 'lodash';
+
+import { HTTPRequestData, HTTPRequestResponseData } from './httpRequest.definitions';
+
+import { ApplicationError, GenericObject, HttpMethod } from '../../definitions';
+
+export const httpRequest = async <ResponseData = unknown>(
+  url: string,
+  data: HTTPRequestData
+): Promise<HTTPRequestResponseData<ResponseData>> => {
+  const { body, query } = data;
+  const headers: GenericObject<unknown> = { ...(data.headers || {}) };
+  const method = data.method || HttpMethod.GET;
+  const requestConfig = {
+    ...(data.axiosConfig || {}),
+    method,
+    url
+  };
+  if (query && method === HttpMethod.GET) {
+    requestConfig.params = query;
+  } else if (body && method !== HttpMethod.GET) {
+    requestConfig.data = body;
+  }
+  if (data.isJSON) {
+    headers['Content-Type'] = 'application/json';
+    requestConfig.responseType = 'json';
+  } else if (data.isFormData) {
+    headers['Content-Type'] = 'application/x-www-form-urlencoded';
+  }
+  requestConfig.headers = headers as AxiosHeaders;
+  const response = await axios(requestConfig);
+  const { status } = response;
+  const usefulResponse = ld.omit(response, ['config', 'request']);
+  const hasError = status >= 400;
+  if (hasError && data.throwOnError) {
+    throw new ApplicationError(`An httpRequest error with statusCode ${status} has occurred.`, usefulResponse);
+  }
+  const returnData: HTTPRequestResponseData<ResponseData> = { hasError, statusCode: status };
+  if (data.returnFullResponse) {
+    returnData.fullResponse = usefulResponse;
+  } else if (response.data) {
+    returnData.data = response.data;
+  }
+  return returnData;
+};

package/src/common/utils/httpRequest/index.ts

@@ -0,0 +1,2 @@
+export * from './httpRequest.definitions';
+export * from './httpRequest.method';

package/src/common/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './base64UrlEncode';
+export * from './getNested';
+export * from './httpRequest';
+export * from './loadDynamicModules';
+export * from './setNested';

package/src/common/utils/loadDynamicModules/index.ts

@@ -0,0 +1 @@
+export * from './utils.loadDynamicModules';

package/src/common/utils/loadDynamicModules/utils.loadDynamicModules.spec.ts

@@ -0,0 +1,111 @@
+import { DynamicModule, Provider } from '@nestjs/common';
+import { describe, expect, it } from 'vitest';
+
+import { ProviderWithInjectionToken, loadDynamicModules } from './utils.loadDynamicModules';
+
+import { GenericObject } from '../../definitions';
+
+describe('loadDynamicModules', () => {
+  it('should return undefined for all arrays if folderData is empty', () => {
+    const result = loadDynamicModules({});
+    expect(result.controllers).toBeUndefined();
+    expect(result.entities).toBeUndefined();
+    expect(result.modules).toBeUndefined();
+    expect(result.services).toBeUndefined();
+  });
+  it('should skip keys matching /^base(.+)?$/', () => {
+    const folderData: GenericObject<unknown> = {
+      base: { name: 'base' },
+      baseExtra: { name: 'baseExtra' },
+      UserController: { name: 'UserController' }
+    };
+    const result = loadDynamicModules(folderData);
+    // Only "UserController" should be processed.
+    expect(result.controllers).toHaveLength(1);
+  });
+  it('should process keys ending with "Controller" and add injection token mapping when provided', () => {
+    const controllerWithToken = {
+      injectionToken: 'TOKEN_Controller',
+      name: 'MyController'
+    } as ProviderWithInjectionToken;
+    const controllerWithoutToken = {
+      name: 'OtherController'
+    } as ProviderWithInjectionToken;
+    const folderData: GenericObject<unknown> = {
+      MyController: controllerWithToken,
+      OtherController: controllerWithoutToken
+    };
+    const result = loadDynamicModules(folderData);
+    // For controller keys, if injectionToken is present, the function pushes a mapped provider and then the original.
+    expect(result.controllers).toHaveLength(3);
+    // Verify that one of the controllers is an object with a "provide" property matching the injection token.
+    const tokenProviders = result.controllers?.filter(c => typeof c === 'object' && 'provide' in c) as Provider[];
+    expect(tokenProviders).toHaveLength(1);
+    expect(tokenProviders[0]).toHaveProperty('provide', 'TOKEN_Controller');
+  });
+  it('should process keys ending with "Entity"', () => {
+    const entity1 = { id: 1 };
+    const entity2 = { id: 2 };
+    const folderData: GenericObject<unknown> = {
+      UserEntity: entity1,
+      OrderEntity: entity2
+    };
+    const result = loadDynamicModules(folderData);
+    expect(result.entities).toHaveLength(2);
+    expect(result.entities).toEqual([entity1, entity2]);
+  });
+  it('should process keys ending with "Module" as DynamicModule', () => {
+    const module1: DynamicModule = { module: (() => {}) as unknown as DynamicModule['module'] };
+    const module2: DynamicModule = { module: (() => {}) as unknown as DynamicModule['module'] };
+    const folderData: GenericObject<unknown> = {
+      AppModule: module1,
+      FeatureModule: module2
+    };
+    const result = loadDynamicModules(folderData);
+    expect(result.modules).toHaveLength(2);
+    expect(result.modules).toEqual([module1, module2]);
+  });
+  it('should process keys ending with "Service" and add injection token mapping when provided', () => {
+    const serviceWithToken = {
+      injectionToken: 'TOKEN_Service',
+      name: 'MyService'
+    } as ProviderWithInjectionToken;
+    const serviceWithoutToken = {
+      name: 'OtherService'
+    } as ProviderWithInjectionToken;
+    const folderData: GenericObject<unknown> = {
+      MyService: serviceWithToken,
+      OtherService: serviceWithoutToken
+    };
+    const result = loadDynamicModules(folderData);
+    // Expect two entries for MyService (mapped + original) and one for OtherService.
+    expect(result.services).toHaveLength(3);
+    const tokenProviders = result.services?.filter(s => typeof s === 'object' && 'provide' in s) as Provider[];
+    expect(tokenProviders).toHaveLength(1);
+    expect(tokenProviders[0]).toHaveProperty('provide', 'TOKEN_Service');
+  });
+  it('should ignore keys that do not match any expected pattern', () => {
+    const folderData: GenericObject<unknown> = {
+      RandomKey: { data: 123 },
+      AnotherKey: { data: 'abc' }
+    };
+    const result = loadDynamicModules(folderData);
+    expect(result.controllers).toBeUndefined();
+    expect(result.entities).toBeUndefined();
+    expect(result.modules).toBeUndefined();
+    expect(result.services).toBeUndefined();
+  });
+  it('should be case-insensitive for the first letter when matching patterns', () => {
+    const folderData: GenericObject<unknown> = {
+      usercontroller: { name: 'lowerCaseController' },
+      OrderEntity: { id: 10 },
+      Featuremodule: { module: (() => {}) as unknown as DynamicModule['module'] },
+      paymentService: { name: 'mixedService' }
+    };
+    const result = loadDynamicModules(folderData);
+    expect(result.controllers).toHaveLength(1);
+    expect(result.entities).toHaveLength(1);
+    expect(result.modules).toHaveLength(1);
+    expect(result.services).toHaveLength(1);
+  });
+});

package/src/common/utils/loadDynamicModules/utils.loadDynamicModules.ts

@@ -0,0 +1,69 @@
+import { ClassProvider, DynamicModule, Provider } from '@nestjs/common';
+
+import { GenericObject } from '../../definitions';
+
+export type ProviderWithInjectionToken = Provider & {
+  injectionToken?: string;
+};
+
+export const loadDynamicModules = (
+  folderData: GenericObject<unknown>,
+  options?: { moduleRegisterOptions?: unknown; registerOptionsPerModule?: GenericObject }
+): { controllers?: Provider[]; entities?: unknown[]; modules?: DynamicModule[]; services?: Provider[] } => {
+  const { moduleRegisterOptions, registerOptionsPerModule } = options || {};
+  const controllers: Provider[] = [];
+  const entities: unknown[] = [];
+  const modules: DynamicModule[] = [];
+  const services: Provider[] = [];
+  for (const key in folderData) {
+    const actualKey = key as keyof typeof folderData;
+    if (key.match(/^base(.+)?$/)) {
+      continue;
+    }
+    if (key.match(/[cC]ontroller$/)) {
+      const FolderDataItem = folderData[actualKey] as ProviderWithInjectionToken;
+      if (FolderDataItem.injectionToken) {
+        controllers.push({
+          provide: FolderDataItem.injectionToken,
+          useClass: FolderDataItem as ClassProvider['useClass']
+        });
+        // continue;
+      }
+      controllers.push(FolderDataItem);
+      continue;
+    }
+    if (key.match(/[eE]ntity$/)) {
+      entities.push(folderData[actualKey]);
+      continue;
+    }
+    if (key.match(/[mM]odule$/)) {
+      const moduleClass = folderData[actualKey] as DynamicModule & {
+        register?: (..._args: unknown[]) => DynamicModule;
+      };
+      modules.push(
+        moduleClass.register
+          ? moduleClass.register(registerOptionsPerModule?.[key] || moduleRegisterOptions)
+          : moduleClass
+      );
+      continue;
+    }
+    if (key.match(/[sS]ervice$/)) {
+      const FolderDataItem = folderData[actualKey] as ProviderWithInjectionToken;
+      if (FolderDataItem.injectionToken) {
+        services.push({
+          provide: FolderDataItem.injectionToken,
+          useClass: FolderDataItem as ClassProvider['useClass']
+        });
+        // continue;
+      }
+      services.push(FolderDataItem);
+      continue;
+    }
+  }
+  return {
+    controllers: controllers.length ? controllers : undefined,
+    entities: entities.length ? entities : undefined,
+    modules: modules.length ? modules : undefined,
+    services: services.length ? services : undefined
+  };
+};

package/src/common/utils/setNested/index.ts

@@ -0,0 +1,2 @@
+export * from './setNested.definitions';
+export * from './setNested.method';

package/src/common/utils/setNested/setNested.definitions.ts

@@ -0,0 +1,4 @@
+export interface SetNestedOptions {
+  removeNestedFieldEscapeSign?: boolean;
+  setNestedArraysPerIndex?: boolean;
+}

package/src/common/utils/setNested/setNested.method.ts

@@ -0,0 +1,83 @@
+import { SetNestedOptions } from './setNested.definitions';
+
+// TODO: implement setNestedArraysPerIndex
+/**
+ * Sets a value in a deeply nested object, for example foo.bar.0.baz in {foo: {bar: [{baz: 'test'}]}}.
+ * @param parent (required) - The object to set the value in.
+ * @param field (required) - The path to the field.
+ * @param value (required) - The value to set.
+ * @returns boolean true if successful, false if not found
+ */
+export function setNested(parent: unknown, field: string, value: unknown, options?: SetNestedOptions): boolean {
+  const { removeNestedFieldEscapeSign } = options || {};
+  const fieldNames = field.split('.');
+  if (field === '' || !fieldNames.length) {
+    return false;
+  }
+  let currentParent = parent;
+  let finalResult = false;
+  const loopEnd = fieldNames.length - 1;
+  for (let i = 0; i <= loopEnd; i++) {
+    if (currentParent === null) {
+      return false;
+    }
+    let fieldName = fieldNames[i];
+    // TODO: setNested for specific indexes
+    // if the current parent is an array and the next field path item is not an index - set the value in all of the array's sub-items
+    if (currentParent instanceof Array && isNaN(parseInt(fieldName, 10))) {
+      let atLeastOnItemSet = false,
+        nestedFieldPath = `${fieldName}`;
+      for (let j = i + 1; j <= loopEnd; j++) {
+        nestedFieldPath += `.${fieldNames[j]}`;
+      }
+      currentParent.forEach(item => {
+        const result = setNested(item, nestedFieldPath, value);
+        if (result && !atLeastOnItemSet) {
+          atLeastOnItemSet = true;
+        }
+      });
+      return atLeastOnItemSet;
+    }
+    // logic for handling Sequelize-style $foo.bar$ - should be treated as a single element
+    if (fieldName.charAt(0) === '$') {
+      let closingBracketFound = false,
+        closingBracketIndex = i + 1;
+      while (closingBracketIndex <= loopEnd) {
+        const element = fieldNames[closingBracketIndex];
+        // false alarm - there's another $ opening before the current one closed - so the current one must be just a variable name, not a bracket
+        if (element.charAt(0) === '$') {
+          break;
+        }
+        // found it !
+        if (element.charAt(element.length - 1) === '$') {
+          closingBracketFound = true;
+          break;
+        }
+        closingBracketIndex++;
+      }
+      if (closingBracketFound) {
+        for (let j = i + 1; j <= closingBracketIndex; j++) {
+          fieldName += `.${fieldNames[j]}`;
+        }
+        if (removeNestedFieldEscapeSign) {
+          fieldName = fieldName.replace(/^\$/, '').replace(/\$$/, '');
+        }
+        if (closingBracketIndex === loopEnd) {
+          (currentParent as Record<string, unknown>)[fieldName] = value;
+          return true;
+        }
+        i = closingBracketIndex;
+      }
+    }
+    if (i === loopEnd) {
+      (currentParent as Record<string, unknown>)[fieldName] = value;
+      finalResult = true;
+      break;
+    }
+    if (typeof (currentParent as Record<string, unknown>)[fieldName] === 'undefined') {
+      (currentParent as Record<string, unknown>)[fieldName] = {};
+    }
+    currentParent = (currentParent as Record<string, unknown>)[fieldName];
+  }
+  return finalResult;
+}