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

package/src/common/configProvider/configProvider.service.spec.ts

@@ -0,0 +1,206 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+import im from 'immutable';
+import { mergeDeepRight } from 'ramda';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  AppConfig,
+  AppConfigCommon,
+  AppEnvironment,
+  GenerateOrmconfigOptions,
+  LoadConfigAppConfigs
+} from './configProvider.definitions';
+import { ConfigProviderService } from './configProvider.service';
+
+const BASE_PATH = path.join(__dirname, '../../../test');
+
+describe('ConfigProviderService', () => {
+  describe('constructor', () => {
+    it('should assign the passed config to the service', () => {
+      const fakeConfig: AppConfig = {
+        api: {},
+        domain: {},
+        general: {
+          environment: AppEnvironment.Local,
+          projectName: 'TestProject',
+          projectRootPath: '/some/path',
+          projectVersion: '1.0.0'
+        },
+        data: {}
+      };
+      const service = new ConfigProviderService(fakeConfig);
+      expect(service.config).toEqual(fakeConfig);
+    });
+  });
+
+  // generateOrmconfig
+  describe('generateOrmconfig', () => {
+    const defaultFakeModuleName = 'db';
+    const defaultFakeOptions: GenerateOrmconfigOptions = {
+      entitiesPathInModule: 'entities',
+      migrationsPathInModule: 'migrations',
+      moduleName: defaultFakeModuleName,
+      modulePathInProject: 'src/data/db'
+    };
+    const defaultFakeConfig: AppConfig = {
+      api: {},
+      domain: {},
+      general: {
+        environment: AppEnvironment.Local,
+        projectName: 'TestProject',
+        projectRootPath: BASE_PATH,
+        projectVersion: '1.0.0'
+      },
+      data: {
+        [defaultFakeModuleName]: { type: 'mysql', extra: 'foo' }
+      }
+    };
+    let fakeModuleName: string;
+    let fakeOptions: GenerateOrmconfigOptions;
+    let fakeConfig: AppConfig;
+    let entitiesDirPath: string;
+    let migrationsPath: string;
+    let ormConfigPath: string;
+    // clean up before each test
+    beforeEach(async () => {
+      fakeModuleName = defaultFakeModuleName;
+      fakeOptions = im.fromJS(defaultFakeOptions).toJS() as unknown as GenerateOrmconfigOptions;
+      fakeConfig = im.fromJS(defaultFakeConfig).toJS() as unknown as AppConfig;
+      entitiesDirPath = path.join(BASE_PATH, fakeOptions.modulePathInProject, fakeOptions.entitiesPathInModule);
+      migrationsPath = path.join(BASE_PATH, fakeOptions.modulePathInProject, fakeOptions.migrationsPathInModule);
+      ormConfigPath = path.join(BASE_PATH, `ormconfig-${fakeModuleName}.json`);
+      try {
+        await fs.unlink(ormConfigPath);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      } catch (_e: unknown) {}
+    });
+    it('should generate ormconfig file with entities and subscribers arrays correctly', async () => {
+      await ConfigProviderService.generateOrmconfig(fakeConfig, fakeOptions);
+      const expectedEntities = [
+        path.join(entitiesDirPath, 'orders', 'orders.entity.ts'),
+        path.join(entitiesDirPath, 'users', 'users.entity.ts')
+      ];
+      const expectedSubscribers = [
+        path.join(entitiesDirPath, 'orders', 'orders.subscriber.ts'),
+        path.join(entitiesDirPath, 'users', 'users.subscriber.ts')
+      ];
+      const expectedMergedConfig = mergeDeepRight(fakeConfig.data[fakeModuleName], {
+        entities: expectedEntities,
+        subscribers: expectedSubscribers,
+        migrations: [`${migrationsPath}/**/*.ts`],
+        cli: { migrationsDir: migrationsPath }
+      });
+      expect((await fs.readFile(ormConfigPath)).toString()).toEqual(JSON.stringify(expectedMergedConfig));
+    });
+    it('should handle case with empty entities directory (no folders)', async () => {
+      fakeOptions.entitiesPathInModule = 'entitiesEmpty';
+      await ConfigProviderService.generateOrmconfig(fakeConfig, fakeOptions);
+      const expectedMergedConfig = mergeDeepRight(fakeConfig.data[fakeModuleName], {
+        entities: [],
+        subscribers: [],
+        migrations: [`${migrationsPath}/**/*.ts`],
+        cli: { migrationsDir: migrationsPath }
+      });
+      expect((await fs.readFile(ormConfigPath)).toString()).toEqual(JSON.stringify(expectedMergedConfig));
+    });
+    it('should ignore files that do not match entity or subscriber patterns', async () => {
+      await ConfigProviderService.generateOrmconfig(fakeConfig, fakeOptions);
+      const writtenConfig = JSON.parse((await fs.readFile(ormConfigPath)).toString());
+      expect(writtenConfig.entities).toEqual(
+        expect.arrayContaining([
+          path.join(entitiesDirPath, 'users', 'users.entity.ts'),
+          path.join(entitiesDirPath, 'orders', 'orders.entity.ts')
+        ])
+      );
+      expect(writtenConfig.entities).not.toEqual(
+        expect.arrayContaining([
+          path.join(entitiesDirPath, 'misc', 'note.txt'),
+          path.join(entitiesDirPath, 'misc', 'helper.ts')
+        ])
+      );
+    });
+    it('should propagate error if fs.readdir fails', async () => {
+      fakeOptions.entitiesPathInModule = 'entitiesNotExistent';
+      await expect(ConfigProviderService.generateOrmconfig(fakeConfig, fakeOptions)).rejects.toThrow('ENOENT');
+    });
+  });
+
+  // loadConfig
+  describe('loadConfig', () => {
+    const defaultAppConfigs: LoadConfigAppConfigs = {
+      appConfigCommon: {
+        general: {
+          projectName: 'TestProject',
+          projectRootPath: BASE_PATH,
+          projectVersion: '1.0.0'
+        },
+        api: {
+          test: {}
+        },
+        domain: {},
+        data: {}
+      },
+      appConfigProfileLocal: {
+        general: { environment: AppEnvironment.Local }
+      }
+    };
+    const defaultEnvKeys = {
+      API: {
+        HTTP: { HOST: 'hostname', PORT: 'port' }
+      }
+    };
+    const defaultEnvKeysParentNames = {
+      API: {
+        children: { TEST: 'test' },
+        name: 'api'
+      }
+    };
+    let appConfigs: LoadConfigAppConfigs;
+
+    beforeEach(() => {
+      process.env.NODE_ENV = 'local';
+      appConfigs = im.fromJS(defaultAppConfigs).toJS() as unknown as LoadConfigAppConfigs;
+    });
+    it('should load and merge configuration from env file and populate nested values', async () => {
+      delete process.env['NODE_ENV'];
+      const loadedConfig = await ConfigProviderService.loadConfig(appConfigs, {
+        envKeys: defaultEnvKeys,
+        envKeysParentNames: defaultEnvKeysParentNames
+      });
+      expect(loadedConfig.general.environment).toBe('local');
+      expect(loadedConfig.api).toBeDefined();
+      expect(loadedConfig.api.rest).toBeUndefined();
+      expect(loadedConfig.api.test).toBeDefined();
+      expect(loadedConfig.api.test.hostname).toBe('127.0.0.1');
+      expect(loadedConfig.api.test.port).toBe('3000');
+    });
+    it('should use default envKeys and envKeysParentNames if options not provided', async () => {
+      appConfigs.appConfigCommon.api!.rest = {};
+      const loadedConfig = await ConfigProviderService.loadConfig(appConfigs);
+      expect(loadedConfig.general.environment).toBe('local');
+      expect(loadedConfig.api.rest).toBeDefined();
+      expect(loadedConfig.api.rest.hostname).toBe('localhost');
+      expect(loadedConfig.api.test.hostname).toBeUndefined();
+    });
+    it('should throw an error if the .env file is missing', async () => {
+      (appConfigs.appConfigCommon as AppConfigCommon).general.projectRootPath = '/fake/path';
+      await expect(
+        ConfigProviderService.loadConfig(appConfigs, {
+          envKeys: defaultEnvKeys,
+          envKeysParentNames: defaultEnvKeysParentNames
+        })
+      ).rejects.toThrow('ENOENT');
+    });
+    it('should skip env keys that do not match expected pattern', async () => {
+      const loadedConfig = await ConfigProviderService.loadConfig(appConfigs, {
+        envKeys: defaultEnvKeys,
+        envKeysParentNames: defaultEnvKeysParentNames
+      });
+      expect(loadedConfig.api.test.hostname).toBe('127.0.0.1');
+      expect(loadedConfig.api.test.port).toBe('3000');
+      expect(loadedConfig.api.something).toBeUndefined();
+    });
+  });
+});

