feat(#108): adds '$parseInt', '$parseFloat' and '$parseBool'

Author: joelgallant

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

@@ -958,6 +958,86 @@ describe('$substitute directive', () => {
     await expect(source.read([environmentVariableSubstitution()])).rejects.toThrow();
   });
 
+  it('parses ints', async () => {
+    process.env.FOO = '11';
+
+    const source = new LiteralSource({
+      $substitute: { $name: 'FOO', $parseInt: true },
+    });
+
+    expect(await source.readToJSON([environmentVariableSubstitution()])).toEqual(11);
+  });
+
+  it('fails when int is invalid', async () => {
+    process.env.FOO = 'not a number';
+
+    const source = new LiteralSource({
+      $substitute: { $name: 'FOO', $parseInt: true },
+    });
+
+    await expect(source.read([environmentVariableSubstitution()])).rejects.toThrow();
+  });
+
+  it('parses float', async () => {
+    process.env.FOO = '11.2';
+
+    const source = new LiteralSource({
+      $substitute: { $name: 'FOO', $parseFloat: true },
+    });
+
+    expect(await source.readToJSON([environmentVariableSubstitution()])).toEqual(11.2);
+  });
+
+  it('fails when float is invalid', async () => {
+    process.env.FOO = 'not a number';
+
+    const source = new LiteralSource({
+      $substitute: { $name: 'FOO', $parseFloat: true },
+    });
+
+    await expect(source.read([environmentVariableSubstitution()])).rejects.toThrow();
+  });
+
+  it('parses boolean = true', async () => {
+    process.env.FOO = 'true';
+
+    const source = new LiteralSource({
+      $substitute: { $name: 'FOO', $parseBool: true },
+    });
+
+    expect(await source.readToJSON([environmentVariableSubstitution()])).toEqual(true);
+  });
+
+  it('parses boolean = 1', async () => {
+    process.env.FOO = '1';
+
+    const source = new LiteralSource({
+      $substitute: { $name: 'FOO', $parseBool: true },
+    });
+
+    expect(await source.readToJSON([environmentVariableSubstitution()])).toEqual(true);
+  });
+
+  it('parses boolean = 0', async () => {
+    process.env.FOO = '0';
+
+    const source = new LiteralSource({
+      $substitute: { $name: 'FOO', $parseBool: true },
+    });
+
+    expect(await source.readToJSON([environmentVariableSubstitution()])).toEqual(false);
+  });
+
+  it('parses boolean = false', async () => {
+    process.env.FOO = 'false';
+
+    const source = new LiteralSource({
+      $substitute: { $name: 'FOO', $parseBool: true },
+    });
+
+    expect(await source.readToJSON([environmentVariableSubstitution()])).toEqual(false);
+  });
+
   it('doesnt visit fallback if name is defined', async () => {
     const failDirective = forKey('$fail', () => () => {
       throw new Error();

app-config-extensions/src/index.ts

@@ -264,17 +264,53 @@ export function environmentVariableSubstitution(
     validateObject(value, [...ctx, key]);
     if (Array.isArray(value)) throw new AppConfigError('$substitute was given an array');
 
-    const { $name: variableName, $fallback: fallback, $allowNull: allowNull } = value;
-    validateString(variableName, [...ctx, key, [InObject, '$name']]);
+    const { $name, $fallback, $allowNull, $parseInt, $parseFloat, $parseBool } = value;
 
-    const resolvedValue = process.env[variableName];
+    const name = (await parse($name)).toJSON();
+
+    validateString(name, [...ctx, key, [InObject, '$name']]);
+
+    const resolvedValue = process.env[name];
 
     if (resolvedValue) {
+      const parseInt = (await parse($parseInt)).toJSON();
+
+      if (parseInt) {
+        const parsed = Number.parseInt(resolvedValue, 10);
+
+        if (Number.isNaN(parsed)) {
+          throw new AppConfigError(`Failed to parseInt(${resolvedValue})`);
+        }
+
+        return parse(parsed, { shouldFlatten: true });
+      }
+
+      const parseFloat = (await parse($parseFloat)).toJSON();
+
+      if (parseFloat) {
+        const parsed = Number.parseFloat(resolvedValue);
+
+        if (Number.isNaN(parsed)) {
+          throw new AppConfigError(`Failed to parseFloat(${resolvedValue})`);
+        }
+
+        return parse(parsed, { shouldFlatten: true });
+      }
+
+      const parseBool = (await parse($parseBool)).toJSON();
+
+      if (parseBool) {
+        const parsed = resolvedValue.toLowerCase() !== 'false' && resolvedValue !== '0';
+
+        return parse(parsed, { shouldFlatten: true });
+      }
+
       return parse(resolvedValue, { shouldFlatten: true });
     }
 
-    if (fallback !== undefined) {
-      const fallbackValue = (await parse(fallback)).toJSON();
+    if ($fallback !== undefined) {
+      const fallbackValue = (await parse($fallback)).toJSON();
+      const allowNull = (await parse($allowNull)).toJSON();
 
       if (allowNull) {
         validateStringOrNull(fallbackValue, [...ctx, key, [InObject, '$fallback']]);
@@ -285,11 +321,7 @@ export function environmentVariableSubstitution(
       return parse(fallbackValue, { shouldFlatten: true });
     }
 
-    if (!resolvedValue) {
-      throw new AppConfigError(`$substitute could not find ${variableName} environment variable`);
-    }
-
-    return parse(resolvedValue, { shouldFlatten: true });
+    throw new AppConfigError(`$substitute could not find ${name} environment variable`);
   });
 }