feat: improves deduplication across code generation modules

Author: joelgallant

app-config-config/src/index.ts

@@ -16,6 +16,7 @@ import {
   EnvironmentAliases,
   EnvironmentSource,
   asEnvOptions,
+  currentEnvironment,
 } from '@app-config/node';
 import { markAllValuesAsSecret } from '@app-config/extensions';
 import { defaultExtensions, defaultEnvExtensions } from '@app-config/default-extensions';
@@ -44,6 +45,8 @@ export interface LoadedConfiguration {
   parsed: ParsedValue;
   parsedSecrets?: ParsedValue;
   parsedNonSecrets?: ParsedValue;
+  /** the current environment that was loaded from given options */
+  environment?: string;
   /** non-exhaustive list of files that were read (useful for reloading in plugins) */
   filePaths?: string[];
   /** if loadValidatedConfig, this is the normalized JSON schema that was used for validation */
@@ -186,6 +189,7 @@ export async function loadUnvalidatedConfig({
     parsed,
     parsedSecrets: secrets,
     parsedNonSecrets: mainConfig.cloneWhere((v) => !v.meta.fromSecrets),
+    environment: currentEnvironment(environmentOptions),
     fullConfig: parsed.toJSON(),
     filePaths: Array.from(filePaths),
   };

app-config-esbuild/src/index.ts

@@ -1,24 +1,39 @@
 import type { Plugin } from 'esbuild';
-import { loadValidatedConfig } from '@app-config/config';
-import { currentEnvironment } from '@app-config/node';
+import { ConfigLoadingOptions, loadValidatedConfig } from '@app-config/config';
 import { generateModuleText, packageNameRegex } from '@app-config/utils';
+import type { SchemaLoadingOptions } from '@app-config/schema';
 
-const plugin: Plugin = {
-  name: 'app-config',
+export interface Options {
+  useGlobalNamespace?: boolean;
+  loadingOptions?: ConfigLoadingOptions;
+  schemaLoadingOptions?: SchemaLoadingOptions;
+  injectValidationFunction?: boolean;
+}
+
+export const createPlugin = ({
+  useGlobalNamespace = true,
+  loadingOptions,
+  schemaLoadingOptions,
+  injectValidationFunction = true,
+}: Options = {}): Plugin => ({
+  name: '@app-config/esbuild',
   setup(build) {
     build.onResolve({ filter: packageNameRegex }, (args) => ({
       path: args.path,
-      namespace: 'app-config-ns',
+      namespace: '@app-config/esbuild',
     }));
 
-    build.onLoad({ filter: /.*/, namespace: 'app-config-ns' }, async () => {
-      const { fullConfig, validationFunctionCode } = await loadValidatedConfig();
+    build.onLoad({ filter: /.*/, namespace: '@app-config/esbuild' }, async () => {
+      const { fullConfig, environment, validationFunctionCode } = await loadValidatedConfig(
+        loadingOptions,
+        schemaLoadingOptions,
+      );
 
       const code = generateModuleText(fullConfig, {
-        esm: true,
-        noGlobal: false,
-        currentEnvironment: currentEnvironment(),
-        validationFunctionCode,
+        environment,
+        useGlobalNamespace,
+        validationFunctionCode: injectValidationFunction ? validationFunctionCode : undefined,
+        esmValidationCode: true,
       });
 
       return {
@@ -27,6 +42,6 @@ const plugin: Plugin = {
       };
     });
   },
-};
+});
 
-export default plugin;
+export default createPlugin;

app-config-rollup/package.json

@@ -35,7 +35,6 @@
   },
   "dependencies": {
     "@app-config/config": "^2.7.2",
-    "@app-config/node": "^2.7.2",
     "@app-config/utils": "^2.7.2"
   },
   "peerDependencies": {},

app-config-rollup/src/index.ts

@@ -1,24 +1,28 @@
 import type { Plugin } from 'rollup';
 import { generateModuleText, packageNameRegex } from '@app-config/utils';
 import { ConfigLoadingOptions, loadValidatedConfig } from '@app-config/config';
-import { asEnvOptions, currentEnvironment } from '@app-config/node';
 import type { SchemaLoadingOptions } from '@app-config/schema';
 
 export interface Options {
-  readGlobal?: boolean;
-  injectValidationFunction?: boolean;
+  useGlobalNamespace?: boolean;
   loadingOptions?: ConfigLoadingOptions;
   schemaLoadingOptions?: SchemaLoadingOptions;
+  injectValidationFunction?: boolean;
+
+  /** @deprecated use useGlobalNamespace instead */
+  readGlobal?: boolean;
 }
 
 // vite resolves first before passing to the rollup plugin
 export const appConfigImportRegex = /(app-config|app-config-main)\/dist(\/es)?\/index\.js/;
 
 export default function appConfigRollup({
-  readGlobal,
-  injectValidationFunction,
+  useGlobalNamespace,
   loadingOptions,
   schemaLoadingOptions,
+  injectValidationFunction,
+
+  readGlobal,
 }: Options = {}): Plugin & { currentFilePaths?: string[] } {
   const currentFilePaths: string[] = [];
 
@@ -34,27 +38,19 @@ export default function appConfigRollup({
     },
     async load(id) {
       if (packageNameRegex.exec(id) || appConfigImportRegex.exec(id)) {
-        const { fullConfig, validationFunctionCode, filePaths } = await loadValidatedConfig(
-          loadingOptions,
-          schemaLoadingOptions,
-        );
+        const { fullConfig, environment, validationFunctionCode, filePaths } =
+          await loadValidatedConfig(loadingOptions, schemaLoadingOptions);
 
         if (filePaths) {
           currentFilePaths.length = 0;
           currentFilePaths.push(...filePaths);
         }
 
         return generateModuleText(fullConfig, {
-          esm: true,
-          noGlobal: !readGlobal,
-          currentEnvironment: currentEnvironment(
-            asEnvOptions(
-              loadingOptions?.environmentOverride,
-              loadingOptions?.environmentAliases,
-              loadingOptions?.environmentSourceNames,
-            ),
-          ),
+          environment,
+          useGlobalNamespace: useGlobalNamespace ?? readGlobal ?? true,
           validationFunctionCode: injectValidationFunction ? validationFunctionCode : undefined,
+          esmValidationCode: true,
         });
       }
 

app-config-rollup/tsconfig.json

@@ -7,6 +7,7 @@
   "include": ["src"],
   "exclude": ["node_modules"],
   "references": [
+    { "path": "../app-config-config" },
     { "path": "../app-config-utils" },
     { "path": "../app-config-test-utils" }
   ]

app-config-utils/src/index.ts

@@ -28,31 +28,24 @@ export function isPrimitive(obj: Json): obj is JsonPrimitive {
 export function generateModuleText(
   fullConfig: Json,
   {
-    esm,
-    noGlobal,
-    currentEnvironment,
+    environment,
+    useGlobalNamespace,
     validationFunctionCode,
+    esmValidationCode,
   }: {
-    esm: boolean;
-    noGlobal: boolean;
-    currentEnvironment: string | undefined;
+    environment: string | undefined;
+    useGlobalNamespace: boolean;
     validationFunctionCode?(): string;
     validationFunctionCode?(esm: true): [string, string];
+    esmValidationCode: boolean;
   },
 ): string {
   const privateName = '_appConfig';
   const config = JSON.stringify(fullConfig);
 
   let generatedText: string;
 
-  if (noGlobal) {
-    generatedText = `
-      const config = ${config};
-
-      export { config };
-      export default config;
-    `;
-  } else {
+  if (useGlobalNamespace) {
     generatedText = `
       const configValue = ${config};
 
@@ -69,13 +62,20 @@ export function generateModuleText(
         globalNamespace.${privateName} = config;
       }
 
+      export { config };
+      export default config;
+    `;
+  } else {
+    generatedText = `
+      const config = ${config};
+
       export { config };
       export default config;
     `;
   }
 
   if (validationFunctionCode) {
-    if (esm) {
+    if (esmValidationCode) {
       const [code, imports] = validationFunctionCode(true);
 
       generatedText = `${generatedText}
@@ -110,7 +110,7 @@ export function generateModuleText(
 
   generatedText = `${generatedText}
     export function currentEnvironment() {
-      return ${currentEnvironment ? JSON.stringify(currentEnvironment) : 'undefined'};
+      return ${environment ? JSON.stringify(environment) : 'undefined'};
     }
   `;
 

app-config-webpack/package.json

@@ -31,7 +31,7 @@
     "prepublishOnly": "yarn clean && yarn build && yarn build:es"
   },
   "dependencies": {
-    "@app-config/node": "^2.7.2",
+    "@app-config/config": "^2.7.2",
     "@app-config/utils": "^2.7.2",
     "loader-utils": "2"
   },

app-config-webpack/src/index.ts

@@ -1,40 +1,44 @@
 import { join } from 'path';
 import { Compiler } from 'webpack';
 import HtmlWebpackPlugin from 'html-webpack-plugin';
-import { ConfigLoadingOptions, SchemaLoadingOptions } from '@app-config/main';
+import type { ConfigLoadingOptions, SchemaLoadingOptions } from '@app-config/main';
+
 import { regex } from './loader';
 
 // loader is the filepath, not the export
 const loader = require.resolve('./loader');
 
 export interface Options {
   headerInjection?: boolean;
+  useGlobalNamespace?: boolean;
+  loadingOptions?: ConfigLoadingOptions;
+  schemaLoadingOptions?: SchemaLoadingOptions;
+  intercept?: RegExp;
+  injectValidationFunction?: boolean;
+
+  /** @deprecated use useGlobalNamespace instead */
   noGlobal?: boolean;
+  /** @deprecated use loadingOptions instead */
   loading?: ConfigLoadingOptions;
+  /** @deprecated use schemaLoadingOptions instead */
   schemaLoading?: SchemaLoadingOptions;
-  intercept?: RegExp;
-  injectValidationFunction?: boolean;
 }
 
-export default class AppConfigPlugin {
+export default class AppConfigPlugin implements Options {
   headerInjection: boolean;
-  noGlobal: boolean;
+  useGlobalNamespace: boolean;
   loadingOptions?: ConfigLoadingOptions;
   schemaLoadingOptions?: SchemaLoadingOptions;
+  injectValidationFunction: boolean;
   intercept: RegExp;
 
-  constructor({
-    headerInjection = false,
-    noGlobal = false,
-    loading,
-    schemaLoading,
-    intercept,
-  }: Options = {}) {
-    this.headerInjection = headerInjection;
-    this.noGlobal = noGlobal;
-    this.loadingOptions = loading;
-    this.schemaLoadingOptions = schemaLoading;
-    this.intercept = intercept ?? AppConfigPlugin.regex;
+  constructor(options: Options = {}) {
+    this.headerInjection = options.headerInjection ?? false;
+    this.useGlobalNamespace = options.useGlobalNamespace ?? !options.noGlobal;
+    this.loadingOptions = options.loadingOptions ?? options.loading;
+    this.schemaLoadingOptions = options.schemaLoadingOptions ?? options.schemaLoading;
+    this.injectValidationFunction = options.injectValidationFunction ?? true;
+    this.intercept = options.intercept ?? AppConfigPlugin.regex;
   }
 
   static loader = loader;
@@ -57,9 +61,16 @@ export default class AppConfigPlugin {
 
           if (this.intercept.test(resolve.request)) {
             const queryString = JSON.stringify({
+              headerInjection: this.headerInjection,
+              useGlobalNamespace: this.useGlobalNamespace,
+              loadingOptions: this.loadingOptions,
+              schemaLoadingOptions: this.schemaLoadingOptions,
+              injectValidationFunction: this.injectValidationFunction,
+
+              // deprecated options
+              noGlobal: !this.useGlobalNamespace,
               loading: this.loadingOptions,
               schemaLoading: this.schemaLoadingOptions,
-              noGlobal: this.noGlobal,
             });
 
             // eslint-disable-next-line no-param-reassign

app-config-webpack/src/loader.ts

@@ -1,6 +1,5 @@
 import { getOptions, parseQuery } from 'loader-utils';
-import { loadValidatedConfig } from '@app-config/main';
-import { currentEnvironment, asEnvOptions } from '@app-config/node';
+import { loadValidatedConfig } from '@app-config/config';
 import { generateModuleText, packageNameRegex } from '@app-config/utils';
 import type { Options } from './index';
 
@@ -11,33 +10,29 @@ const loader = function AppConfigLoader(this: Loader) {
   if (this.cacheable) this.cacheable();
 
   const callback = this.async()!;
-  const {
-    noGlobal = false,
-    loading = {},
-    schemaLoading,
-    injectValidationFunction = true,
-  }: Options = {
+  const options: Options = {
     ...getOptions(this),
     ...parseQuery(this.resourceQuery),
   };
 
-  loadValidatedConfig(loading, schemaLoading)
-    .then(({ fullConfig, filePaths, validationFunctionCode }) => {
+  const useGlobalNamespace = options.useGlobalNamespace ?? !options.noGlobal;
+  const loadingOptions = options.loadingOptions ?? options.loading ?? {};
+  const schemaLoadingOptions = options.schemaLoadingOptions ?? options.schemaLoading;
+  const injectValidationFunction = options.injectValidationFunction ?? true;
+
+  loadValidatedConfig(loadingOptions, schemaLoadingOptions)
+    .then(({ fullConfig, environment, filePaths, validationFunctionCode }) => {
       if (filePaths) {
         filePaths.forEach((filePath) => this.addDependency(filePath));
       }
 
-      const { environmentOverride, environmentAliases, environmentSourceNames } = loading;
-
       callback(
         null,
         generateModuleText(fullConfig, {
-          esm: false,
-          noGlobal,
-          currentEnvironment: currentEnvironment(
-            asEnvOptions(environmentOverride, environmentAliases, environmentSourceNames),
-          ),
+          environment,
+          useGlobalNamespace,
           validationFunctionCode: injectValidationFunction ? validationFunctionCode : undefined,
+          esmValidationCode: false,
         }),
       );
     })

app-config-webpack/tsconfig.json

@@ -8,6 +8,6 @@
   "exclude": ["node_modules"],
   "references": [
     { "path": "../app-config-utils" },
-    { "path": "../app-config-main" }
+    { "path": "../app-config-config" }
   ]
 }