@intlayer/config 1.0.2 → 1.2.0

package/src/envVariables/extractEnvVariable.ts

@@ -0,0 +1,224 @@
+import type {
+  InternationalizationConfig,
+  MiddlewareConfig,
+  ContentConfig,
+} from '../types/config';
+import { type ViteEnvVar, getPlatform } from './detectPlatform';
+
+// Utility type that replaces all values of a given type with another type
+type ReplaceValue<T> = {
+  [K in keyof T]: string | undefined;
+};
+
+const extractNextEnvVariable = () => {
+  if (typeof process === 'undefined') {
+    return extractEmptyEnvVariable();
+  }
+
+  const env = process.env;
+
+  const intlayerIntlConfiguration: ReplaceValue<InternationalizationConfig> = {
+    locales: env.NEXT_PUBLIC_INTLAYER_LOCALES,
+    defaultLocale: env.NEXT_PUBLIC_INTLAYER_DEFAULT_LOCALE,
+  };
+
+  const intlayerMiddlewareConfiguration: ReplaceValue<MiddlewareConfig> = {
+    headerName: env.NEXT_PUBLIC_INTLAYER_HEADER_NAME,
+    cookieName: env.NEXT_PUBLIC_INTLAYER_COOKIE_NAME,
+    prefixDefault: env.NEXT_PUBLIC_INTLAYER_PREFIX_DEFAULT,
+    basePath: env.NEXT_PUBLIC_INTLAYER_BASE_PATH,
+    serverSetCookie: env.NEXT_PUBLIC_INTLAYER_SERVER_SET_COOKIE,
+    noPrefix: env.NEXT_PUBLIC_INTLAYER_NO_PREFIX,
+  };
+
+  const intlayerContentConfiguration: ReplaceValue<ContentConfig> = {
+    fileExtensions: env.NEXT_PUBLIC_INTLAYER_FILE_EXTENSIONS,
+    baseDir: env.NEXT_PUBLIC_INTLAYER_BASE_DIR,
+    contentDirName: env.NEXT_PUBLIC_INTLAYER_CONTENT_DIR_NAME,
+    contentDir: env.NEXT_PUBLIC_INTLAYER_CONTENT_DIR,
+    excludedPath: env.NEXT_PUBLIC_INTLAYER_EXCLUDED_PATH,
+    resultDirName: env.NEXT_PUBLIC_INTLAYER_RESULT_DIR_NAME,
+    moduleAugmentationDirName:
+      env.NEXT_PUBLIC_INTLAYER_MODULE_AUGMENTATION_DIR_NAME,
+    dictionariesDirName: env.NEXT_PUBLIC_INTLAYER_DICTIONARIES_DIR_NAME,
+    typeDirName: env.NEXT_PUBLIC_INTLAYER_TYPE_DIR_NAME,
+    mainDirName: env.NEXT_PUBLIC_INTLAYER_MAIN_DIR_NAME,
+    resultDir: env.NEXT_PUBLIC_INTLAYER_RESULT_DIR,
+    moduleAugmentationDir: env.NEXT_PUBLIC_INTLAYER_MODULE_AUGMENTATION_DIR,
+    dictionariesDir: env.NEXT_PUBLIC_INTLAYER_DICTIONARIES_DIR,
+    typesDir: env.NEXT_PUBLIC_INTLAYER_TYPE_DIR,
+    mainDir: env.NEXT_PUBLIC_INTLAYER_MAIN_DIR,
+    watchedFilesPattern: env.NEXT_PUBLIC_INTLAYER_WATCHED_FILES_PATTERN,
+    watchedFilesPatternWithPath:
+      env.NEXT_PUBLIC_INTLAYER_WATCHED_FILES_PATTERN_WITH_PATH,
+    outputFilesPatternWithPath:
+      env.NEXT_PUBLIC_INTLAYER_OUTPUT_FILES_PATTERN_WITH_PATH,
+  };
+
+  return {
+    intlayerIntlConfiguration,
+    intlayerMiddlewareConfiguration,
+    intlayerContentConfiguration,
+  };
+};
+
+const extractReactAppEnvVariable = () => {
+  if (typeof process === 'undefined') {
+    return extractEmptyEnvVariable();
+  }
+
+  const env = process.env;
+
+  const intlayerIntlConfiguration: ReplaceValue<InternationalizationConfig> = {
+    locales: env.REACT_APP_INTLAYER_LOCALES,
+    defaultLocale: env.REACT_APP_INTLAYER_DEFAULT_LOCALE,
+  };
+
+  const intlayerMiddlewareConfiguration: ReplaceValue<MiddlewareConfig> = {
+    headerName: env.REACT_APP_INTLAYER_HEADER_NAME,
+    cookieName: env.REACT_APP_INTLAYER_COOKIE_NAME,
+    prefixDefault: env.REACT_APP_INTLAYER_PREFIX_DEFAULT,
+    basePath: env.REACT_APP_INTLAYER_BASE_PATH,
+    serverSetCookie: env.REACT_APP_INTLAYER_SERVER_SET_COOKIE,
+    noPrefix: env.REACT_APP_INTLAYER_NO_PREFIX,
+  };
+
+  const intlayerContentConfiguration: ReplaceValue<ContentConfig> = {
+    fileExtensions: env.REACT_APP_INTLAYER_FILE_EXTENSIONS,
+    baseDir: env.REACT_APP_INTLAYER_BASE_DIR,
+    contentDirName: env.REACT_APP_INTLAYER_CONTENT_DIR_NAME,
+    contentDir: env.REACT_APP_INTLAYER_CONTENT_DIR,
+    excludedPath: env.REACT_APP_INTLAYER_EXCLUDED_PATH,
+    resultDirName: env.REACT_APP_INTLAYER_RESULT_DIR_NAME,
+    moduleAugmentationDirName:
+      env.REACT_APP_INTLAYER_MODULE_AUGMENTATION_DIR_NAME,
+    dictionariesDirName: env.REACT_APP_INTLAYER_DICTIONARIES_DIR_NAME,
+    typeDirName: env.REACT_APP_INTLAYER_TYPE_DIR_NAME,
+    mainDirName: env.REACT_APP_INTLAYER_MAIN_DIR_NAME,
+    resultDir: env.REACT_APP_INTLAYER_RESULT_DIR,
+    moduleAugmentationDir: env.REACT_APP_INTLAYER_MODULE_AUGMENTATION_DIR,
+    dictionariesDir: env.REACT_APP_INTLAYER_DICTIONARIES_DIR,
+    typesDir: env.REACT_APP_INTLAYER_TYPE_DIR,
+    mainDir: env.REACT_APP_INTLAYER_MAIN_DIR,
+    watchedFilesPattern: env.REACT_APP_INTLAYER_WATCHED_FILES_PATTERN,
+    watchedFilesPatternWithPath:
+      env.REACT_APP_INTLAYER_WATCHED_FILES_PATTERN_WITH_PATH,
+    outputFilesPatternWithPath:
+      env.REACT_APP_INTLAYER_OUTPUT_FILES_PATTERN_WITH_PATH,
+  };
+
+  return {
+    intlayerIntlConfiguration,
+    intlayerMiddlewareConfiguration,
+    intlayerContentConfiguration,
+  };
+};
+
+const extractViteEnvVariable = () => {
+  const env = (import.meta as unknown as ViteEnvVar).env;
+
+  if (typeof env === 'undefined') {
+    return extractEmptyEnvVariable();
+  }
+
+  const intlayerIntlConfiguration: ReplaceValue<InternationalizationConfig> = {
+    locales: env.VITE_INTLAYER_LOCALES,
+    defaultLocale: env.VITE_INTLAYER_DEFAULT_LOCALE,
+  };
+
+  const intlayerMiddlewareConfiguration: ReplaceValue<MiddlewareConfig> = {
+    headerName: env.VITE_INTLAYER_HEADER_NAME,
+    cookieName: env.VITE_INTLAYER_COOKIE_NAME,
+    prefixDefault: env.VITE_INTLAYER_PREFIX_DEFAULT,
+    basePath: env.VITE_INTLAYER_BASE_PATH,
+    serverSetCookie: env.VITE_INTLAYER_SERVER_SET_COOKIE,
+    noPrefix: env.VITE_INTLAYER_NO_PREFIX,
+  };
+
+  const intlayerContentConfiguration: ReplaceValue<ContentConfig> = {
+    fileExtensions: env.VITE_INTLAYER_FILE_EXTENSIONS,
+    baseDir: env.VITE_INTLAYER_BASE_DIR,
+    contentDirName: env.VITE_INTLAYER_CONTENT_DIR_NAME,
+    contentDir: env.VITE_INTLAYER_CONTENT_DIR,
+    excludedPath: env.VITE_INTLAYER_EXCLUDED_PATH,
+    resultDirName: env.VITE_INTLAYER_RESULT_DIR_NAME,
+    moduleAugmentationDirName: env.VITE_INTLAYER_MODULE_AUGMENTATION_DIR_NAME,
+    dictionariesDirName: env.VITE_INTLAYER_DICTIONARIES_DIR_NAME,
+    typeDirName: env.VITE_INTLAYER_TYPE_DIR_NAME,
+    mainDirName: env.VITE_INTLAYER_MAIN_DIR_NAME,
+    resultDir: env.VITE_INTLAYER_RESULT_DIR,
+    moduleAugmentationDir: env.VITE_INTLAYER_MODULE_AUGMENTATION_DIR,
+    dictionariesDir: env.VITE_INTLAYER_DICTIONARIES_DIR,
+    typesDir: env.VITE_INTLAYER_TYPE_DIR,
+    mainDir: env.VITE_INTLAYER_MAIN_DIR,
+    watchedFilesPattern: env.VITE_INTLAYER_WATCHED_FILES_PATTERN,
+    watchedFilesPatternWithPath:
+      env.VITE_INTLAYER_WATCHED_FILES_PATTERN_WITH_PATH,
+    outputFilesPatternWithPath:
+      env.VITE_INTLAYER_OUTPUT_FILES_PATTERN_WITH_PATH,
+  };
+
+  return {
+    intlayerIntlConfiguration,
+    intlayerMiddlewareConfiguration,
+    intlayerContentConfiguration,
+  };
+};
+
+const extractEmptyEnvVariable = () => {
+  const intlayerIntlConfiguration: ReplaceValue<InternationalizationConfig> = {
+    locales: undefined,
+    defaultLocale: undefined,
+  };
+
+  const intlayerMiddlewareConfiguration: ReplaceValue<MiddlewareConfig> = {
+    headerName: undefined,
+    cookieName: undefined,
+    prefixDefault: undefined,
+    basePath: undefined,
+    serverSetCookie: undefined,
+    noPrefix: undefined,
+  };
+
+  const intlayerContentConfiguration: ReplaceValue<ContentConfig> = {
+    fileExtensions: undefined,
+    baseDir: undefined,
+    contentDirName: undefined,
+    contentDir: undefined,
+    excludedPath: undefined,
+    resultDirName: undefined,
+    moduleAugmentationDirName: undefined,
+    dictionariesDirName: undefined,
+    typeDirName: undefined,
+    mainDirName: undefined,
+    resultDir: undefined,
+    moduleAugmentationDir: undefined,
+    dictionariesDir: undefined,
+    typesDir: undefined,
+    mainDir: undefined,
+    watchedFilesPattern: undefined,
+    watchedFilesPatternWithPath: undefined,
+    outputFilesPatternWithPath: undefined,
+  };
+
+  return {
+    intlayerIntlConfiguration,
+    intlayerMiddlewareConfiguration,
+    intlayerContentConfiguration,
+  };
+};
+
+export const extractEnvVariable = () => {
+  const platform = getPlatform();
+
+  switch (platform) {
+    case 'next':
+      return extractNextEnvVariable();
+    case 'vite':
+      return extractViteEnvVariable();
+    case 'react_app':
+      return extractReactAppEnvVariable();
+    default:
+      return extractEmptyEnvVariable();
+  }
+};

