@k03mad/ip2geo 19.3.3 → 20.0.0

package/tests/cache-file-subfolder.ts

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/api.ts';
+import type {ReqOutput} from '../app/types.ts';
+
+import {getCurrentFilename, getTestFolder} from './helpers/path.ts';
+import {REQUEST_IPV4} from './shared/consts.ts';
+import {checkCacheFile, removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+  const SUBFOLDERS = 5;
+
+  const opts = {
+    cacheDir: getTestFolder(path.join(...Array.from({length: SUBFOLDERS}, () => testName))),
+    cacheMap: new Map<string, ReqOutput>(),
+  };
+
+  it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+  it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+    const data = await ip2geo({ip: REQUEST_IPV4.ip ?? '', ...opts});
+    assert.deepEqual(data, REQUEST_IPV4);
+  });
+
+  it('should have cache file', () =>
+    checkCacheFile({
+      ...opts,
+      response: REQUEST_IPV4,
+    }));
+});

package/tests/cache-map-entries.ts

@@ -0,0 +1,41 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/api.ts';
+import type {ReqOutput} from '../app/types.ts';
+
+import {getCurrentFilename, getTestFolder} from './helpers/path.ts';
+import {REQUEST_IPV4, REQUEST_IPV6} from './shared/consts.ts';
+import {removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+  const opts = {
+    cacheDir: getTestFolder(testName),
+    cacheMap: new Map<string, ReqOutput>(),
+  };
+
+  it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+  it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+    const data = await ip2geo({ip: REQUEST_IPV4.ip ?? '', ...opts});
+    assert.deepEqual(data, REQUEST_IPV4);
+  });
+
+  it('should have 1 correct cache entry', () => {
+    assert.equal(opts.cacheMap.size, 1);
+    assert.deepEqual(opts.cacheMap.get(REQUEST_IPV4.ip ?? ''), REQUEST_IPV4);
+  });
+
+  it.skip(`should return correct response for IP: "${REQUEST_IPV6.ip}"`, async () => {
+    const data = await ip2geo({ip: REQUEST_IPV6.ip ?? '', ...opts});
+    assert.deepEqual(data, REQUEST_IPV6);
+  });
+
+  it.skip('should have 2 correct cache entries', () => {
+    assert.equal(opts.cacheMap.size, 2);
+    assert.deepEqual(opts.cacheMap.get(REQUEST_IPV4.ip ?? ''), REQUEST_IPV4);
+    assert.deepEqual(opts.cacheMap.get(REQUEST_IPV6.ip ?? ''), REQUEST_IPV6);
+  });
+});

package/tests/cache-map-max-entries.ts

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/api.ts';
+import type {ReqOutput} from '../app/types.ts';
+
+import {getCurrentFilename, getTestFolder} from './helpers/path.ts';
+import {removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+  const firstReqIps = ['10.10.10.10', '20.20.20.20', '30.30.30.30', '40.40.40.40', '50.50.50.50'];
+
+  const secondReqIps = ['60.60.60.60'];
+
+  const opts = {
+    cacheDir: getTestFolder(testName),
+    cacheMap: new Map<string, ReqOutput>(),
+    cacheMapMaxEntries: 2,
+  };
+
+  it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+  firstReqIps.forEach(ip => {
+    it(`should request geo for IP: "${ip}"`, async () => {
+      await ip2geo({ip, ...opts});
+    });
+  });
+
+  it(`should have ${opts.cacheMapMaxEntries} correct cache entries`, () => {
+    assert.equal(opts.cacheMap.size, opts.cacheMapMaxEntries);
+    assert.deepEqual([...opts.cacheMap.keys()], firstReqIps.slice(-opts.cacheMapMaxEntries));
+  });
+
+  secondReqIps.forEach(ip => {
+    it(`should request geo for IP: "${ip}"`, async () => {
+      await ip2geo({ip, ...opts});
+    });
+  });
+
+  it(`should have ${opts.cacheMapMaxEntries} correct cache entries`, () => {
+    assert.equal(opts.cacheMap.size, opts.cacheMapMaxEntries);
+
+    assert.deepEqual(
+      [...opts.cacheMap.keys()],
+      [firstReqIps, secondReqIps].flat().slice(-opts.cacheMapMaxEntries),
+    );
+  });
+});