package/src/common/configProvider/configProvider.service.ts

@@ -0,0 +1,204 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+import { Inject, Injectable } from '@nestjs/common';
+import dotenv from 'dotenv';
+import ld from 'lodash';
+
+import {
+  APP_CONFIG_FROM_ENV_KEYS as APP_CONFIG_FROM_ENV_KEYS_DEFAULT,
+  APP_CONFIG_FROM_ENV_KEYS_PARENT_NAMES as APP_CONFIG_FROM_ENV_KEYS_PARENT_NAMES_DEFAULT,
+  AppConfigDataRDB,
+  AppConfig as AppConfigDefault,
+  AppEnvironment,
+  GenerateOrmconfigOptions,
+  LoadConfigAppConfigs,
+  LoadConfigOptions,
+  RDBType
+} from './configProvider.definitions';
+
+import { Constants } from '../definitions';
+import { setNested } from '../utils';
+
+@Injectable()
+export class ConfigProviderService<AppConfig extends AppConfigDefault = AppConfigDefault> {
+  constructor(
+    @Inject(Constants.CONFIG)
+    // eslint-disable-next-line no-unused-vars
+    public config: AppConfig
+  ) {}
+
+  // TODO: consider moving this into the data-rdb package
+  static async generateOrmconfig<AppConfig extends AppConfigDefault = AppConfigDefault>(
+    config: AppConfig,
+    options: GenerateOrmconfigOptions
+  ): Promise<void> {
+    const {
+      general: { projectRootPath },
+      data
+    } = config;
+    const { entitiesPathInModule, migrationsPathInModule, moduleName, modulePathInProject, seedsPathInModule } =
+      options;
+    const entitiesDirPath = path.join(projectRootPath, modulePathInProject, entitiesPathInModule);
+    const entitiesDirData = await fs.readdir(entitiesDirPath);
+    const entities: string[] = [];
+    const migrationsPath = path.join(projectRootPath, modulePathInProject, migrationsPathInModule);
+    const moduleConfig = data[moduleName] as AppConfigDataRDB;
+    const subscribers: string[] = [];
+    for (const i in entitiesDirData) {
+      const entityName = entitiesDirData[i];
+      if (entityName.match(/^base$/)) {
+        continue;
+      }
+      const entityFolderPath = path.join(entitiesDirPath, entityName);
+      const entityFolderChildItemStat = await fs.lstat(entityFolderPath);
+      if (!entityFolderChildItemStat.isDirectory()) {
+        continue;
+      }
+      const entityFolderData = await fs.readdir(entityFolderPath);
+      for (const j in entityFolderData) {
+        const entityFolderFileName = entityFolderData[j];
+        if (entityFolderFileName.match(/\.entity\./)) {
+          entities.push(path.join(entityFolderPath, entityFolderFileName));
+          continue;
+        }
+        if (entityFolderFileName.match(/\.subscriber\./)) {
+          subscribers.push(path.join(entityFolderPath, entityFolderFileName));
+          continue;
+        }
+      }
+    }
+    // write the ORM Config file
+    const ormconfigMigrations: string[] = [`${migrationsPath}/**/*.ts`];
+    if (seedsPathInModule) {
+      const baseSeedsPath = path.join(projectRootPath, modulePathInProject, seedsPathInModule);
+      ormconfigMigrations.push(`${baseSeedsPath}/common/**/*.ts`);
+    }
+    await fs.writeFile(
+      path.join(projectRootPath, `ormconfig-${moduleName}.json`),
+      JSON.stringify(
+        ld.merge(data[moduleName], {
+          cli: {
+            migrationsDir: migrationsPath
+          },
+          entities: [...entities],
+          migrations: ormconfigMigrations,
+          name: moduleConfig.connectionName,
+          synchronize: moduleConfig.type === RDBType.Aurora ? true : false,
+          subscribers: [...subscribers],
+          type: moduleConfig.type === RDBType.Aurora ? RDBType.MySQL : moduleConfig.type,
+          ...(moduleConfig.typeormExtraOptions || {})
+        })
+      )
+    );
+    // write the Datasource file
+    const entitiesPathInProject = path.join(modulePathInProject, entitiesPathInModule);
+    await fs.writeFile(
+      path.join(projectRootPath, `datasource-${moduleName}.ts`),
+      "import { loadDynamicModules } from '@node-c/core';\n" +
+        '\n' +
+        "import { DataSource } from 'typeorm';\n" +
+        '\n' +
+        `import * as FolderData from './${entitiesPathInProject}';\n` +
+        '\n' +
+        'const { entities } = loadDynamicModules(FolderData);\n' +
+        '\n' +
+        'export default new DataSource({\n' +
+        `  database: '${moduleConfig.database}',\n` +
+        '  entities: entities as unknown as string[],\n' +
+        `  host: '${moduleConfig.host}',\n` +
+        '  logging: false,\n' +
+        `  migrations: [${ormconfigMigrations.map(item => `'${item.replace(projectRootPath.replace(/\/$/, ''), '.')}'`).join(', ')}],\n` +
+        `  name: '${moduleConfig.connectionName}',\n` +
+        `  password: '${moduleConfig.password}',\n` +
+        `  port: ${moduleConfig.port},\n` +
+        '  subscribers: [],\n' +
+        `  synchronize: ${moduleConfig.type === RDBType.Aurora ? true : false},\n` +
+        `  type: '${moduleConfig.type === RDBType.Aurora ? RDBType.MySQL : moduleConfig.type}',\n` +
+        `  username: '${moduleConfig.user}'\n` +
+        '});\n'
+    );
+  }
+
+  // TODO: logging about invalid config values
+  static async loadConfig<AppConfig extends AppConfigDefault = AppConfigDefault>(
+    appConfigs: LoadConfigAppConfigs,
+    options?: LoadConfigOptions
+  ): Promise<AppConfig> {
+    const { useEnvFile, useEnvFileWithPriority, ...optionsData } = options || ({} as LoadConfigOptions);
+    const envKeys = optionsData.envKeys || APP_CONFIG_FROM_ENV_KEYS_DEFAULT;
+    const envKeysParentNames = optionsData.envKeysParentNames || APP_CONFIG_FROM_ENV_KEYS_PARENT_NAMES_DEFAULT;
+    const processEnv = process.env;
+    const envName = (processEnv['NODE_ENV'] as AppEnvironment) || AppEnvironment.Local;
+    const config = ld.merge(
+      appConfigs.appConfigCommon,
+      appConfigs[
+        `appConfigProfile${envName.charAt(0).toUpperCase()}${envName.substring(
+          1,
+          envName.length
+        )}` as keyof typeof appConfigs
+      ]
+    ) as AppConfig;
+    const moduleNamesByCategoryAndType: {
+      [moduleCategory: string]: { [moduleType: string]: string[] };
+    } = {};
+    const moduleTypesRegex = new RegExp(`^((${Object.keys(envKeys).join(')|(')}))_`);
+    config.general.environment = envName;
+    let envVars: Record<string, unknown> = processEnv;
+    if (useEnvFile) {
+      // populate the data from the .env file into the config object
+      const envVarsFromFile = dotenv.parse(
+        (await fs.readFile(path.join(config.general.projectRootPath, `envFiles/.${envName}.env`))).toString()
+      );
+      if (useEnvFileWithPriority) {
+        envVars = ld.merge(envVars, envVarsFromFile);
+      } else {
+        envVars = ld.merge(envVarsFromFile, envVars);
+      }
+    }
+    // first pass - create a list of modules by name and map them by module type
+    for (const envKey in envVars) {
+      const [, moduleCategory] = envKey.match(moduleTypesRegex) || [];
+      if (!moduleCategory) {
+        continue;
+      }
+      const [, moduleName] = envKey.match(new RegExp(`^${moduleCategory}_(.+)_MODULE_TYPE$`)) || [];
+      if (!moduleName) {
+        continue;
+      }
+      const moduleFields = envKeys[moduleCategory as keyof typeof envKeys];
+      const moduleType = envVars[envKey] as keyof typeof moduleFields;
+      if (!moduleFields[moduleType]) {
+        continue;
+      }
+      if (!moduleNamesByCategoryAndType[moduleCategory]) {
+        moduleNamesByCategoryAndType[moduleCategory] = {};
+      }
+      if (!moduleNamesByCategoryAndType[moduleCategory][moduleType]) {
+        moduleNamesByCategoryAndType[moduleCategory][moduleType] = [];
+      }
+      moduleNamesByCategoryAndType[moduleCategory][moduleType].push(moduleName);
+    }
+    // second pass - actually go through the env vars and populate them in the config accordingly
+    for (const moduleCategory in moduleNamesByCategoryAndType) {
+      const { children: moduleConfigKeysForCategory, name: categoryConfigKey } = envKeysParentNames[moduleCategory];
+      const moduleFieldsForCategory = envKeys[moduleCategory as keyof typeof envKeys];
+      const moduleNamesByType = moduleNamesByCategoryAndType[moduleCategory];
+      for (const moduleType in moduleNamesByType) {
+        const moduleFieldsForType = moduleFieldsForCategory[
+          moduleType as keyof typeof moduleFieldsForCategory
+        ] as Record<string, string>;
+        const moduleNames = moduleNamesByType[moduleType];
+        moduleNames.forEach(moduleName => {
+          const moduleConfigKey = moduleConfigKeysForCategory[moduleName];
+          for (const fieldName in moduleFieldsForType) {
+            const configKey = `${categoryConfigKey}.${moduleConfigKey}.${moduleFieldsForType[fieldName]}`;
+            const envKey = `${moduleCategory}_${moduleName}_${fieldName}`;
+            setNested(config, configKey, envVars[envKey]);
+          }
+        });
+      }
+    }
+    return config;
+  }
+}

