@intlayer/config 1.0.0

package/src/configFile/buildConfigurationFields.ts

@@ -0,0 +1,214 @@
+import { join } from 'path';
+import { DEFAULT_LOCALE, LOCALES } from '../defaultValues/internationalization';
+import {
+  BASE_PATH,
+  COOKIE_NAME,
+  HEADER_NAME,
+  NO_PREFIX,
+  PREFIX_DEFAULT,
+  SERVER_SET_COOKIE,
+} from '../defaultValues/middleware';
+import {
+  BUNDLE_DIR_NAME,
+  CONTENT_DIR_NAME,
+  DICTIONARIES_DIR_NAME,
+  FILE_EXTENSIONS,
+  RESULT_DIR_NAME,
+  EXCLUDED_PATHS,
+  BUNDLE_FILE_EXTENSION,
+  TYPES_DIR_NAME,
+  MAIN_DIR_NAME,
+  MODULE_AUGMENTATION_DIR_NAME,
+} from '../defaultValues/server';
+import type {
+  BaseDerivedConfig,
+  ContentConfig,
+  CustomIntlayerConfig,
+  PatternsContentConfig,
+  InternationalizationConfig,
+  IntlayerConfig,
+  MiddlewareConfig,
+  BaseContentConfig,
+  ResultDirDerivedConfig,
+} from '../types';
+import type { GetConfigurationOptions } from './getConfiguration';
+
+let storedConfiguration: IntlayerConfig;
+
+const buildInternationalizationFields = (
+  customConfiguration?: Partial<InternationalizationConfig>
+): InternationalizationConfig => ({
+  /**
+   * Internationalization configuration
+   */
+
+  // Locales available in the application
+  locales: customConfiguration?.locales ?? LOCALES,
+
+  // Default locale of the application for fallback
+  defaultLocale: customConfiguration?.defaultLocale ?? DEFAULT_LOCALE,
+});
+
+const buildMiddlewareFields = (
+  customConfiguration?: Partial<MiddlewareConfig>
+): MiddlewareConfig => ({
+  /**
+   * Middleware configuration
+   */
+
+  // Header name to get the locale
+  headerName: customConfiguration?.headerName ?? HEADER_NAME,
+
+  // Cookie name to get the locale
+  cookieName: customConfiguration?.cookieName ?? COOKIE_NAME,
+
+  // Prefix the default locale in the URL
+  prefixDefault: customConfiguration?.prefixDefault ?? PREFIX_DEFAULT,
+
+  // Base path
+  basePath: customConfiguration?.basePath ?? BASE_PATH,
+
+  // Set cookie on server
+  serverSetCookie: customConfiguration?.serverSetCookie ?? SERVER_SET_COOKIE,
+
+  // No prefix
+  noPrefix: customConfiguration?.noPrefix ?? NO_PREFIX,
+});
+
+const buildContentFields = (
+  customConfiguration?: Partial<ContentConfig>
+): ContentConfig => {
+  const notDerivedContentConfig: BaseContentConfig = {
+    /**
+     * Content configurations
+     */
+
+    // File extensions of content to look for
+    fileExtensions: customConfiguration?.fileExtensions ?? FILE_EXTENSIONS,
+
+    // Directory name of the project
+    baseDir: customConfiguration?.baseDir ?? process.cwd(),
+
+    // Directory name where the content is stored
+    contentDirName: customConfiguration?.contentDirName ?? CONTENT_DIR_NAME,
+
+    // Result directory name
+    resultDirName: customConfiguration?.resultDirName ?? RESULT_DIR_NAME,
+
+    // Module augmentation directory name
+    moduleAugmentationDirName:
+      customConfiguration?.moduleAugmentationDirName ??
+      MODULE_AUGMENTATION_DIR_NAME,
+
+    // Bundle directory name
+    bundleDirName: customConfiguration?.bundleDirName ?? BUNDLE_DIR_NAME,
+
+    // Bundle file extension
+    bundleFileExtension:
+      customConfiguration?.bundleFileExtension ?? BUNDLE_FILE_EXTENSION,
+
+    // Dictionary directory name
+    dictionariesDirName:
+      customConfiguration?.dictionariesDirName ?? DICTIONARIES_DIR_NAME,
+
+    // Types directory name
+    typeDirName: customConfiguration?.typeDirName ?? TYPES_DIR_NAME,
+
+    // Main directory name
+    mainDirName: customConfiguration?.mainDirName ?? MAIN_DIR_NAME,
+
+    // Directories to exclude
+    excludedPath: customConfiguration?.excludedPath ?? EXCLUDED_PATHS,
+  };
+
+  const baseDirDerivedConfiguration: BaseDerivedConfig = {
+    // Directory where the content is stored
+    contentDir: join(
+      notDerivedContentConfig.baseDir,
+      notDerivedContentConfig.contentDirName
+    ),
+
+    // Directory where the result will be stored
+    resultDir: join(
+      notDerivedContentConfig.baseDir,
+      notDerivedContentConfig.resultDirName
+    ),
+
+    // Directory where the module augmentation will be stored
+    moduleAugmentationDir: join(
+      notDerivedContentConfig.baseDir,
+      notDerivedContentConfig.moduleAugmentationDirName
+    ),
+  };
+
+  const resultDirDerivedConfiguration: ResultDirDerivedConfig = {
+    // Directory where the bundle will be stored
+    bundleDir: join(
+      baseDirDerivedConfiguration.resultDir,
+      notDerivedContentConfig.bundleDirName
+    ),
+
+    // Directory where the dictionaries will be stored
+    dictionariesDir: join(
+      baseDirDerivedConfiguration.resultDir,
+      notDerivedContentConfig.dictionariesDirName
+    ),
+
+    // Directory where the types will be stored
+    typesDir: join(
+      baseDirDerivedConfiguration.resultDir,
+      notDerivedContentConfig.typeDirName
+    ),
+
+    // Directory where the main files will be stored
+    mainDir: join(
+      baseDirDerivedConfiguration.resultDir,
+      notDerivedContentConfig.mainDirName
+    ),
+  };
+
+  const patternsConfiguration: PatternsContentConfig = {
+    // Pattern of files to watch
+    watchedFilesPattern: notDerivedContentConfig.fileExtensions.map(
+      (ext) => `/**/*${ext}`
+    ),
+
+    // Pattern of files to watch including the relative path
+    watchedFilesPatternWithPath: notDerivedContentConfig.fileExtensions.map(
+      (ext) => `${baseDirDerivedConfiguration.contentDir}/**/*${ext}`
+    ),
+
+    // Pattern of files to output
+    outputFilesPatternWithPath: `${resultDirDerivedConfiguration.dictionariesDir}/**/*.json`,
+  };
+
+  return {
+    ...notDerivedContentConfig,
+    ...baseDirDerivedConfiguration,
+    ...resultDirDerivedConfiguration,
+    ...patternsConfiguration,
+  };
+};
+
+export const buildConfigurationFields = (
+  options: GetConfigurationOptions,
+  customConfiguration?: CustomIntlayerConfig
+): IntlayerConfig => {
+  const internationalizationConfig = buildInternationalizationFields(
+    customConfiguration?.internationalization
+  );
+
+  const middlewareConfig = buildMiddlewareFields(
+    customConfiguration?.middleware
+  );
+
+  const contentConfig = buildContentFields(customConfiguration?.content);
+
+  storedConfiguration = {
+    internationalization: internationalizationConfig,
+    middleware: middlewareConfig,
+    content: contentConfig,
+  };
+
+  return storedConfiguration;
+};

