refactor: splits up app-config/extensions package

Author: joelgallant

app-config-extensions/src/env-directive.test.ts

@@ -0,0 +1,145 @@
+import { LiteralSource } from '@app-config/core';
+import { forKey } from '@app-config/extension-utils';
+import { envDirective } from './env-directive';
+
+describe('$env directive', () => {
+  it('fails when not in an environment', async () => {
+    const source = new LiteralSource({ $env: {} });
+    await expect(source.read([envDirective()])).rejects.toThrow();
+  });
+
+  it('fails when no options match current environment', async () => {
+    process.env.NODE_ENV = 'test';
+    const source = new LiteralSource({ $env: { dev: true } });
+    await expect(source.read([envDirective()])).rejects.toThrow();
+  });
+
+  it('fails when options is not an object', async () => {
+    const source = new LiteralSource({
+      foo: {
+        $env: 'invalid',
+      },
+    });
+
+    await expect(source.read([envDirective()])).rejects.toThrow();
+  });
+
+  it('resolves to default environment', async () => {
+    const source = new LiteralSource({ $env: { default: 42 } });
+    const parsed = await source.read([envDirective()]);
+
+    expect(parsed.toJSON()).toEqual(42);
+  });
+
+  it('fails to resolve with no current environment', async () => {
+    process.env.NODE_ENV = undefined;
+
+    const source = new LiteralSource({ $env: { test: 42 } });
+    await expect(source.read([envDirective()])).rejects.toThrow();
+  });
+
+  it('resolves to default with no current environment', async () => {
+    process.env.NODE_ENV = undefined;
+
+    const source = new LiteralSource({ $env: { default: 42 } });
+
+    expect(await source.readToJSON([envDirective()])).toBe(42);
+  });
+
+  it('resolves to test environment', async () => {
+    process.env.NODE_ENV = 'test';
+    const source = new LiteralSource({ $env: { test: 84, default: 42 } });
+    const parsed = await source.read([envDirective()]);
+
+    expect(parsed.toJSON()).toEqual(84);
+  });
+
+  it('resolves to environment alias', async () => {
+    process.env.NODE_ENV = 'development';
+    const source = new LiteralSource({ $env: { dev: 84, default: 42 } });
+    const parsed = await source.read([envDirective()]);
+
+    expect(parsed.toJSON()).toEqual(84);
+  });
+
+  it('uses environment alias', async () => {
+    process.env.NODE_ENV = 'dev';
+    const source = new LiteralSource({ $env: { development: 84, default: 42 } });
+    const parsed = await source.read([envDirective()]);
+
+    expect(parsed.toJSON()).toEqual(84);
+  });
+
+  it('resolves to object', async () => {
+    process.env.NODE_ENV = 'test';
+    const source = new LiteralSource({
+      $env: { test: { testing: true }, default: { testing: false } },
+    });
+
+    const parsed = await source.read([envDirective()]);
+    expect(parsed.toJSON()).toEqual({ testing: true });
+  });
+
+  it('resolves to null', async () => {
+    process.env.NODE_ENV = 'test';
+    const source = new LiteralSource({
+      $env: { test: null },
+    });
+
+    const parsed = await source.read([envDirective()]);
+    expect(parsed.toJSON()).toEqual(null);
+  });
+
+  it('uses the none option', async () => {
+    delete process.env.NODE_ENV;
+    const source = new LiteralSource({
+      $env: { default: 1, none: 2 },
+    });
+
+    const parsed = await source.read([envDirective()]);
+    expect(parsed.toJSON()).toEqual(2);
+  });
+
+  it('uses the default over the none option when env is defined', async () => {
+    process.env.NODE_ENV = 'test';
+    const source = new LiteralSource({
+      $env: { default: 1, none: 2 },
+    });
+
+    const parsed = await source.read([envDirective()]);
+    expect(parsed.toJSON()).toEqual(1);
+  });
+
+  it('doesnt evaluate non-current environment', async () => {
+    const failDirective = forKey('$fail', () => () => {
+      throw new Error();
+    });
+
+    process.env.NODE_ENV = 'test';
+    const source = new LiteralSource({
+      $env: { test: null, dev: { $fail: true } },
+    });
+
+    const parsed = await source.read([envDirective(), failDirective]);
+    expect(parsed.toJSON()).toEqual(null);
+  });
+
+  it('merges selection with sibling keys', async () => {
+    const source = new LiteralSource({
+      sibling: true,
+      testing: false,
+      $env: {
+        test: { testing: true },
+        default: { testing: false },
+      },
+    });
+
+    process.env.NODE_ENV = 'test';
+    const parsed = await source.read([envDirective()]);
+    expect(parsed.toJSON()).toEqual({ sibling: true, testing: true });
+
+    process.env.NODE_ENV = 'development';
+    const parsed2 = await source.read([envDirective()]);
+    expect(parsed2.toJSON()).toEqual({ sibling: true, testing: false });
+  });
+});

app-config-extensions/src/env-directive.ts

@@ -0,0 +1,61 @@
+import type { ParsingExtension } from '@app-config/core';
+import { AppConfigError } from '@app-config/core';
+import { named, forKey, keysToPath, validateOptions } from '@app-config/extension-utils';
+import { currentEnvironment, defaultAliases, EnvironmentAliases } from '@app-config/node';
+
+/** Looks up an environment-specific value ($env) */
+export function envDirective(
+  aliases: EnvironmentAliases = defaultAliases,
+  environmentOverride?: string,
+  environmentSourceNames?: string[] | string,
+): ParsingExtension {
+  const environment = environmentOverride ?? currentEnvironment(aliases, environmentSourceNames);
+  const metadata = { shouldOverride: true };
+
+  return named(
+    '$env',
+    forKey(
+      '$env',
+      validateOptions(
+        (SchemaBuilder) => SchemaBuilder.emptySchema().addAdditionalProperties(),
+        (value, _, ctx) => (parse) => {
+          if (!environment) {
+            if ('none' in value) {
+              return parse(value.none, metadata);
+            }
+
+            if ('default' in value) {
+              return parse(value.default, metadata);
+            }
+
+            throw new AppConfigError(
+              `An $env directive was used (in ${keysToPath(
+                ctx,
+              )}), but current environment (eg. NODE_ENV) is undefined`,
+            );
+          }
+
+          for (const [envName, envValue] of Object.entries(value)) {
+            if (envName === environment || aliases[envName] === environment) {
+              return parse(envValue, metadata);
+            }
+          }
+
+          if ('default' in value) {
+            return parse(value.default, metadata);
+          }
+
+          const found = Object.keys(value).join(', ');
+
+          throw new AppConfigError(
+            `An $env directive was used (in ${keysToPath(
+              ctx,
+            )}), but none matched the current environment (wanted ${environment}, saw [${found}])`,
+          );
+        },
+        // $env is lazy so that non-applicable envs don't get evaluated
+        { lazy: true },
+      ),
+    ),
+  );
+}