package/src/common/configProvider/index.ts

@@ -0,0 +1,3 @@
+export * from './configProvider.definitions';
+export * from './configProvider.module';
+export * from './configProvider.service';

package/src/common/definitions/common.constants.ts

@@ -0,0 +1,27 @@
+export enum Constants {
+  // eslint-disable-next-line no-unused-vars
+  API_MODULE_NAME = 'API_MODULE_NAME',
+  // eslint-disable-next-line no-unused-vars
+  CONFIG = 'CONFIG',
+  // eslint-disable-next-line no-unused-vars
+  DOMAIN_MODULE_NAME = 'DOMAIN_MODULE_NAME',
+  // eslint-disable-next-line no-unused-vars
+  DATA_MODULE_NAME = 'DATA_MODULE_NAME'
+}
+
+export enum HttpMethod {
+  // eslint-disable-next-line no-unused-vars
+  DELETE = 'delete',
+  // eslint-disable-next-line no-unused-vars
+  GET = 'get',
+  // eslint-disable-next-line no-unused-vars
+  HEAD = 'head',
+  // eslint-disable-next-line no-unused-vars
+  OPTIONS = 'options',
+  // eslint-disable-next-line no-unused-vars
+  PATCH = 'patch',
+  // eslint-disable-next-line no-unused-vars
+  POST = 'post',
+  // eslint-disable-next-line no-unused-vars
+  PUT = 'put'
+}