package/src/envVariables/formatEnvVariable.ts

@@ -1,18 +1,24 @@
 import { getConfiguration } from '../configFile/getConfiguration';
+import { getPrefix, type Platform } from './detectPlatform';
 
+/**
+ * Format a key to corresponding environment variable name
+ *
+ * Example:
+ *  toEnvVariable('mainDir') => 'INTLAYER_MAIN_DIR'
+ */
+const formatEnvName = (key: string, prefix: string): string =>
+  prefix + key.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+
+/**
+ * Format all configuration values as environment variables
+ */
 export const formatEnvVariable = (
-  prefix = 'NEXT_PUBLIC_INTLAYER_'
+  platform: Platform
 ): Record<string, string> => {
   const intlayerConfig = getConfiguration();
 
-  /**
-   * Format a key to corresponding environment variable name
-   *
-   * Example:
-   *  toEnvVariable('mainDir') => 'INTLAYER_MAIN_DIR'
-   */
-  const formatEnvName = (key: string): string =>
-    prefix + key.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+  const prefix = getPrefix(platform);
 
   // Set all configuration values as environment variables
   const env: Record<string, string> = {};
@@ -22,9 +28,9 @@ export const formatEnvVariable = (
     ...intlayerConfig.middleware,
   })) {
     if (typeof value === 'string') {
-      env[formatEnvName(key)] = value;
+      env[formatEnvName(key, prefix)] = value;
     } else {
-      env[formatEnvName(key)] = JSON.stringify(value);
+      env[formatEnvName(key, prefix)] = JSON.stringify(value);
     }
   }
 

