refactor config file validation

Author: dem1fo

src/config/Config.ts

@@ -15,50 +15,44 @@ export namespace Config {
     target?: string;
   }
   export interface AlgorithmColumns {
-    to_translate: string[];
+    process: string[];
     static: string[];
     reference: string[];
   }
+  export type StringBasedSalt = { source: 'STRING'; value: string }
+  export type FileBasedSalt = {
+    source: 'FILE';
+    validator_regex?: string;
+    value: {
+      win32?: string;
+      darwin?: string;
+      linux?: string;
+    }
+  };
   export interface Options {
     isBackup?: boolean;
     meta: {
       region: string;
       version: string;
+      signature: string;
     };
     messages?: {
       terms_and_conditions: string;
       error_in_config: string;
       error_in_salt: string;
     };
     source: ColumnMap;
-    validations: { [key: string]: ColumnValidation[] };
+    validations?: { [key: string]: ColumnValidation[] };
     algorithm: {
       columns: AlgorithmColumns;
       hash: {
-        strategy: 'SHA256' | 'SCRYPT' | 'ARGON2';
-        num_iterations?: number;
-        parallelism?: number;
-        block_size?: number;
-        size?: number;
-      };
-      salt: {
-        source: 'FILE' | 'STRING';
-        validator_regex: string;
-        value:
-          | {
-              win32?: string;
-              darwin?: string;
-              linux?: string;
-            }
-          | string;
+        strategy: 'SHA256'
       };
+      salt: StringBasedSalt | FileBasedSalt
     };
     destination: ColumnMap;
     destination_map: ColumnMap;
     destination_errors: ColumnMap;
-    signature: {
-      config_signature: string;
-    };
   }
 }
 

src/config/configStore.ts

@@ -27,16 +27,13 @@ import {
   saveAppConfig,
   DEFAULT_APP_CONFIG,
 } from './appConfig.js';
-import { appDataLocation } from './utils.js';
 
 import type { AppConfigData, Config } from './Config.js';
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
 // Ensure the application's config file directory exists
 function ensureAppDirectoryExists(appDir: string) {
   if (!fs.existsSync(appDir)) {
-    log("Application directory '", appDir, "' does not exits -- creating it");
+    console.log("Application directory '", appDir, "' does not exits -- creating it");
     fs.mkdirSync(appDir /*, { recursive: true } */);
   }
 }