package/src/common/definitions/common.definitions.ts

@@ -0,0 +1,13 @@
+export interface GenericObject<Values = unknown> {
+  [fieldName: string]: Values;
+}
+
+export class GenericObjectClass<Values = unknown> implements GenericObject<Values> {
+  [fieldName: string]: Values;
+}
+
+export type GenericObjectType<Type> =
+  | {
+      new (): Type;
+    }
+  | ((..._args: unknown[]) => unknown);

package/src/common/definitions/common.errors.ts

@@ -0,0 +1,13 @@
+import { GenericObject } from './common.definitions';
+
+export class ApplicationError implements Error {
+  data?: { errorCode?: number } | GenericObject;
+  message: string;
+  name: string;
+
+  constructor(message: string, data?: GenericObject) {
+    this.message = message;
+    this.name = 'ApplicationError';
+    this.data = data || {};
+  }
+}

package/src/common/definitions/index.ts

@@ -0,0 +1,3 @@
+export * from './common.constants';
+export * from './common.definitions';
+export * from './common.errors';

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

@@ -0,0 +1,4 @@
+export const base64UrlEncode = (buffer: ArrayBuffer | string): string => {
+  const actualBuffer = typeof buffer === 'string' ? Buffer.from(buffer, 'utf-8') : Buffer.from(buffer);
+  return actualBuffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+};

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

