feat(#136): adds named wrapper on 3rd party parsing extensions

joelgallant · joelgallant · commit 7e62083e47f0 · 2021-04-24T17:43:54.000-06:00
diff --git a/app-config-encryption/package.json b/app-config-encryption/package.json
@@ -31,6 +31,7 @@
   },
   "dependencies": {
     "@app-config/core": "^2.4.6",
+    "@app-config/extension-utils": "^2.4.6",
     "@app-config/logging": "^2.4.6",
     "@app-config/meta": "^2.4.6",
     "@app-config/node": "^2.4.6",
diff --git a/app-config-encryption/src/index.ts b/app-config-encryption/src/index.ts
@@ -1,4 +1,5 @@
 import type { ParsingExtension } from '@app-config/core';
+import { named } from '@app-config/extension-utils';
 import { DecryptedSymmetricKey, decryptValue } from './encryption';
 
 export * from './encryption';
@@ -7,7 +8,7 @@ export * from './secret-agent-tls';
 
 /** Decrypts inline encrypted values */
 export default function encryptedDirective(symmetricKey?: DecryptedSymmetricKey): ParsingExtension {
-  return (value) => {
+  return named('encryption', (value) => {
     if (typeof value === 'string' && value.startsWith('enc:')) {
       return async (parse) => {
         const decrypted = await decryptValue(value, symmetricKey);
@@ -17,5 +18,5 @@ export default function encryptedDirective(symmetricKey?: DecryptedSymmetricKey)
     }
 
     return false;
-  };
+  });
 }
diff --git a/app-config-exec/src/index.ts b/app-config-exec/src/index.ts
@@ -1,6 +1,6 @@
 import { Json } from '@app-config/utils';
 import { ParsingExtension, parseRawString, guessFileType, AppConfigError } from '@app-config/core';
-import { forKey, validateOptions } from '@app-config/extension-utils';
+import { named, forKey, validateOptions } from '@app-config/extension-utils';
 import { resolveFilepath } from '@app-config/node';
 import { exec } from 'child_process';
 import { promisify } from 'util';
@@ -19,66 +19,69 @@ class ExecError extends AppConfigError {
 }
 
 function execParsingExtension(): ParsingExtension {
-  return forKey(
+  return named(
     '$exec',
-    validateOptions(
-      (SchemaBuilder) =>
-        SchemaBuilder.oneOf(
-          SchemaBuilder.stringSchema(),
-          SchemaBuilder.emptySchema()
-            .addString('command')
-            .addBoolean('failOnStderr', {}, false)
-            .addBoolean('parseOutput', {}, false)
-            .addBoolean('trimWhitespace', {}, false),
-        ),
-      (value) => async (parse, _, context) => {
-        let options;
-
-        if (typeof value === 'string') {
-          options = { command: value };
-        } else {
-          options = value;
-        }
-
-        const {
-          command,
-          failOnStderr = false,
-          parseOutput = false,
-          trimWhitespace = true,
-        } = options;
-
-        try {
-          const dir = resolveFilepath(context, '.');
-          const { stdout, stderr } = await execAsync(command, { cwd: dir });
-
-          if (failOnStderr && stderr) {
-            throw new ExecError(`$exec command "${command}" produced stderr: ${stderr}`);
+    forKey(
+      '$exec',
+      validateOptions(
+        (SchemaBuilder) =>
+          SchemaBuilder.oneOf(
+            SchemaBuilder.stringSchema(),
+            SchemaBuilder.emptySchema()
+              .addString('command')
+              .addBoolean('failOnStderr', {}, false)
+              .addBoolean('parseOutput', {}, false)
+              .addBoolean('trimWhitespace', {}, false),
+          ),
+        (value) => async (parse, _, context) => {
+          let options;
+
+          if (typeof value === 'string') {
+            options = { command: value };
+          } else {
+            options = value;
           }
 
-          let result: Json = stdout;
+          const {
+            command,
+            failOnStderr = false,
+            parseOutput = false,
+            trimWhitespace = true,
+          } = options;
 
-          if (trimWhitespace) {
-            result = stdout.trim();
-          }
+          try {
+            const dir = resolveFilepath(context, '.');
+            const { stdout, stderr } = await execAsync(command, { cwd: dir });
 
-          if (parseOutput) {
-            const fileType = await guessFileType(stdout);
-            result = await parseRawString(stdout, fileType);
-          }
+            if (failOnStderr && stderr) {
+              throw new ExecError(`$exec command "${command}" produced stderr: ${stderr}`);
+            }
 
-          return parse(result, { shouldFlatten: true });
-        } catch (err: unknown) {
-          if (!isError(err)) {
-            throw err;
-          }
+            let result: Json = stdout;
 
-          if (err instanceof ExecError) {
-            throw err;
-          }
+            if (trimWhitespace) {
+              result = stdout.trim();
+            }
 
-          throw new ExecError(`$exec command "${command}" failed with error:\n${err.message}`);
-        }
-      },
+            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;
+            }
+
+            if (err instanceof ExecError) {
+              throw err;
+            }
+
+            throw new ExecError(`$exec command "${command}" failed with error:\n${err.message}`);
+          }
+        },
+      ),
     ),
   );
 }
diff --git a/app-config-git/src/index.ts b/app-config-git/src/index.ts
@@ -1,48 +1,51 @@
 import simpleGit from 'simple-git';
 import { ParsingExtension, AppConfigError, Fallbackable } from '@app-config/core';
-import { forKey, validateOptions } from '@app-config/extension-utils';
+import { named, forKey, validateOptions } from '@app-config/extension-utils';
 
 class GitError extends Fallbackable {}
 
 /** Access to the git branch and commit ref */
 export default function gitRefDirectives(
   getStatus: typeof gitStatus = gitStatus,
 ): ParsingExtension {
-  return forKey(
+  return named(
     '$git',
-    validateOptions(
-      (SchemaBuilder) => SchemaBuilder.stringSchema(),
-      (value) => async (parse) => {
-        switch (value) {
-          case 'commit':
-            return getStatus().then(({ commitRef }) => parse(commitRef, { shouldFlatten: true }));
+    forKey(
+      '$git',
+      validateOptions(
+        (SchemaBuilder) => SchemaBuilder.stringSchema(),
+        (value) => async (parse) => {
+          switch (value) {
+            case 'commit':
+              return getStatus().then(({ commitRef }) => parse(commitRef, { shouldFlatten: true }));
 
-          case 'commitShort':
-            return getStatus().then(({ commitRef }) =>
-              parse(commitRef.slice(0, 7), { shouldFlatten: true }),
-            );
+            case 'commitShort':
+              return getStatus().then(({ commitRef }) =>
+                parse(commitRef.slice(0, 7), { shouldFlatten: true }),
+              );
 
-          case 'branch':
-          case 'branchName':
-            return getStatus().then(({ branchName }) => {
-              if (!branchName) {
-                throw new AppConfigError(
-                  'The $git directive tried to retrieve branchname, but it appears no branch is checked out',
-                );
-              }
+            case 'branch':
+            case 'branchName':
+              return getStatus().then(({ branchName }) => {
+                if (!branchName) {
+                  throw new AppConfigError(
+                    'The $git directive tried to retrieve branchname, but it appears no branch is checked out',
+                  );
+                }
 
-              return parse(branchName, { shouldFlatten: true });
-            });
+                return parse(branchName, { shouldFlatten: true });
+              });
 
-          case 'tag':
-            return getStatus().then(({ tag }) => {
-              return parse(tag ?? null, { shouldFlatten: true });
-            });
+            case 'tag':
+              return getStatus().then(({ tag }) => {
+                return parse(tag ?? null, { shouldFlatten: true });
+              });
 
-          default:
-            throw new AppConfigError('$git directive was not passed a valid option');
-        }
-      },
+            default:
+              throw new AppConfigError('$git directive was not passed a valid option');
+          }
+        },
+      ),
     ),
   );
 }
diff --git a/app-config-js/src/index.ts b/app-config-js/src/index.ts
@@ -1,35 +1,38 @@
 import { ParsingExtension } from '@app-config/core';
-import { forKey, validateOptions } from '@app-config/extension-utils';
+import { named, forKey, validateOptions } from '@app-config/extension-utils';
 import { resolveFilepath } from '@app-config/node';
 
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 
 export default function jsModuleDirective(): ParsingExtension {
-  return forKey(
+  return named(
     '$jsModule',
-    validateOptions(
-      (SchemaBuilder) => SchemaBuilder.stringSchema(),
-      (value) => async (parse, _, context) => {
-        const resolvedPath = resolveFilepath(context, value);
+    forKey(
+      '$jsModule',
+      validateOptions(
+        (SchemaBuilder) => SchemaBuilder.stringSchema(),
+        (value) => async (parse, _, context) => {
+          const resolvedPath = resolveFilepath(context, value);
 
-        let loaded: any = await import(resolvedPath);
+          let loaded: any = await import(resolvedPath);
 
-        if (!loaded) {
-          return parse(loaded, { shouldFlatten: true });
-        }
+          if (!loaded) {
+            return parse(loaded, { shouldFlatten: true });
+          }
 
-        if ('default' in loaded) {
-          loaded = loaded.default;
-        }
+          if ('default' in loaded) {
+            loaded = loaded.default;
+          }
 
-        if (typeof loaded === 'function') {
-          loaded = loaded();
-        }
+          if (typeof loaded === 'function') {
+            loaded = loaded();
+          }
 
-        return parse(loaded, { shouldFlatten: true });
-      },
+          return parse(loaded, { shouldFlatten: true });
+        },
+      ),
     ),
   );
 }
diff --git a/app-config-v1-compat/package.json b/app-config-v1-compat/package.json
@@ -31,6 +31,7 @@
   },
   "dependencies": {
     "@app-config/core": "^2.4.6",
+    "@app-config/extension-utils": "^2.4.6",
     "@app-config/logging": "^2.4.6",
     "@app-config/node": "^2.4.6",
     "@app-config/utils": "^2.4.6",
diff --git a/app-config-v1-compat/src/index.ts b/app-config-v1-compat/src/index.ts
@@ -1,13 +1,14 @@
 import { join, dirname, extname } from 'path';
 import { pathExists } from 'fs-extra';
 import { isObject } from '@app-config/utils';
+import { named } from '@app-config/extension-utils';
 import { ParsingExtension, Root } from '@app-config/core';
 import { FileSource } from '@app-config/node';
 import { logger } from '@app-config/logging';
 
 /** V1 app-config compatibility */
 export default function v1Compat(): ParsingExtension {
-  return (value, [_, key], context) => {
+  return named('v1-compat', (value, [_, key], context) => {
     // only apply in top-level app-config property
     if (context[context.length - 1]?.[0] !== Root) {
       return false;
@@ -97,5 +98,5 @@ export default function v1Compat(): ParsingExtension {
     }
 
     return false;
-  };
+  });
 }
diff --git a/app-config-vault/src/index.ts b/app-config-vault/src/index.ts