package/tests/cache-map-off.ts

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {cacheStorage, ip2geo} from '../app/api.ts';
+
+import {getCurrentFilename, getTestFolder} from './helpers/path.ts';
+import {REQUEST_IPV4_MAP_OFF_ONLY} from './shared/consts.ts';
+import {checkCacheFile, removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+  const opts = {
+    cacheDir: getTestFolder(testName),
+    cacheMapMaxEntries: 0,
+  };
+
+  it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+  it(`should return correct response for IP: "${REQUEST_IPV4_MAP_OFF_ONLY.ip}"`, async () => {
+    const data = await ip2geo({ip: REQUEST_IPV4_MAP_OFF_ONLY.ip ?? '', ...opts});
+    assert.deepEqual(data, REQUEST_IPV4_MAP_OFF_ONLY);
+  });
+
+  it('should have cache file', () =>
+    checkCacheFile({
+      ...opts,
+      response: REQUEST_IPV4_MAP_OFF_ONLY,
+    }));
+
+  it('should not have cache entries', () => {
+    assert.equal(cacheStorage.size, 0);
+  });
+});

package/tests/default.ts

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {cacheStorage, ip2geo} from '../app/api.ts';
+import type {ReqOutput} from '../app/types.ts';
+
+import {getCurrentFilename} from './helpers/path.ts';
+import {REQUEST_IPV4} from './shared/consts.ts';
+import {checkCacheFile, removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+  it('should remove fs cache dir if exist', () => removeCacheFolder());
+
+  describe('with ip arg', () => {
+    it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+      const data = await ip2geo({ip: REQUEST_IPV4.ip ?? ''});
+      assert.deepEqual(data, REQUEST_IPV4);
+    });
+
+    it('should have cache file', () =>
+      checkCacheFile({
+        response: REQUEST_IPV4,
+      }));
+
+    it('should have 1 correct cache entry', () => {
+      assert.equal(cacheStorage.size, 1);
+      assert.deepEqual(cacheStorage.get(REQUEST_IPV4.ip ?? ''), REQUEST_IPV4);
+    });
+  });
+
+  describe('without ip arg', () => {
+    let data: ReqOutput;
+
+    it('should request geoip without ip arg', async () => {
+      data = await ip2geo();
+    });
+
+    Object.keys(REQUEST_IPV4).forEach(key => {
+      it(`should have "${key}" in request response`, () => {
+        assert.ok(Object.hasOwn(data, key));
+      });
+    });
+
+    it('should not have extra keys in request response', () => {
+      assert.deepEqual(Object.keys(data), Object.keys(REQUEST_IPV4));
+    });
+
+    it('should have 2 cache entries', () => {
+      assert.equal(cacheStorage.size, 2);
+      assert.deepEqual(cacheStorage.get(REQUEST_IPV4.ip ?? ''), REQUEST_IPV4);
+    });
+  });
+});

package/tests/helpers/path.ts

@@ -0,0 +1,5 @@
+import path from 'node:path';
+
+export const getCurrentFilename = (file: string): string => path.basename(file, '.ts');
+
+export const getTestFolder = (file: string): string => path.join('.geoip', file);

package/tests/ip-multi-requests-cache.ts

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/api.ts';
+import type {ReqOutput} from '../app/types.ts';
+
+import {getCurrentFilename, getTestFolder} from './helpers/path.ts';
+import {REQUEST_IPV4} from './shared/consts.ts';
+import {checkCacheFile, removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+  const opts = {
+    cacheDir: getTestFolder(testName),
+    cacheMap: new Map<string, ReqOutput>(),
+    requestsCount: 5,
+  };
+
+  it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+  Array.from({length: opts.requestsCount}).forEach(() => {
+    it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+      const data = await ip2geo({ip: REQUEST_IPV4.ip ?? '', ...opts});
+      assert.deepEqual(data, REQUEST_IPV4);
+    });
+  });
+
+  it('should have cache file', () =>
+    checkCacheFile({
+      ...opts,
+      response: REQUEST_IPV4,
+    }));
+
+  it('should have 1 correct cache entry', () => {
+    assert.equal(opts.cacheMap.size, 1);
+    assert.deepEqual(opts.cacheMap.get(REQUEST_IPV4.ip ?? ''), REQUEST_IPV4);
+  });
+});

