feat: uses extension-utils

Author: joelgallant

app-config-exec/src/index.test.ts

@@ -106,6 +106,14 @@ describe('execParsingExtension', () => {
     await expect(action()).rejects.toThrow();
   });
 
+  it('fails if options dont include command', async () => {
+    process.env.APP_CONFIG = JSON.stringify({
+      $exec: {},
+    });
+
+    await expect(loadUnvalidatedConfig(defaultOptions)).rejects.toThrow();
+  });
+
   it('invalid command fails', async () => {
     process.env.APP_CONFIG = JSON.stringify({
       $exec: { command: 'non-existing-command' },

app-config-exec/src/index.ts

@@ -1,5 +1,6 @@
 import { Json } from '@app-config/utils';
-import { ParsingExtension, parseRawString, guessFileType } from '@app-config/core';
+import { ParsingExtension, parseRawString, guessFileType, AppConfigError } from '@app-config/core';
+import { forKey, validateOptions } from '@app-config/extension-utils';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 
@@ -12,83 +13,72 @@ export interface Options {
   trimWhitespace: boolean;
 }
 
-class ExecError extends Error {
+class ExecError extends AppConfigError {
   name = 'ExecError';
 }
 
-function parseOptions(parsed: Json): Options {
-  if (typeof parsed === 'string') {
-    return { command: parsed, failOnStderr: false, parseOutput: false, trimWhitespace: true };
-  }
-
-  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-    const { command, failOnStderr = false, parseOutput = false, trimWhitespace = true } = parsed;
-
-    if (typeof command !== 'string') {
-      throw new ExecError('$exec requires a "command" option');
-    }
-
-    if (typeof failOnStderr !== 'boolean') {
-      throw new ExecError('$exec "failOnStderr" option must be a boolean');
-    }
-
-    if (typeof parseOutput !== 'boolean') {
-      throw new ExecError('$exec "parseString" option must be a boolean');
-    }
-
-    if (typeof trimWhitespace !== 'boolean') {
-      throw new ExecError('$exec "trimWhitespace" option must be a boolean');
-    }
-
-    return { command, failOnStderr, parseOutput, trimWhitespace };
-  }
-
-  throw new ExecError('$exec must be a string, or object with options');
-}
-
 function execParsingExtension(): ParsingExtension {
-  return (value, [_, objectKey]) => {
-    if (objectKey !== '$exec') {
-      return false;
-    }
+  return forKey(
+    '$exec',
+    validateOptions(
+      (SchemaBuilder) =>
+        SchemaBuilder.oneOf(
+          SchemaBuilder.stringSchema(),
+          SchemaBuilder.emptySchema()
+            .addString('command')
+            .addBoolean('failOnStderr', {}, false)
+            .addBoolean('parseOutput', {}, false)
+            .addBoolean('trimWhitespace', {}, false),
+        ),
+      (value) => async (parse) => {
+        let options;
+
+        if (typeof value === 'string') {
+          options = { command: value };
+        } else {
+          options = value;
+        }
 
-    return async (parse) => {
-      const parsed = await parse(value).then((v) => v.toJSON());
+        const {
+          command,
+          failOnStderr = false,
+          parseOutput = false,
+          trimWhitespace = true,
+        } = options;
 
-      const { command, failOnStderr, parseOutput, trimWhitespace } = parseOptions(parsed);
+        try {
+          const { stdout, stderr } = await execAsync(command);
 
-      try {
-        const { stdout, stderr } = await execAsync(command);
+          if (failOnStderr && stderr) {
+            throw new ExecError(`$exec command "${command}" produced stderr: ${stderr}`);
+          }
 
-        if (failOnStderr && stderr) {
-          throw new ExecError(`$exec command "${command}" produced stderr: ${stderr}`);
-        }
+          let result: Json = stdout;
 
-        let result: Json = stdout;
+          if (trimWhitespace) {
+            result = stdout.trim();
+          }
 
-        if (trimWhitespace) {
-          result = stdout.trim();
-        }
+          if (parseOutput) {
+            const fileType = await guessFileType(stdout);
+            result = await parseRawString(stdout, fileType);
+          }
 
-        if (parseOutput) {
-          const fileType = await guessFileType(stdout);
-          result = await parseRawString(stdout, fileType);
-        }
+          return parse(result, { shouldFlatten: true });
+        } catch (err: unknown) {
+          if (!isError(err)) {
+            throw err;
+          }
 
-        return parse(result, { shouldFlatten: true });
-      } catch (err: unknown) {
-        if (!isError(err)) {
-          throw err;
-        }
+          if (err instanceof ExecError) {
+            throw err;
+          }
 
-        if (err instanceof ExecError) {
-          throw err;
+          throw new ExecError(`$exec command "${command}" failed with error:\n${err.message}`);
         }
-
-        throw new ExecError(`$exec command "${command}" failed with error:\n${err.message}`);
-      }
-    };
-  };
+      },
+    ),
+  );
 }
 
 /**