fix: false unused with dynamic variables (#384)

* fix: false unused with dynamic variables

* chore(docs): updated docs

* chore: changeset

* chore: removed export from pattern interface

* chore: tests updated

Author: Chrilleweb

.changeset/twelve-clouds-add.md

@@ -0,0 +1,5 @@
+---
+'dotenv-diff': patch
+---
+
+fixed warning on unsued dynamic sveltekit variables

docs/capabilities.md

@@ -28,6 +28,12 @@ env.MY_KEY
 const { MY_KEY } = env
 const { MY_KEY: alias, OTHER_KEY = "fallback" } = env
 
+// SvelteKit – dynamic with aliased import
+import { env as privateEnv } from '$env/dynamic/private';
+import { env as publicEnv } from '$env/dynamic/public';
+privateEnv.MY_KEY
+const { MY_KEY } = privateEnv
+
 // SvelteKit – static (named imports)
 import { MY_KEY } from '$env/static/private';
 import { MY_KEY } from '$env/static/public';

packages/cli/src/core/scan/patterns.ts

@@ -6,6 +6,38 @@ type Pattern = {
   processor?: (match: RegExpExecArray) => string[];
 };
 
+/**
+ * Builds SvelteKit env patterns for an aliased import.
+ * Handles: import { env as aliasName } from '$env/dynamic/private'
+ * @param alias - The local alias used for the env object (e.g. "privateEnv")
+ * @returns Patterns matching aliasName.VAR and { VAR } = aliasName
+ */
+export function buildSveltekitAliasPatterns(alias: string): Pattern[] {
+  return [
+    {
+      name: 'sveltekit' as const,
+      regex: new RegExp(`(?<![.\\w])${alias}\\.([A-Z_][A-Z0-9_]*)`, 'g'),
+    },
+    {
+      name: 'sveltekit' as const,
+      regex: new RegExp(`\\{([^}]*)\\}\\s*=\\s*${alias}\\b`, 'g'),
+      processor: (match) => {
+        const content = match[1];
+        if (!content) return [];
+        return content
+          .split(',')
+          .map((part) => part.trim())
+          .filter(Boolean)
+          .map((part) => {
+            const [key] = part.split(/[:=]/);
+            return key ? key.trim() : '';
+          })
+          .filter((key) => /^[A-Z_][A-Z0-9_]*$/.test(key));
+      },
+    },
+  ];
+}
+
 /**
  * Framework-specific regex patterns for detecting environment variable usage
  * across different runtimes and frameworks.

packages/cli/src/core/scan/scanFile.ts

@@ -1,6 +1,6 @@
 import path from 'path';
 import type { EnvUsage, ScanOptions } from '../../config/types.js';
-import { ENV_PATTERNS } from './patterns.js';
+import { ENV_PATTERNS, buildSveltekitAliasPatterns } from './patterns.js';
 import { hasIgnoreComment } from '../security/secretDetectors.js';
 import { normalizePath } from '../helpers/normalizePath.js';
 import { isLikelyMinified } from '../helpers/isLikelyMinified.js';
@@ -35,7 +35,18 @@ export function scanFile(
     envImports.push(importMatch[1]!);
   }
 
-  for (const pattern of ENV_PATTERNS) {
+  // Detect aliased $env imports: import { env as aliasName } from '$env/dynamic/private'
+  const aliasImportRegex =
+    /import\s*\{\s*env\s+as\s+(\w+)\s*\}\s*from\s*['"]\$env\/(?:static|dynamic)\/(?:private|public)['"]/g;
+
+  const allPatterns = [...ENV_PATTERNS];
+  let aliasImportMatch: RegExpExecArray | null;
+
+  while ((aliasImportMatch = aliasImportRegex.exec(content)) !== null) {
+    allPatterns.push(...buildSveltekitAliasPatterns(aliasImportMatch[1]!));
+  }
+
+  for (const pattern of allPatterns) {
     let match: RegExpExecArray | null;
     const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
 

packages/cli/test/unit/core/scan/patterns.test.ts

@@ -4,6 +4,7 @@ import {
   DEFAULT_INCLUDE_EXTENSIONS,
   DEFAULT_EXCLUDE_PATTERNS,
   ENV_PATTERNS,
+  buildSveltekitAliasPatterns,
 } from '../../../../src/core/scan/patterns';
 import type { ScanOptions } from '../../../../src/config/types';
 
@@ -455,6 +456,70 @@ describe('scanFile - Pattern Detection', () => {
     });
   });
 
+  describe('buildSveltekitAliasPatterns', () => {
+    function makeMatch(
+      fullMatch: string,
+      ...groups: (string | undefined)[]
+    ): RegExpExecArray {
+      return Object.assign([fullMatch, ...groups], {
+        index: 0,
+        input: fullMatch,
+      }) as unknown as RegExpExecArray;
+    }
+
+    it('returns two patterns for a given alias', () => {
+      const patterns = buildSveltekitAliasPatterns('privateEnv');
+      expect(patterns).toHaveLength(2);
+      expect(patterns[0]?.regex).toBeInstanceOf(RegExp);
+      expect(patterns[1]?.regex).toBeInstanceOf(RegExp);
+      expect(patterns.every((p) => p.name === 'sveltekit')).toBe(true);
+    });
+
+    it('dot notation pattern matches alias.VAR', () => {
+      const [dotPattern] = buildSveltekitAliasPatterns('privateEnv');
+      expect(dotPattern!.regex.test('privateEnv.MY_SECRET')).toBe(true);
+      expect(dotPattern!.regex.test('env.MY_SECRET')).toBe(false);
+    });
+
+    it('destructuring processor returns [] for empty content (if !content branch)', () => {
+      const [, destructurePattern] = buildSveltekitAliasPatterns('privateEnv');
+      const result = destructurePattern!.processor!(makeMatch('{}', ''));
+      expect(result).toEqual([]);
+    });
+
+    it('destructuring processor returns [] when content is undefined', () => {
+      const [, destructurePattern] = buildSveltekitAliasPatterns('privateEnv');
+      const result = destructurePattern!.processor!(makeMatch('{}', undefined));
+      expect(result).toEqual([]);
+    });
+
+    it('destructuring processor returns empty string for part starting with : (key falsy branch)', () => {
+      // ':ALIAS' splits to key='' which is falsy → '' → filtered by uppercase check
+      const code = `import { env as privateEnv } from '$env/dynamic/private';
+const { :ALIAS } = privateEnv;`;
+      const result = scanFile('test.ts', code, baseOpts);
+      expect(result).toHaveLength(0);
+    });
+
+    it('destructuring processor extracts multiple vars from aliased import', () => {
+      const code = `import { env as privateEnv } from '$env/dynamic/private';
+const { SECRET_KEY, API_TOKEN } = privateEnv;`;
+      const result = scanFile('test.ts', code, baseOpts);
+      expect(result.map((u) => u.variable).sort()).toEqual([
+        'API_TOKEN',
+        'SECRET_KEY',
+      ]);
+    });
+
+    it('destructuring processor handles aliased keys: { VAR: alias } = privateEnv', () => {
+      const code = `import { env as privateEnv } from '$env/dynamic/private';
+const { SECRET_KEY: secret } = privateEnv;`;
+      const result = scanFile('test.ts', code, baseOpts);
+      expect(result).toHaveLength(1);
+      expect(result[0]?.variable).toBe('SECRET_KEY');
+    });
+  });
+
   describe('SvelteKit env Object Access', () => {
     it('detects env.VARIABLE_NAME access', () => {
       const code = 'const token = env.KEYCLOAK_SECRET;';

packages/cli/test/unit/core/scan/scanFile.test.ts

@@ -155,6 +155,64 @@ import * as env from '$env/dynamic/private';`;
     expect(usages.length).toBeGreaterThanOrEqual(0);
   });
 
+  it('detects env variable accessed via aliased $env import (dot notation)', () => {
+    const content = `import { env as privateEnv } from '$env/dynamic/private';
+const key = privateEnv.SUPABASE_SERVICE_ROLE_KEY;`;
+    const usages = scanFile(
+      '/test/project/src/lib/supabase.ts',
+      content,
+      baseOpts,
+    );
+
+    expect(usages).toHaveLength(1);
+    expect(usages[0]?.variable).toBe('SUPABASE_SERVICE_ROLE_KEY');
+    expect(usages[0]?.pattern).toBe('sveltekit');
+  });
+
+  it('detects env variable accessed via aliased $env/dynamic/public import', () => {
+    const content = `import { env as publicEnv } from '$env/dynamic/public';
+const url = publicEnv.PUBLIC_SUPABASE_URL;`;
+    const usages = scanFile(
+      '/test/project/src/lib/supabase.ts',
+      content,
+      baseOpts,
+    );
+
+    expect(usages).toHaveLength(1);
+    expect(usages[0]?.variable).toBe('PUBLIC_SUPABASE_URL');
+  });
+
+  it('detects multiple env variables via multiple aliased imports', () => {
+    const content = `import { env as publicEnv } from '$env/dynamic/public';
+import { env as privateEnv } from '$env/dynamic/private';
+const url = publicEnv.PUBLIC_SUPABASE_URL;
+const key = privateEnv.SUPABASE_SERVICE_ROLE_KEY;`;
+    const usages = scanFile(
+      '/test/project/src/lib/supabase.ts',
+      content,
+      baseOpts,
+    );
+
+    expect(usages).toHaveLength(2);
+    expect(usages.map((u) => u.variable)).toContain('PUBLIC_SUPABASE_URL');
+    expect(usages.map((u) => u.variable)).toContain(
+      'SUPABASE_SERVICE_ROLE_KEY',
+    );
+  });
+
+  it('detects env variables via destructuring from aliased import', () => {
+    const content = `import { env as privateEnv } from '$env/dynamic/private';
+const { SECRET_KEY, API_TOKEN } = privateEnv;`;
+    const usages = scanFile(
+      '/test/project/src/lib/server.ts',
+      content,
+      baseOpts,
+    );
+
+    expect(usages.map((u) => u.variable)).toContain('SECRET_KEY');
+    expect(usages.map((u) => u.variable)).toContain('API_TOKEN');
+  });
+
   it('returns empty array when no env variables found', () => {
     const content = 'const x = 1;\nconst y = 2;';
     const usages = scanFile('/test/project/src/app.js', content, baseOpts);