package/tests/ip-no-data.ts

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/api.ts';
+import type {ReqOutput} from '../app/types.ts';
+
+import {getCurrentFilename, getTestFolder} from './helpers/path.ts';
+import {REQUEST_IPV4} from './shared/consts.ts';
+import {removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+  const responses = ['10.10.10.10', '192.168.1.100'];
+
+  const opts = {
+    cacheDir: getTestFolder(testName),
+    cacheMap: new Map<string, ReqOutput>(),
+  };
+
+  it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+  responses.forEach(ip => {
+    const expectedResponse = Object.fromEntries(
+      Object.keys(REQUEST_IPV4).map(key => [key, key === 'ip' ? ip : '']),
+    ) as ReqOutput;
+
+    it(`should return empty response for IP: "${ip}"`, async () => {
+      const data = await ip2geo({ip, ...opts});
+      assert.deepEqual(data, expectedResponse);
+    });
+  });
+});

package/tests/ip-v6.ts

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/api.ts';
+import type {ReqOutput} from '../app/types.ts';
+
+import {getCurrentFilename, getTestFolder} from './helpers/path.ts';
+import {REQUEST_IPV6} from './shared/consts.ts';
+import {checkCacheFile, removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe.skip(testName, () => {
+  const opts = {
+    cacheDir: getTestFolder(testName),
+    cacheMap: new Map<string, ReqOutput>(),
+  };
+
+  it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+  it(`should return correct response for IP: "${REQUEST_IPV6.ip}"`, async () => {
+    const data = await ip2geo({ip: REQUEST_IPV6.ip ?? '', ...opts});
+    assert.deepEqual(data, REQUEST_IPV6);
+  });
+
+  it('should have cache file', () =>
+    checkCacheFile({
+      ...opts,
+      response: REQUEST_IPV6,
+    }));
+});

package/tests/shared/consts.ts

@@ -0,0 +1,49 @@
+import type {ReqOutput} from '../../app/types.ts';
+
+export const REQUEST_IPV4: ReqOutput = {
+  ip: '8.8.8.8',
+  continent: 'North America',
+  continentCode: 'NA',
+  country: 'United States',
+  countryCode: 'US',
+  countryEmoji: '🇺🇸',
+  region: 'California',
+  regionCode: 'CA',
+  city: 'Mountain View',
+  connectionAsn: 15_169,
+  connectionOrg: 'Google LLC',
+  connectionIsp: 'Google LLC',
+  connectionDomain: 'google.com',
+};
+
+export const REQUEST_IPV4_MAP_OFF_ONLY: ReqOutput = {
+  ip: '9.9.9.9',
+  continent: 'North America',
+  continentCode: 'NA',
+  country: 'United States',
+  countryCode: 'US',
+  countryEmoji: '🇺🇸',
+  region: 'California',
+  regionCode: 'CA',
+  city: 'Berkeley',
+  connectionAsn: 19_281,
+  connectionOrg: 'Quad',
+  connectionIsp: 'Quad',
+  connectionDomain: 'quad9.net',
+};
+
+export const REQUEST_IPV6: ReqOutput = {
+  ip: '2a00:dd80:40:100::',
+  continent: 'North America',
+  continentCode: 'NA',
+  country: 'United States',
+  countryCode: 'US',
+  countryEmoji: '🇺🇸',
+  region: 'District of Columbia',
+  regionCode: 'DC',
+  city: 'Washington',
+  connectionAsn: 36_236,
+  connectionOrg: 'Netactuate INC',
+  connectionIsp: 'Netactuate, INC',
+  connectionDomain: 'netactuate.com',
+};

package/tests/shared/fs.ts

@@ -0,0 +1,44 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  DEFAULT_CACHE_FILE_DIR,
+  DEFAULT_CACHE_FILE_NAME,
+  DEFAULT_CACHE_FILE_NEWLINE,
+  DEFAULT_CACHE_FILE_SEPARATOR,
+} from '../../app/api.ts';
+import type {ReqOutput} from '../../app/types.ts';
+
+interface CheckCacheFileOpts {
+  cacheDir?: string;
+  cacheFileName?: string;
+  cacheFileSeparator?: string;
+  cacheFileNewline?: string;
+  response: ReqOutput;
+}
+
+export const removeCacheFolder = async (
+  cacheDir: string = DEFAULT_CACHE_FILE_DIR,
+): Promise<void> => {
+  try {
+    await fs.rm(cacheDir, {recursive: true, force: true});
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw err;
+    }
+  }
+};
+
+export const checkCacheFile = async ({
+  cacheDir = DEFAULT_CACHE_FILE_DIR,
+  cacheFileName = DEFAULT_CACHE_FILE_NAME,
+  cacheFileSeparator = DEFAULT_CACHE_FILE_SEPARATOR,
+  cacheFileNewline = DEFAULT_CACHE_FILE_NEWLINE,
+  response,
+}: CheckCacheFileOpts): Promise<void> => {
+  const cacheFile = `${response.ip?.split(/[.:]/)[0] ?? ''}_${cacheFileName}`;
+  const data = await fs.readFile(path.join(cacheDir, cacheFile), {encoding: 'utf8'});
+
+  assert.equal(data, cacheFileNewline + Object.values(response).join(cacheFileSeparator));
+};

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@tsconfig/strictest/tsconfig.json",
+  "compilerOptions": {
+    "types": ["node"],
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "erasableSyntaxOnly": true
+  }
+}