package/src/envVariables/getConfiguration.ts

@@ -6,114 +6,108 @@ import type {
   ServerSetCookieRule,
 } from '../types/config';
 import type { Locales } from '../types/locales';
+import { extractEnvVariable } from './extractEnvVariable';
 import { getEnvValue } from './utils';
 
+const env = extractEnvVariable();
+
 export const intlayerIntlConfiguration: InternationalizationConfig = {
   locales: getEnvValue<Locales>(
-    process.env.NEXT_PUBLIC_INTLAYER_LOCALES,
+    env.intlayerIntlConfiguration.locales,
     'array'
   )!,
   defaultLocale: getEnvValue<Locales>(
-    process.env.NEXT_PUBLIC_INTLAYER_DEFAULT_LOCALE,
+    env.intlayerIntlConfiguration.defaultLocale,
     'string'
   )!,
 };
 
 export const intlayerMiddlewareConfiguration: MiddlewareConfig = {
   headerName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_HEADER_NAME,
+    env.intlayerMiddlewareConfiguration.headerName,
     'string'
   )!,
   cookieName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_COOKIE_NAME,
+    env.intlayerMiddlewareConfiguration.cookieName,
     'string'
   )!,
   prefixDefault: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_PREFIX_DEFAULT,
+    env.intlayerMiddlewareConfiguration.prefixDefault,
     'boolean'
   )!,