@@ -49,7 +46,7 @@ function saveConfig(configData: Config.Options, outputPath: string) {
   // update the config hash on import to account for the
   const outputData = JSON.stringify(configData, null, '    ');
   fs.writeFileSync(outputPath, outputData, CONFIG_FILE_ENCODING);
-  log('Written config data to ', outputPath);
+  console.log('Written config data to ', outputPath);
 }
 
 interface ConfigStorePaths {
@@ -120,12 +117,12 @@ export class ConfigStore {
     // if the load succesds we have a valid config -- use it as a
     // user-provided one
     if (userConfigLoad.success) {
-      log('User config validation success - using it as config');
+      console.log('User config validation success - using it as config');
       this.useUserConfig(userConfigLoad.config, userConfigLoad.lastUpdated);
       return;
     }
 
-    log(
+    console.log(
       'User config validation not successful - attempting to load backup config',
     );
     // if the default config load failed use the backup default
@@ -138,7 +135,7 @@ export class ConfigStore {
     // if the load succesds we have a valid config -- use it as
     // a config-from-backup
     if (backupConfigLoad.success) {
-      log('Backup config validation success - using it as config');
+      console.log('Backup config validation success - using it as config');
       backupConfigLoad.config.isBackup = true;
       this.useBackupConfig(backupConfigLoad.config);
       return;
@@ -148,7 +145,7 @@ export class ConfigStore {
     this.loadError = backupConfigLoad.error;
 
     // if the backup config fails to load we are screwed
-    log(
+    console.log(
       'Backup config load failed - the application should alert the user: ',
       backupConfigLoad.error,
     );
@@ -193,26 +190,26 @@ export class ConfigStore {
   // This method does not save the backup as the user config, only deletes the user config file
   removeUserConfig() {
     // attempt to load the backup config
-    log(
+    console.log(
       '[removeUserConfig] Attempting to remove user configuration and replace with backup.',
     );
 
     // if the current config is already a backup config don't do anything
     if (this.isCurrentConfigBackup()) {
-      log('[removeUserConfig] Already using a backup config -- bailing');
+      console.log('[removeUserConfig] Already using a backup config -- bailing');
       // this is not an error - we're already using the backup
       return;
     }
 
-    log('[removeUserConfig] Trying to load backup config file');
+    console.log('[removeUserConfig] Trying to load backup config file');
     const backupConfigLoad = loadConfig(
       this.getBackupConfigFilePath(),
       this.getRegion(),
     );
 
     // if failed return the error message (do not delete the user config yet)
     if (!backupConfigLoad.success) {
-      log(
+      console.log(
         'Backup config validation failed -- returning error and keeping existing user config:',
         backupConfigLoad.error,
       );
@@ -223,7 +220,7 @@ export class ConfigStore {
     }
 
     // if successful use the loaded backup configuration
-    log(
+    console.log(
       '[removeUserConfig] Backup config validation success - using it as config',
     );
     backupConfigLoad.config.isBackup = true;
@@ -266,7 +263,7 @@ export class ConfigStore {
   // deletes the user configuration file
   _deleteUserConfigFile() {
     const configPath = this.getConfigFilePath();
-    log('Deleting config file: ', configPath);
+    console.log('Deleting config file: ', configPath);
     fs.unlinkSync(configPath);
   }
 

src/config/generateConfigHash.ts

@@ -22,28 +22,32 @@ import type { Config } from './Config.js';
 const DEFAULT_HASH_TYPE = 'md5';
 const HASH_DIGEST_TYPE = 'hex';
 
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
+type RecursivePartial<T> = { [P in keyof T]?: RecursivePartial<T[P]>}
+type RecursivePartialExcept<T, K extends keyof T> = RecursivePartial<T> & Pick<T, K>
+
 // Takes a config, removes the "signature" and salt keys from it, generates
 // a stable JSON representation and hashes it using the provided algorithm
 export function generateConfigHash(
   config: Config.Options,
   hashType = DEFAULT_HASH_TYPE,
 ) {
   // create a nested copy of the object
-  const configCopy = JSON.parse(JSON.stringify(config));
+  const configCopy = { ...JSON.parse(JSON.stringify(config)) as RecursivePartial<Config.Options>};
 
   // remove the "signature" key
-  delete configCopy.signature;
+  delete configCopy.meta!.signature;
 
   // remove the "messages" key
   // TODO: messages should go in a separate locales file to future proof translations
   delete configCopy.messages;
 
   // remove the "algorithm.salt" part as it may have injected keys
   // TODO: this enables messing with the salt file path pre-injection without signature validations, but is required for compatibility w/ the injection workflow
-  delete configCopy.algorithm.salt.value;
+  delete configCopy.algorithm!.salt!.value;
   // mock the salt source as STRING to ensure that both imported and saved
   // (with pre-injected salt) config files work
-  configCopy.algorithm.salt.source = 'STRING';
+  configCopy.algorithm!.salt!.source = 'STRING';
 
   // generate a stable JSON representation
   const stableJson = stableStringify(configCopy);

src/config/loadConfig.ts

@@ -83,25 +83,25 @@ export function loadConfig(
   log('CONFIG HASH:', configHash);
 
   // fail if the signature is not OK
-  if (configHash !== configData.signature.config_signature) {
+  if (configHash !== configData.meta.signature) {
     return {
       success: false,
-      error: `Configuration file signature mismatch -- required signature is '${configData.signature.config_signature}' but user configuration has '${configHash}' `,
+      error: `Configuration file signature mismatch -- required signature is '${configData.meta.signature}' but user configuration has '${configHash}' `,
     };
   }
 
-  // alphabetically sort the to_translate, static, and reference fields to standardise and prevent
+  // alphabetically sort the process, static, and reference fields to standardise and prevent
   // different ordering in config producing different results in output.
-  configData.algorithm.columns.to_translate =
-    configData.algorithm.columns.to_translate.sort();
+  configData.algorithm.columns.process =
+    configData.algorithm.columns.process.sort();
   configData.algorithm.columns.reference =
     configData.algorithm.columns.reference.sort();
   configData.algorithm.columns.static =
     configData.algorithm.columns.static.sort();
 
   // check if we need to inject the salt data into the config
   // if not, the config loading is finished
-  if (configData.algorithm.salt.source.toUpperCase() !== 'FILE') {
+  if (configData.algorithm.salt.source === 'STRING') {
     return {
       success: true,
       lastUpdated: lastUpdateDate,
@@ -111,9 +111,9 @@ export function loadConfig(
 
   // figure out the file path and the validation regexp
   const saltFilePath = configData.algorithm.salt.value;
-  const saltFileValidatorRegexp = RegExp(
-    configData.algorithm.salt.validator_regex,
-  );
+  const saltFileValidatorRegexp = configData.algorithm.salt.validator_regex
+    ? RegExp(configData.algorithm.salt.validator_regex)
+    : undefined;
 
   // attempt to load the salt file
   // saltFilePath must be { win32: string, darwin: string } at this stage since salt.source is guaranteed to be "FILE".
@@ -133,11 +133,10 @@ export function loadConfig(
   }
 
   // replace the "FILE" with "STRING" amd embed the salt data
+  configData.algorithm.salt = configData.algorithm.salt as unknown as Config.StringBasedSalt;
   configData.algorithm.salt.source = 'STRING';
   configData.algorithm.salt.value = saltData;
 
-  configData;
-
   // return the freshly injected config
   return {
     success: true,

src/config/utils.ts

@@ -43,6 +43,7 @@ export function attemptToReadTOMLData<T>(
 
     // handle TOML
     if (filePath.toLowerCase().endsWith('.toml')) {
+      // TODO: better error handling for toml parsing (i.e. unsupported mixed array types)
       return toml.parse(fileData);
     }