package/app/api.js

@@ -1,142 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-
-import {request} from '@k03mad/request';
-
-import {
-    collectOutputData,
-    readFromFsCache,
-    readFromMapCache,
-    writeToFsCache,
-    writeToMapCache,
-} from './helpers/cache.js';
-
-const API = 'https://ipwho.is/';
-
-export const DEFAULT_CACHE_FILE_DIR = path.join(os.tmpdir(), '.ip2geo-cache');
-export const DEFAULT_CACHE_FILE_NAME = 'ip.log';
-export const DEFAULT_CACHE_FILE_SEPARATOR = ';;';
-export const DEFAULT_CACHE_FILE_NEWLINE = '\n';
-export const DEFAULT_CACHE_MAP_MAX_ENTRIES = Number.POSITIVE_INFINITY;
-export const DEFAULT_CONCURRENCY = 2;
-
-export const cacheStorage = new Map();
-
-/**
- * @typedef {object} ReqInput
- * @property {object} [opts]
- * @property {object} [opts.ip]
- * @property {string} [opts.cacheDir]
- * @property {string} [opts.cacheFileName]
- * @property {string} [opts.cacheFileSeparator]
- * @property {string} [opts.cacheFileNewline]
- * @property {Map} [opts.cacheMap]
- * @property {number} [opts.cacheMapMaxEntries]
- * @property {number} [opts.rps]
- * @property {number} [opts.concurrency]
- */
-
-/**
- * @typedef {object} ReqOutput
- * @property {string} [ip]
- * @property {string} [continent]
- * @property {string} [continentCode]
- * @property {string} [country]
- * @property {string} [countryCode]
- * @property {string} [countryEmoji]
- * @property {string} [region]
- * @property {string} [regionCode]
- * @property {string} [city]
- * @property {string} [connectionAsn]
- * @property {string} [connectionOrg]
- * @property {string} [connectionIsp]
- * @property {string} [connectionDomain]
- */
-
-/**
- * @param {ReqInput} opts
- * @returns {Promise<ReqOutput>}
- */
-export const ip2geo = async ({
-    ip = '',
-    cacheDir = DEFAULT_CACHE_FILE_DIR,
-    cacheFileName = DEFAULT_CACHE_FILE_NAME,
-    cacheFileSeparator = DEFAULT_CACHE_FILE_SEPARATOR,
-    cacheFileNewline = DEFAULT_CACHE_FILE_NEWLINE,
-    cacheMapMaxEntries = DEFAULT_CACHE_MAP_MAX_ENTRIES,
-    cacheMap = cacheStorage,
-    rps,
-    concurrency,
-} = {}) => {
-    if (ip) {
-        const mapCache = readFromMapCache(ip, cacheMap, cacheMapMaxEntries);
-
-        if (mapCache) {
-            return mapCache;
-        }
-
-        const fsCache = await readFromFsCache(
-            ip,
-            cacheDir,
-            cacheFileName,
-            cacheFileSeparator,
-            cacheFileNewline,
-        );
-
-        if (fsCache) {
-            writeToMapCache(fsCache, cacheMap, cacheMapMaxEntries);
-
-            return fsCache;
-        }
-    }
-
-    const reqUrl = API + ip;
-    const queueOpts = {};
-
-    if (rps) {
-        queueOpts.rps = rps;
-    } else if (concurrency) {
-        queueOpts.concurrency = concurrency;
-    } else {
-        queueOpts.concurrency = DEFAULT_CONCURRENCY;
-    }
-
-    const {body} = await request(reqUrl, {}, queueOpts);
-
-    if (!body?.ip) {
-        throw new Error(
-            ['API error', `request: ${reqUrl}`, `response body: ${JSON.stringify(body)}`].join(
-                '\n',
-            ),
-        );
-    }
-
-    const outputData = collectOutputData([
-        body.ip,
-        body?.continent,
-        body?.continent_code,
-        body?.country,
-        body?.country_code,
-        body?.flag?.emoji,
-        body?.region,
-        body?.region_code,
-        body?.city,
-        body?.connection?.asn,
-        body?.connection?.org,
-        body?.connection?.isp,
-        body?.connection?.domain,
-    ]);
-
-    writeToMapCache(outputData, cacheMap, cacheMapMaxEntries);
-
-    await writeToFsCache(
-        body.ip,
-        outputData,
-        cacheDir,
-        cacheFileName,
-        cacheFileSeparator,
-        cacheFileNewline,
-    );
-
-    return outputData;
-};