-  basePath: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_BASE_PATH, 'string')!,
+  basePath: getEnvValue(
+    env.intlayerMiddlewareConfiguration.basePath,
+    'string'
+  )!,
   serverSetCookie: getEnvValue<ServerSetCookieRule>(
-    process.env.NEXT_PUBLIC_INTLAYER_SERVER_SET_COOKIE,
+    env.intlayerMiddlewareConfiguration.serverSetCookie,
     'string'
   )!,
-  noPrefix: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_NO_PREFIX, 'boolean')!,
+  noPrefix: getEnvValue(
+    env.intlayerMiddlewareConfiguration.noPrefix,
+    'boolean'
+  )!,
 };
 
 export const intlayerContentConfiguration: ContentConfig = {
   fileExtensions: getEnvValue<string>(
-    process.env.NEXT_PUBLIC_INTLAYER_FILE_EXTENSIONS,
+    env.intlayerContentConfiguration.fileExtensions,
     'array'
   )!,
-  baseDir: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_BASE_DIR, 'string')!,
+  baseDir: getEnvValue(env.intlayerContentConfiguration.baseDir, 'string')!,
   contentDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_CONTENT_DIR_NAME,
+    env.intlayerContentConfiguration.contentDirName,
     'string'
   )!,
   contentDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_CONTENT_DIR,
+    env.intlayerContentConfiguration.contentDir,
     'string'
   )!,
   excludedPath: getEnvValue<string>(
-    process.env.NEXT_PUBLIC_INTLAYER_EXCLUDED_PATH,
+    env.intlayerContentConfiguration.excludedPath,
     'array'
   )!,
   resultDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_RESULT_DIR_NAME,
-    'string'
-  )!,
-  resultDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_RESULT_DIR,
+    env.intlayerContentConfiguration.resultDirName,
     'string'
   )!,
+  resultDir: getEnvValue(env.intlayerContentConfiguration.resultDir, 'string')!,
   moduleAugmentationDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_MODULE_AUGMENTATION_DIR_NAME,
+    env.intlayerContentConfiguration.moduleAugmentationDirName,
     'string'
   )!,
   moduleAugmentationDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_MODULE_AUGMENTATION_DIR,
-    'string'
-  )!,
-  bundleDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_BUNDLE_DIR_NAME,
-    'string'
-  )!,
-  bundleDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_BUNDLE_DIR,
-    'string'
-  )!,
-  bundleFileExtension: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_BUNDLE_FILE_EXTENSION,
+    env.intlayerContentConfiguration.moduleAugmentationDir,
     'string'
   )!,
   dictionariesDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_DICTIONARIES_DIR_NAME,