package/src/configFile/getConfiguration.ts

@@ -0,0 +1,75 @@
+import { relative } from 'path';
+import type { CustomIntlayerConfig, IntlayerConfig } from '../types';
+import { buildConfigurationFields } from './buildConfigurationFields';
+import { loadConfigurationFile } from './loadConfigurationFile';
+import { searchConfigurationFile } from './searchConfigurationFile';
+
+let storedConfiguration: IntlayerConfig | undefined;
+let storedConfigurationFilePath: string | undefined;
+let storedNumCustomConfiguration: number | undefined;
+
+export type GetConfigurationOptions = {
+  baseDir: string;
+  verbose: boolean;
+};
+
+const BASE_DIR_PATH = process.env.INTLAYER_BASE_DIR_PATH ?? process.cwd();
+const defaultOptions: GetConfigurationOptions = {
+  baseDir: BASE_DIR_PATH,
+  verbose: false,
+};
+
+export const getConfiguration = (
+  options?: Partial<GetConfigurationOptions>
+): IntlayerConfig => {
+  const mergedOptions = { ...defaultOptions, ...options };
+  const { baseDir, verbose } = mergedOptions;
+
+  if (!storedConfiguration) {
+    // Search for configuration files
+    const { configurationFilePath, numCustomConfiguration } =
+      searchConfigurationFile(baseDir);
+
+    // Load the custom configuration
+    let customConfiguration: CustomIntlayerConfig | undefined;
+    if (configurationFilePath) {
+      customConfiguration = loadConfigurationFile(configurationFilePath);
+    }
+
+    // Save the configuration to avoid reading the file again
+    storedConfiguration = buildConfigurationFields(
+      mergedOptions,
+      customConfiguration
+    );
+    storedConfigurationFilePath = configurationFilePath;
+    storedNumCustomConfiguration = numCustomConfiguration;
+  }
+
+  // Log warning if multiple configuration files are found
+  if (verbose)
+    logConfigFileResult(
+      storedNumCustomConfiguration,
+      storedConfigurationFilePath
+    );
+
+  return storedConfiguration;
+};
+
+const logConfigFileResult = (
+  numCustomConfiguration?: number,
+  configurationFilePath?: string
+) => {
+  if (numCustomConfiguration === 0) {
+    console.info('Configuration file not found, using default configuration.');
+  } else {
+    const relativeOutputPath = relative(BASE_DIR_PATH, configurationFilePath!);
+
+    if (numCustomConfiguration === 1) {
+      console.info(`Configuration file found: ${relativeOutputPath}.`);
+    } else {
+      console.warn(
+        `Multiple configuration files found, using ${relativeOutputPath}.`
+      );
+    }
+  }
+};