package/app/cli.js

@@ -1,104 +0,0 @@
-#!/usr/bin/env node
-
-import chalk from 'chalk';
-
-import {
-    DEFAULT_CACHE_FILE_DIR,
-    DEFAULT_CACHE_FILE_NEWLINE,
-    DEFAULT_CACHE_FILE_SEPARATOR,
-    ip2geo,
-} from './api.js';
-import {pruneCache} from './helpers/cache.js';
-import {codeText, nameText} from './helpers/colors.js';
-
-const {blue, red, green, dim, bold} = chalk;
-
-const args = process.argv.slice(2);
-const argsExtra = args.filter(arg => !arg.startsWith('-'));
-
-const isHelp = args.includes('-h') || args.includes('--help');
-const isPrune = args.includes('-p') || args.includes('--prune');
-
-if (isHelp) {
-    const cmd = `${codeText('$')} ${nameText('ip2geo')}`;
-
-    console.log(
-        [
-            '',
-            codeText('# current external ip'),
-            cmd,
-            `${cmd} 1.1.1.1`,
-            '',
-            `${cmd} -h`,
-            `${cmd} --help`,
-            '',
-            `${cmd} 1.1.1.1 -j`,
-            `${cmd} 1.1.1.1 --json`,
-            '',
-            `${cmd} 1.1.1.1 8.8.8.8`,
-            `${cmd} 1.1.1.1,8.8.8.8`,
-            '',
-            codeText('# remove duplicate cache entries'),
-            `${cmd} -p`,
-            `${cmd} --prune`,
-        ].join('\n'),
-    );
-
-    process.exit(0);
-}
-
-if (isPrune) {
-    const cacheFolder = argsExtra[0] || DEFAULT_CACHE_FILE_DIR;
-    console.log(blue(cacheFolder));
-
-    try {
-        const {different, duplicates, empty, entries, longLinesFiles} = await pruneCache(
-            cacheFolder,
-            DEFAULT_CACHE_FILE_SEPARATOR,
-            DEFAULT_CACHE_FILE_NEWLINE,
-        );
-
-        console.log(
-            [
-                '',
-                green(`Removed duplicate cache entries: ${bold(duplicates.length)}`),
-                ...duplicates.map(elem => dim(`— ${elem}`)),
-                green(`Removed different cache entries: ${bold(different.length)}`),
-                ...different.map(elem => dim(`— ${elem}`)),
-                green(`Removed empty cache entries: ${bold(empty.length)}`),
-                ...empty.map(elem => dim(`— ${elem}`)),
-            ].join('\n'),
-        );
-
-        if (longLinesFiles.length > 0) {
-            console.log(
-                [
-                    red(
-                        `Required manual check, some cache files has too long lines: ${bold(longLinesFiles.length)}`,
-                    ),
-                    ...longLinesFiles.map(({file, elem}) => dim(`— ${file}\n|— ${elem}`)),
-                ].join('\n'),
-            );
-        }
-
-        console.log(['', green(`Current cache entries: ${bold(entries)}`)].join('\n'));
-    } catch (err) {
-        console.error(red(err));
-        process.exit(1);
-    }
-} else {
-    const output =
-        argsExtra.length === 0
-            ? [await ip2geo()]
-            : await Promise.all(
-                  argsExtra.map(arg => Promise.all(arg.split(',').map(ip => ip2geo({ip})))),
-              );
-
-    const flatten = output.flat();
-
-    if (args.includes('--json') || args.includes('-j')) {
-        console.log(JSON.stringify(flatten.length > 1 ? flatten : flatten[0]));
-    } else {
-        flatten.forEach(elem => console.log(elem));
-    }
-}