+    env.intlayerContentConfiguration.dictionariesDirName,
     'string'
   )!,
   dictionariesDir: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_DICTIONARIES_DIR,
+    env.intlayerContentConfiguration.dictionariesDir,
     'string'
   )!,
   typeDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_TYPES_DIR_NAME,
+    env.intlayerContentConfiguration.typeDirName,
     'string'
   )!,
-  typesDir: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_TYPES_DIR, 'string')!,
+  typesDir: getEnvValue(env.intlayerContentConfiguration.typesDir, 'string')!,
   mainDirName: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_MAIN_DIR_NAME,
+    env.intlayerContentConfiguration.mainDirName,
     'string'
   )!,
-  mainDir: getEnvValue(process.env.NEXT_PUBLIC_INTLAYER_MAIN_DIR, 'string')!,
+  mainDir: getEnvValue(env.intlayerContentConfiguration.mainDir, 'string')!,
   watchedFilesPattern: getEnvValue<string>(
-    process.env.NEXT_PUBLIC_INTLAYER_WATCHED_FILES_PATTERN,
+    env.intlayerContentConfiguration.watchedFilesPattern,
     'array'
   )!,
   watchedFilesPatternWithPath: getEnvValue<string>(
-    process.env.NEXT_PUBLIC_INTLAYER_WATCHED_FILES_PATTERN_WITH_PATH,
+    env.intlayerContentConfiguration.watchedFilesPatternWithPath,
     'array'
   )!,
   outputFilesPatternWithPath: getEnvValue(
-    process.env.NEXT_PUBLIC_INTLAYER_OUTPUT_FILES_PATTERN,
+    env.intlayerContentConfiguration.outputFilesPatternWithPath,
     'string'
   )!,
 };
@@ -124,4 +118,9 @@ export const intlayerConfiguration: IntlayerConfig = {
   content: intlayerContentConfiguration,
 };
 
+/**
+ * Get all configuration values using environment variables
+ * Can be used in the client side as the server side
+ * To use it, be sure to have the environment variables set
+ */
 export const getConfiguration = (): IntlayerConfig => intlayerConfiguration;

package/src/envVariables/utils.ts

@@ -1,14 +1,32 @@
-function getEnvValue(value: unknown, type: 'boolean'): boolean | undefined;
-function getEnvValue(value: unknown, type: 'number'): number | undefined;
+function getEnvValue(
+  value: unknown,
+  type: 'boolean',
+  verbose?: boolean
+): boolean | undefined;
+function getEnvValue(
+  value: unknown,
+  type: 'number',
+  verbose?: boolean
+): number | undefined;
 function getEnvValue<T extends string>(
   value: unknown,
-  type: 'string'
+  type: 'string',
+  verbose?: boolean
 ): T | undefined;
-function getEnvValue<T>(value: unknown, type: 'object'): T | undefined;
-function getEnvValue<T>(value: unknown, type: 'array'): T[] | undefined;
+function getEnvValue<T>(
+  value: unknown,
+  type: 'object',
+  verbose?: boolean
+): T | undefined;
+function getEnvValue<T>(
+  value: unknown,
+  type: 'array',
+  verbose?: boolean
+): T[] | undefined;
 function getEnvValue(
   value: unknown,
-  type: 'string' | 'boolean' | 'number' | 'object' | 'array'
+  type: 'string' | 'boolean' | 'number' | 'object' | 'array',
+  verbose = false
 ) {
   try {
     switch (type) {
@@ -27,20 +45,18 @@ function getEnvValue(
       case 'object':
       case 'array':
         // Attempt to parse the value as JSON
-        try {
-          return JSON.parse(value as string);
-        } catch (error) {
-          // Log error and return undefined if any error occurs during parsing
-          console.error(`Error parsing environment variable`);
-          return undefined;
-        }
+        return JSON.parse(value as string);
 
       default:
         return undefined;
     }
   } catch (error) {
     // Log error and return undefined if any error occurs during parsing
-    console.error(`Error parsing environment variable`);
+    if (verbose) {
+      console.error(
+        `Error parsing environment variable, parsing : ${((value ?? '') as string).toString()}`
+      );
+    }
     return undefined;
   }
 }