configorama 1.0.2 → 1.1.0

package/src/utils/paths/fileType.js

@@ -0,0 +1,27 @@
+// Classifies config files by type, treating dotenv files as ".env"
+// so extension-less names like .env / .env.local / deploy.env resolve consistently
+const path = require('path')
+
+/**
+ * Whether a path is a dotenv file (.env, .env.local, deploy.env, ...).
+ * `path.extname('.env')` is '' (dotfile), so detection is by basename.
+ * @param {string} filePath - File path or name
+ * @returns {boolean} True for dotenv files
+ */
+function isEnvFile(filePath) {
+  const base = path.basename(String(filePath || ''))
+  return base === '.env' || base.startsWith('.env.') || base.endsWith('.env')
+}
+
+/**
+ * Normalized config file type: '.env' for dotenv files, else the lowercased
+ * extension.
+ * @param {string} filePath - File path or name
+ * @returns {string} File type (e.g. '.yml', '.env', '')
+ */
+function configFileType(filePath) {
+  if (isEnvFile(filePath)) return '.env'
+  return path.extname(String(filePath || '')).toLowerCase()
+}
+
+module.exports = { isEnvFile, configFileType }

package/src/utils/paths/fileType.test.js

@@ -0,0 +1,41 @@
+/* Tests for config file type classification (dotenv detection) */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { isEnvFile, configFileType } = require('./fileType')
+
+test('isEnvFile detects the env-stage-loader precedence names', () => {
+  // .env.{environment}.local, .env.{environment}, .env.local, .env
+  assert.ok(isEnvFile('.env'))
+  assert.ok(isEnvFile('.env.local'))
+  assert.ok(isEnvFile('.env.production'))
+  assert.ok(isEnvFile('.env.production.local'))
+  assert.ok(isEnvFile('/path/to/.env.staging.local'))
+  assert.ok(isEnvFile('deploy.env'))
+})
+
+test('isEnvFile rejects non-dotenv names', () => {
+  assert.is(isEnvFile('config.yml'), false)
+  assert.is(isEnvFile('env.js'), false)
+  assert.is(isEnvFile('environment.json'), false)
+  assert.is(isEnvFile('.environment'), false)
+  assert.is(isEnvFile(''), false)
+})
+
+test('configFileType returns .env for staged dotenv names', () => {
+  assert.is(configFileType('.env.production.local'), '.env')
+  assert.is(configFileType('.env.staging'), '.env')
+})
+
+test('configFileType returns .env for dotenv files', () => {
+  assert.is(configFileType('.env'), '.env')
+  assert.is(configFileType('/x/.env.local'), '.env')
+  assert.is(configFileType('deploy.env'), '.env')
+})
+
+test('configFileType returns lowercased extension otherwise', () => {
+  assert.is(configFileType('config.YML'), '.yml')
+  assert.is(configFileType('data.json'), '.json')
+  assert.is(configFileType('noext'), '')
+})
+
+test.run()

package/src/utils/paths/findLineForKey.js

@@ -31,6 +31,10 @@ function findLineForKey(keyToFind, lines, fileType) {
     if (fileType === '.ini') {
       return new RegExp(`^\\s*${escapedKey}\\s*=`).test(line)
     }
+    // dotenv: KEY= or export KEY=
+    if (fileType === '.env') {
+      return new RegExp(`^\\s*(?:export\\s+)?${escapedKey}\\s*=`).test(line)
+    }
     // JS/TS/ESM: key: or "key": or 'key': or `key`: or [`key`]:
     if (['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts'].includes(fileType)) {
       return new RegExp(`(?:${escapedKey}|"${escapedKey}"|'${escapedKey}'|\`${escapedKey}\`|\\[\`${escapedKey}\`\\])\\s*:`).test(line)
@@ -55,13 +59,32 @@ function findLineByPath(configPath, lines, fileType) {
 
   const isYaml = fileType === '.yml' || fileType === '.yaml'
   const isJson = fileType === '.json' || fileType === '.json5' || fileType === '.jsonc'
-  if (!isYaml && !isJson) return 0
+  const isEnv = fileType === '.env'
+  if (!isYaml && !isJson && !isEnv) return 0
 
   const segments = configPath.split('.')
+  if (isEnv) return findLineByPathEnv(segments, lines)
   if (isYaml) return findLineByPathYaml(segments, lines)
   return findLineByPathJson(segments, lines)
 }
 
+/**
+ * Find a dotenv key's line. .env is flat, so the key is the first path segment.
+ * Handles leading whitespace and an optional `export ` prefix.
+ * @param {string[]} segments
+ * @param {string[]} lines
+ * @returns {number}
+ */
+function findLineByPathEnv(segments, lines) {
+  const key = segments[0]
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const pattern = new RegExp(`^\\s*(?:export\\s+)?${escaped}\\s*=`)
+  for (let li = 0; li < lines.length; li++) {
+    if (pattern.test(lines[li])) return li + 1
+  }
+  return 0
+}
+
 /**
  * @param {string[]} segments
  * @param {string[]} lines

package/src/utils/paths/findLineForKey.test.js

@@ -3,7 +3,7 @@
  */
 const { test } = require('uvu')
 const assert = require('uvu/assert')
-const { findLineForKey } = require('./findLineForKey')
+const { findLineForKey, findLineByPath } = require('./findLineForKey')
 
 // YAML tests
 test('YAML - finds key at start of line', () => {
@@ -123,4 +123,23 @@ test('unknown file type falls back to YAML-style', () => {
   assert.equal(findLineForKey('foo', lines, '.unknown'), 1)
 })
 
+// dotenv
+test('dotenv - finds KEY= line', () => {
+  const lines = ['API_URL=https://x', 'stage=${opt:stage}']
+  assert.equal(findLineForKey('stage', lines, '.env'), 2)
+  assert.equal(findLineForKey('API_URL', lines, '.env'), 1)
+})
+
+test('dotenv - finds export-prefixed and whitespace-padded keys', () => {
+  const lines = ['# comment', 'export TOKEN=abc', '  PADDED = x']
+  assert.equal(findLineForKey('TOKEN', lines, '.env'), 2)
+  assert.equal(findLineForKey('PADDED', lines, '.env'), 3)
+})
+
+test('findLineByPath - dotenv key lookup', () => {
+  const lines = ['A=1', 'stage=${opt:stage}', 'B=2']
+  assert.equal(findLineByPath('stage', lines, '.env'), 2)
+  assert.equal(findLineByPath('missing', lines, '.env'), 0)
+})
+
 test.run()