package/src/configFile/index.ts

@@ -0,0 +1 @@
+export * from './getConfiguration';

package/src/configFile/loadConfigurationFile.ts

@@ -0,0 +1,97 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import { createRequire } from 'module';
+import { type Context, runInNewContext } from 'vm';
+import { type BuildOptions, buildSync, type BuildResult } from 'esbuild';
+import type { CustomIntlayerConfig } from '../types';
+
+const isESModule = typeof import.meta.url === 'string';
+
+const sandboxContext: Context = {
+  exports: {
+    default: {},
+  },
+  module: {
+    exports: {},
+  },
+  console,
+  require: isESModule ? createRequire(import.meta.url) : require,
+};
+
+const transformationOption: BuildOptions = {
+  loader: {
+    '.js': 'js',
+    '.jsx': 'jsx',
+    '.mjs': 'js',
+    '.ts': 'ts',
+    '.tsx': 'tsx',
+    '.cjs': 'js',
+    '.json': 'json',
+  },
+  format: 'cjs', // Output format as commonjs
+  target: 'es2017',
+  packages: 'external',
+  write: false,
+  bundle: true,
+};
+
+export const loadConfigurationFile = (
+  configFilePath: string
+): CustomIntlayerConfig | undefined => {
+  let customConfiguration: CustomIntlayerConfig | undefined = undefined;
+
+  const configFileExtension = configFilePath.split('.').pop() ?? '';
+
+  try {
+    if (configFileExtension === 'json') {
+      // Assume JSON
+      return require(configFilePath);
+    }
+
+    // Rest is JS, MJS or TS
+
+    const moduleResult: BuildResult = buildSync({
+      entryPoints: [configFilePath],
+
+      ...transformationOption,
+    });
+
+    const moduleResultString = moduleResult.outputFiles?.[0].text;
+
+    if (!moduleResultString) {
+      console.error('Configuration file could not be loaded.');
+      return undefined;
+    }
+
+    runInNewContext(moduleResultString, sandboxContext);
+
+    if (
+      sandboxContext.exports.default &&
+      Object.keys(sandboxContext.exports.default).length > 0
+    ) {
+      // ES Module
+      customConfiguration = sandboxContext.exports.default;
+    } else if (
+      sandboxContext.module.exports.defaults &&
+      Object.keys(sandboxContext.module.exports.defaults).length > 0
+    ) {
+      // CommonJS
+      customConfiguration = sandboxContext.module.exports.default;
+    } else if (
+      sandboxContext.module.exports.default &&
+      Object.keys(sandboxContext.module.exports.default).length > 0
+    ) {
+      // ES Module
+      customConfiguration = sandboxContext.module.exports.default;
+    } else if (
+      sandboxContext.module.exports &&
+      Object.keys(sandboxContext.module.exports).length > 0
+    ) {
+      // Other
+      customConfiguration = sandboxContext.module.exports;
+    }
+
+    return customConfiguration;
+  } catch (error) {
+    console.error('Error:', error);
+  }
+};

package/src/configFile/searchConfigurationFile.ts

@@ -0,0 +1,48 @@
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+
+const EXTENSION = ['ts', 'js', 'json', 'cjs', 'mjs', ''];
+const CONFIGURATION_FILE_NAME_1 = 'intlayer.config';
+const CONFIGURATION_FILE_NAME_2 = '.intlayerrc';
+
+const intLayerConfigFiles = EXTENSION.filter(
+  (extension) => extension !== ''
+).map((ext) => `${CONFIGURATION_FILE_NAME_1}.${ext}`);
+
+const configurationFiles = [...intLayerConfigFiles, CONFIGURATION_FILE_NAME_2];
+
+type SearchConfigurationFileResult = {
+  configurationFilePath?: string;
+  numCustomConfiguration: number;
+};
+
+export const searchConfigurationFile = (
+  configFilePath: string
+): SearchConfigurationFileResult => {
+  let configurationFilePath: string | undefined = undefined;
+  let numCustomConfiguration = 0;
+
+  for (const fileName of configurationFiles) {
+    try {
+      const filePath = resolve(configFilePath, fileName);
+
+      // Check if the file exists
+      if (!existsSync(filePath)) {
+        continue;
+      } else {
+        numCustomConfiguration += 1;
+
+        if (!configurationFilePath) {
+          configurationFilePath = filePath;
+        }
+      }
+    } catch (error) {
+      // Return "Cannot use import statement outside a module"
+      console.error(`${fileName}: ${error as string}`);
+
+      continue;
+    }
+  }
+
+  return { configurationFilePath, numCustomConfiguration };
+};

package/src/defaultValues/internationalization.ts

@@ -0,0 +1,9 @@
+import { Locales } from './locales';
+
+export const LOCALES: Locales[] = [
+  Locales.ENGLISH,
+  Locales.FRENCH,
+  Locales.SPANISH,
+];
+
+export const DEFAULT_LOCALE = Locales.ENGLISH;