feat: add config and .config path support

Author: chrisbbreuer

src/config.ts

@@ -159,6 +159,7 @@ export function applyEnvVarsToConfig<T extends Record<string, any>>(
  * @param {ArrayMergeStrategy} [options.arrayStrategy] - The strategy to use when merging arrays.
  * @param {string} [options.alias] - An alternative name to check for config files.
  * @param {string} [options.cwd] - The current working directory.
+ * @param {string} [options.configDir] - Additional directory to search for configuration files.
  * @param {T} options.defaultConfig - The default configuration.
  * @param {boolean} [options.verbose] - Whether to log verbose information.
  * @param {boolean} [options.checkEnv] - Whether to check environment variables.
@@ -174,6 +175,7 @@ export async function loadConfig<T>({
   name = '',
   alias,
   cwd,
+  configDir,
   defaultConfig,
   verbose = false,
   checkEnv = true,
@@ -192,33 +194,46 @@ export async function loadConfig<T>({
     log.info(`Loading configuration for "${name}"${alias ? ` (alias: "${alias}")` : ''} from ${baseDir}`)
   }
 
-  // Build the list of config file patterns to try (including alias if provided)
-  const configPatterns = []
-
-  // Primary name patterns
-  configPatterns.push(`${name}.config`)
-  configPatterns.push(`.${name}.config`)
-  configPatterns.push(name)
-  configPatterns.push(`.${name}`)
-
-  // Alias patterns if an alias is provided
-  if (alias) {
-    configPatterns.push(`${alias}.config`)
-    configPatterns.push(`.${alias}.config`)
-    configPatterns.push(alias)
-    configPatterns.push(`.${alias}`)
-  }
-
-  // Try loading config in order of preference (local directory first)
-  for (const configPath of configPatterns) {
-    for (const ext of extensions) {
-      const fullPath = resolve(baseDir, `${configPath}${ext}`)
-      const config = await tryLoadConfig(fullPath, configWithEnvVars, arrayStrategy)
-      if (config !== null) {
-        if (verbose) {
-          log.success(`Configuration loaded from: ${configPath}${ext}`)
+  // Base pattern sets for primary and alias
+  const primaryBarePatterns = [name, `.${name}`].filter(Boolean)
+  const primaryConfigSuffixPatterns = [`${name}.config`, `.${name}.config`].filter(Boolean)
+  const aliasBarePatterns = alias ? [alias, `.${alias}`] : []
+  const aliasConfigSuffixPatterns = alias ? [`${alias}.config`, `.${alias}.config`] : []
+
+  // Determine local directories to search
+  const searchDirectories = Array.from(new Set([
+    baseDir,
+    resolve(baseDir, 'config'),
+    resolve(baseDir, '.config'),
+    configDir ? resolve(baseDir, configDir) : undefined,
+  ].filter(Boolean) as string[]))
+
+  // Try loading config in order of preference for each directory (local directories first)
+  for (const dir of searchDirectories) {
+    if (verbose)
+      log.info(`Searching for configuration in: ${dir}`)
+
+    // Prefer bare names inside config directories to avoid redundant ".config" suffix
+    const isConfigLikeDir = [resolve(baseDir, 'config'), resolve(baseDir, '.config')]
+      .concat(configDir ? [resolve(baseDir, configDir)] : [])
+      .includes(dir)
+
+    const patternsForDir = isConfigLikeDir
+      // Primary first, then alias: prefer bare before *.config when inside config dirs
+      ? [...primaryBarePatterns, ...primaryConfigSuffixPatterns, ...aliasBarePatterns, ...aliasConfigSuffixPatterns]
+      // Primary first, then alias: default order keeps *.config before bare
+      : [...primaryConfigSuffixPatterns, ...primaryBarePatterns, ...aliasConfigSuffixPatterns, ...aliasBarePatterns]
+
+    for (const configPath of patternsForDir) {
+      for (const ext of extensions) {
+        const fullPath = resolve(dir, `${configPath}${ext}`)
+        const config = await tryLoadConfig(fullPath, configWithEnvVars, arrayStrategy)
+        if (config !== null) {
+          if (verbose) {
+            log.success(`Configuration loaded from: ${fullPath}`)
+          }
+          return config
         }
-        return config
       }
     }
   }

test/bunfig.test.ts

@@ -637,6 +637,154 @@ describe('bunfig', () => {
         port: 443,
       })
     })
+
+    it('should find config inside ./config directory', async () => {
+      const nestedDir = resolve(testConfigDir, 'config')
+      mkdirSync(nestedDir, { recursive: true })
+
+      const name = 'local-in-config'
+      const configPath = resolve(nestedDir, `${name}.config.ts`)
+      writeFileSync(configPath, `export default { source: 'config-dir' }`)
+
+      const result = await loadConfig<{ source: string }>({
+        name,
+        cwd: testConfigDir,
+        defaultConfig: { source: 'default' },
+      })
+
+      expect(result).toEqual({ source: 'config-dir' })
+    })
+
+    it('should find config inside ./.config directory', async () => {
+      const nestedDir = resolve(testConfigDir, '.config')
+      mkdirSync(nestedDir, { recursive: true })
+
+      const name = 'local-in-dot-config'
+      const configPath = resolve(nestedDir, `${name}.config.ts`)
+      writeFileSync(configPath, `export default { source: 'dot-config-dir' }`)
+
+      const result = await loadConfig<{ source: string }>({
+        name,
+        cwd: testConfigDir,
+        defaultConfig: { source: 'default' },
+      })
+
+      expect(result).toEqual({ source: 'dot-config-dir' })
+    })
+
+    it('should prefer bare name over name.config inside config directories', async () => {
+      const name = 'prefer-bare'
+      const dirConfig = resolve(testConfigDir, 'config')
+      const dirDotConfig = resolve(testConfigDir, '.config')
+      mkdirSync(dirConfig, { recursive: true })
+      mkdirSync(dirDotConfig, { recursive: true })
+
+      // In ./config: place both bare and *.config; bare should win
+      writeFileSync(resolve(dirConfig, `${name}.ts`), `export default { where: 'config-bare' }`)
+      writeFileSync(resolve(dirConfig, `${name}.config.ts`), `export default { where: 'config-suffixed' }`)
+
+      // In ./.config: place both; but ./config is searched before ./.config, so above should win regardless
+      writeFileSync(resolve(dirDotConfig, `${name}.ts`), `export default { where: 'dot-config-bare' }`)
+      writeFileSync(resolve(dirDotConfig, `${name}.config.ts`), `export default { where: 'dot-config-suffixed' }`)
+
+      const result = await loadConfig<{ where: string }>({
+        name,
+        cwd: testConfigDir,
+        defaultConfig: { where: 'default' },
+      })
+
+      expect(result).toEqual({ where: 'config-bare' })
+    })
+
+    it('should support bare alias names inside config directories', async () => {
+      const name = 'alias-bare'
+      const dirConfig = resolve(testConfigDir, 'config')
+      mkdirSync(dirConfig, { recursive: true })
+
+      // Only create alias files, both bare and suffixed; bare should take precedence in config dir
+      writeFileSync(resolve(dirConfig, `tls.ts`), `export default { target: 'alias-bare' }`)
+      writeFileSync(resolve(dirConfig, `tls.config.ts`), `export default { target: 'alias-suffixed' }`)
+
+      const result = await loadConfig<{ target: string }>({
+        name,
+        alias: 'tls',
+        cwd: testConfigDir,
+        defaultConfig: { target: 'default' },
+      })
+
+      expect(result).toEqual({ target: 'alias-bare' })
+    })
+
+    it('should respect directory precedence: base > config > .config > custom configDir', async () => {
+      const name = 'precedence-test'
+
+      // Prepare directories
+      const dirBase = testConfigDir
+      const dirConfig = resolve(testConfigDir, 'config')
+      const dirDotConfig = resolve(testConfigDir, '.config')
+      const dirExtras = resolve(testConfigDir, 'extras')
+      mkdirSync(dirConfig, { recursive: true })
+      mkdirSync(dirDotConfig, { recursive: true })
+      mkdirSync(dirExtras, { recursive: true })
+
+      // Write same-named configs in all locations with different sources
+      writeFileSync(resolve(dirExtras, `${name}.config.ts`), `export default { source: 'extras' }`)
+      writeFileSync(resolve(dirDotConfig, `${name}.config.ts`), `export default { source: 'dot-config' }`)
+      writeFileSync(resolve(dirConfig, `${name}.config.ts`), `export default { source: 'config' }`)
+      writeFileSync(resolve(dirBase, `${name}.config.ts`), `export default { source: 'base' }`)
+
+      const result = await loadConfig<{ source: string }>({
+        name,
+        cwd: testConfigDir,
+        configDir: 'extras',
+        defaultConfig: { source: 'default' },
+        verbose: false,
+      })
+
+      // Base directory should win
+      expect(result).toEqual({ source: 'base' })
+    })
+
+    it('should prioritize ./config over ./.config and custom configDir when base is missing', async () => {
+      const name = 'precedence-no-base'
+
+      const dirConfig = resolve(testConfigDir, 'config')
+      const dirDotConfig = resolve(testConfigDir, '.config')
+      const dirExtras = resolve(testConfigDir, 'extras')
+      mkdirSync(dirConfig, { recursive: true })
+      mkdirSync(dirDotConfig, { recursive: true })
+      mkdirSync(dirExtras, { recursive: true })
+
+      writeFileSync(resolve(dirExtras, `${name}.config.ts`), `export default { source: 'extras' }`)
+      writeFileSync(resolve(dirDotConfig, `${name}.config.ts`), `export default { source: 'dot-config' }`)
+      writeFileSync(resolve(dirConfig, `${name}.config.ts`), `export default { source: 'config' }`)
+
+      const result = await loadConfig<{ source: string }>({
+        name,
+        cwd: testConfigDir,
+        configDir: 'extras',
+        defaultConfig: { source: 'default' },
+      })
+
+      expect(result).toEqual({ source: 'config' })
+    })
+
+    it('should use a custom configDir when provided', async () => {
+      const extrasDir = resolve(testConfigDir, 'extras')
+      mkdirSync(extrasDir, { recursive: true })
+
+      const name = 'custom-config-dir'
+      writeFileSync(resolve(extrasDir, `${name}.config.ts`), `export default { source: 'extras' }`)
+
+      const result = await loadConfig<{ source: string }>({
+        name,
+        cwd: testConfigDir,
+        configDir: 'extras',
+        defaultConfig: { source: 'default' },
+      })
+
+      expect(result).toEqual({ source: 'extras' })
+    })
   })
 
   describe('config function', () => {