@@ -0,0 +1 @@
+export * from './base64UrlEncode.method';

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

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

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

@@ -0,0 +1,108 @@
+import { GetNestedOptions } from './getNested.definitions';
+
+import { GenericObject } from '../../definitions';
+
+/**
+ * Extracts a value from a deeply nested object, for example foo.bar.0.baz from {foo: {bar: [{baz: 'test'}]}}.
+ * @param parent (required) - The object to retrieve the value from.
+ * @param field (required) - The path to the field.
+ * @param options (optional) - Method executiom options, such as arrayItemsShouldBeUnique.
+ * @returns The decoded object or value.
+ */
+export function getNested<ReturnData = unknown>(
+  parent: unknown | unknown[],
+  field: string,
+  options?: GetNestedOptions
+): { paths: string[]; unifiedValue?: ReturnData | ReturnData[]; values: (ReturnData | undefined)[] } {
+  if (typeof parent !== 'object' || parent === null || !field.length) {
+    return { paths: [field], values: [] };
+  }
+  const { arrayItemsShouldBeUnique, removeNestedFieldEscapeSign } = options || {};
+  const fieldData = field.split('.');
+  const fieldDataLength = fieldData.length;
+  const paths: string[] = [];
+  const values: (ReturnData | undefined)[] = [];
+  let currentElement = parent;
+  let currentPath = '';
+  for (let i = 0; i < fieldDataLength; i++) {
+    let innerElementName = fieldData[i];
+    // logic for handling Sequelize-style $foo.bar$ - should be treated as a single element
+    if (innerElementName.charAt(0) === '$') {
+      let closingBracketFound = false,
+        closingBracketIndex = i + 1;
+      while (closingBracketIndex < fieldDataLength) {
+        const element = fieldData[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++) {
+          innerElementName += `.${fieldData[j]}`;
+        }
+        i = closingBracketIndex;
+        if (removeNestedFieldEscapeSign) {
+          innerElementName = innerElementName.replace(/^\$/, '').replace(/\$$/, '');
+        }
+      }
+    }
+    const nextElement = (currentElement as GenericObject)[innerElementName];
+    currentPath += `${currentPath.length ? '.' : ''}${innerElementName}`;
+    if (typeof nextElement === 'undefined') {
+      paths.push(currentPath);
+      break;
+    }
+    // if the next element is an array, prepare to return an array of the inner items
+    if (nextElement instanceof Array) {
+      // if this is the last item, just return the array
+      if (i === fieldDataLength - 1) {
+        paths.push(currentPath);
+        values.push(nextElement as ReturnData);
+        break;
+      }
+      // if the next item is not an index, recursively call self for each item of the array
+      if (isNaN(parseInt(fieldData[i + 1], 10))) {
+        let innerPath = '';
+        for (let j = i + 1; j < fieldDataLength; j++) {
+          innerPath += `${fieldData[j]}${j < fieldDataLength - 1 ? '.' : ''}`;
+        }
+        nextElement.forEach(item => {
+          const { paths: innerPaths, values: innerValue } = getNested(item, innerPath, options);
+          if (typeof innerValue === 'undefined') {
+            return;
+          }
+          // flatten inner arrays
+          innerValue.forEach((innerValueItem, innerValueItemIndex) => {
+            if (
+              !arrayItemsShouldBeUnique ||
+              (arrayItemsShouldBeUnique && values.indexOf(innerValueItem as ReturnData) === -1)
+            ) {
+              paths.push(`${currentPath}.${innerValueItemIndex}.${innerPaths[innerValueItemIndex]}`);
+              values.push(innerValueItem as ReturnData);
+            }
+          });
+        });
+        break;
+      }
+    }
+    currentElement = nextElement as GenericObject;
+    if (i === fieldDataLength - 1) {
+      paths.push(currentPath);
+      values.push(currentElement as ReturnData);
+    }
+  }
+  let unifiedValue = undefined;
+  if (paths.length > 1 || values.length > 1) {
+    unifiedValue = values;
+  } else {
+    unifiedValue = values[0];
+  }
+  return { paths, unifiedValue: unifiedValue as ReturnData | ReturnData[], values };
+}