feat(resolveConfig::findPackageJson): re-write internals to be more maintainable

Author: hasezoey

packages/mongodb-memory-server-core/src/util/__tests__/resolveConfig.test.ts

@@ -1,6 +1,7 @@
 import { promises as fspromises } from 'fs';
 import * as tmp from 'tmp';
 import resolveConfig, { findPackageJson, ResolveConfigVariables } from '../resolveConfig';
+import { assertion, isNullOrUndefined } from '../utils';
 
 tmp.setGracefulCleanup();
 
@@ -25,7 +26,7 @@ describe('resolveConfig', () => {
   const originalDir = process.cwd();
   let tmpObj: tmp.DirResult;
 
-  describe('configuration from closest package.json', () => {
+  describe('findPackageJson', () => {
     beforeAll(async () => {
       // Set up test project/subproject structure in a temporary directory:
       //
@@ -62,24 +63,27 @@ describe('resolveConfig', () => {
       // expect to get the outer package.json
       process.chdir(`${tmpObj.name}/project`);
       const out = findPackageJson();
+      assertion(!isNullOrUndefined(out));
       expect(resolveConfig(ResolveConfigVariables.VERSION)).toBe('3.0.0');
-      expect(out.inner).toBe(false);
+      expect(out.config.inner).toBe(false);
     });
 
     test('in subproject', () => {
       // expect to get the inner package.json
       process.chdir(`${tmpObj.name}/project/subproject`);
       const out = findPackageJson();
+      assertion(!isNullOrUndefined(out));
       expect(resolveConfig(ResolveConfigVariables.VERSION)).toBe('4.0.0');
-      expect(out.inner).toBe(true);
+      expect(out.config.inner).toBe(true);
     });
 
     test('with explicit directory in reInitializePackageJson', () => {
       // expect to get the inner package.json
       process.chdir(`${tmpObj.name}/project`);
       const out = findPackageJson(`${tmpObj.name}/project/subproject`);
+      assertion(!isNullOrUndefined(out));
       expect(resolveConfig(ResolveConfigVariables.VERSION)).toBe('4.0.0');
-      expect(out.inner).toBe(true);
+      expect(out.config.inner).toBe(true);
     });
   });
 });

packages/mongodb-memory-server-core/src/util/resolveConfig.ts

@@ -3,6 +3,7 @@ import { findSync } from 'new-find-package-json';
 import debug from 'debug';
 import * as path from 'path';
 import { readFileSync } from 'fs';
+import { isNullOrUndefined } from './utils';
 
 const log = debug('MongoMS:ResolveConfig');
 
@@ -34,6 +35,13 @@ export const defaultValues = new Map<ResolveConfigVariables, string>([
   [ResolveConfigVariables.SYSTEM_BINARY_VERSION_CHECK, 'true'],
 ]);
 
+interface PackageJSON {
+  /** The Path where the package.json was found (directory, not the file) */
+  filePath: string;
+  /** The Options that were parsed from the package.json */
+  config: Record<string, string>;
+}
+
 /**
  * Set an Default value for an specific key
  * Mostly only used internally (for the "global-x.x" packages)
@@ -44,49 +52,69 @@ export function setDefaultValue(key: ResolveConfigVariables, value: string): voi
   defaultValues.set(key, value);
 }
 
-let packageJsonConfig: Record<string, string> = {};
+// let packageJsonConfig: Record<string, string> = {};
+let packagejson: PackageJSON | undefined = undefined;
 /**
  * Find the nearest package.json (that has an non-empty config field) for the provided directory
  * @param directory Set an custom directory to search the config in (default: process.cwd())
+ * @returns what "packagejson" variable is
  */
-export function findPackageJson(directory?: string): Record<string, string> {
-  let filename: string | undefined;
+export function findPackageJson(directory?: string): PackageJSON | undefined {
   for (const filename of findSync(directory || process.cwd())) {
     log(`findPackageJson: Found package.json at "${filename}"`);
     const readout: Record<string, any> = JSON.parse(readFileSync(filename).toString());
 
-    if (Object.keys(readout?.config?.mongodbMemoryServer ?? {}).length > 0) {
+    /** Shorthand for the long path */
+    const config = readout?.config?.mongodbMemoryServer;
+
+    if (!isNullOrUndefined(config) && Object.keys(config ?? {}).length > 0) {
       log(`findPackageJson: Found package with non-empty config field at "${filename}"`);
 
-      // the optional chaining is needed, because typescript wont accept an "isNullOrUndefined" in the if with "&& Object.keys"
-      packageJsonConfig = readout?.config?.mongodbMemoryServer;
+      const filepath = path.dirname(filename);
+
+      packagejson = {
+        filePath: filepath,
+        config: processConfigOption(config, filepath),
+      };
       break;
     }
   }
 
-  // block for all file-path resolving
-  if (filename) {
-    // These are so that "camelCase" doesnt get executed much & de-duplicate code
-    // "cc*" means "camelcase"
-    const ccDownloadDir = camelCase(ResolveConfigVariables.DOWNLOAD_DIR);
-    const ccSystemBinary = camelCase(ResolveConfigVariables.SYSTEM_BINARY);
-
-    if (ccDownloadDir in packageJsonConfig) {
-      packageJsonConfig[ccDownloadDir] = path.resolve(
-        path.dirname(filename),
-        packageJsonConfig[ccDownloadDir]
-      );
-    }
+  return packagejson;
+}
 
-    if (ccSystemBinary in packageJsonConfig) {
-      packageJsonConfig[ccSystemBinary] = path.resolve(
-        path.dirname(filename),
-        packageJsonConfig[ccSystemBinary]
-      );
-    }
+/**
+ * Apply Proccessing to input options (like resolving paths)
+ * @param input The input to process
+ * @param filepath The FilePath for the input to resolve relative paths to (needs to be a dirname and absolute)
+ * @returns always returns a object
+ */
+export function processConfigOption(input: unknown, filepath: string): Record<string, string> {
+  log('processConfigOption', input, filepath);
+
+  if (typeof input !== 'object') {
+    log('processConfigOptions: input was not a object');
+
+    return {};
+  }
+
+  // cast because it was tested before that "input" is a object and the key can only be a string in a package.json
+  const returnobj = input as Record<string, string>;
+
+  // These are so that "camelCase" doesnt get executed much & de-duplicate code
+  // "cc*" means "camelcase"
+  const ccDownloadDir = camelCase(ResolveConfigVariables.DOWNLOAD_DIR);
+  const ccSystemBinary = camelCase(ResolveConfigVariables.SYSTEM_BINARY);
+
+  if (ccDownloadDir in returnobj) {
+    returnobj[ccDownloadDir] = path.resolve(filepath, returnobj[ccDownloadDir]);
+  }
+
+  if (ccSystemBinary in returnobj) {
+    returnobj[ccSystemBinary] = path.resolve(filepath, returnobj[ccSystemBinary]);
   }
 
-  return packageJsonConfig;
+  return returnobj;
 }
 
 /**
@@ -96,7 +124,7 @@ export function findPackageJson(directory?: string): Record<string, string> {
 export function resolveConfig(variableName: ResolveConfigVariables): string | undefined {
   return (
     process.env[envName(variableName)] ??
-    packageJsonConfig[camelCase(variableName)] ??
+    packagejson?.config[camelCase(variableName)] ??
     defaultValues.get(variableName)
   )?.toString();
 }