From 484de37f3e8c18835e2aee3190a569f8d5de38b1 Mon Sep 17 00:00:00 2001 From: Chrilleweb Date: Thu, 11 Dec 2025 11:56:05 +0100 Subject: [PATCH 1/8] small refactor for old noCompare option --- CHANGELOG.md | 4 +- src/cli/run.ts | 61 +++++++------ src/commands/scanUsage.ts | 130 ++++++++++++++-------------- src/config/options.ts | 3 - src/config/types.ts | 3 - src/core/computeHealthScore.ts | 3 + src/core/determineComparisonFile.ts | 3 - src/core/helpers/isAllOk.ts | 1 + 8 files changed, 101 insertions(+), 107 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7df0819..10cef6e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,13 +4,13 @@ This project follows [Keep a Changelog](https://keepachangelog.com/) and [Semant ## [Unreleased] ### Added -- +- More jsDOcs for better code documentation. ### Changed - ### Fixed -- +- Removed unused code for old --no-compare option. ## [2.3.9] - 2025-12-09 ### Added diff --git a/src/cli/run.ts b/src/cli/run.ts index 8df06c6..9c41ce8 100644 --- a/src/cli/run.ts +++ b/src/cli/run.ts @@ -17,6 +17,36 @@ import { printErrorNotFound } from '../ui/compare/printErrorNotFound.js'; import { setupGlobalConfig } from '../ui/shared/setupGlobalConfig.js'; import { loadConfig } from '../config/loadConfig.js'; +/** + * Run the CLI program + * @param program The commander program instance + * @returns void + */ +export async function run(program: Command): Promise { + program.parse(process.argv); + + // Load and normalize options + const cliOptions = program.opts(); + + // Handle --init flag + if (await handleInitFlag(cliOptions)) return; + + // Merge CLI options with config file options + const mergedRawOptions = loadConfig(cliOptions); + + // Normalize merged options + const opts = normalizeOptions(mergedRawOptions); + + setupGlobalConfig(opts); + + // Route to appropriate command + if (opts.compare) { + await runCompareMode(opts); + } else { + await runScanMode(opts); + } +} + /** * Run scan-usage mode (default behavior) * @param opts - Normalized options @@ -41,7 +71,6 @@ async function runScanMode(opts: Options): Promise { secrets: opts.secrets, strict: opts.strict ?? false, ignoreUrls: opts.ignoreUrls ?? [], - noCompare: opts.noCompare ?? false, uppercaseKeys: opts.uppercaseKeys ?? true, expireWarnings: opts.expireWarnings, inconsistentNamingWarnings: opts.inconsistentNamingWarnings, @@ -235,33 +264,3 @@ function outputResults( } process.exit(exitWithError ? 1 : 0); } - -/** - * Run the CLI program - * @param program The commander program instance - * @returns void - */ -export async function run(program: Command): Promise { - program.parse(process.argv); - - // Load and normalize options - const cliOptions = program.opts(); - - // Handle --init flag - if (await handleInitFlag(cliOptions)) return; - - // Merge CLI options with config file options - const mergedRawOptions = loadConfig(cliOptions); - - // Normalize merged options - const opts = normalizeOptions(mergedRawOptions); - - setupGlobalConfig(opts); - - // Route to appropriate command - if (opts.compare) { - await runCompareMode(opts); - } else { - await runScanMode(opts); - } -} diff --git a/src/commands/scanUsage.ts b/src/commands/scanUsage.ts index 2b04d6d..132e716 100644 --- a/src/commands/scanUsage.ts +++ b/src/commands/scanUsage.ts @@ -14,71 +14,6 @@ import { hasIgnoreComment } from '../core/secretDetectors.js'; import { frameworkValidator } from '../core/frameworkValidator.js'; import { detectSecretsInExample } from '../core/exampleSecretDetector.js'; -/** - * Filters out commented usages from the list. - * Skipping comments: - * // process.env.API_URL - * # process.env.API_URL - * /* process.env.API_URL - * * process.env.API_URL - * - * @param usages - List of environment variable usages - * @returns Filtered list of environment variable usages - */ -function skipCommentedUsages(usages: EnvUsage[]): EnvUsage[] { - let insideHtmlComment = false; - let insideIgnoreBlock = false; - - return usages.filter((u) => { - if (!u.context) return true; - const line = u.context.trim(); - - if (line.includes('')) { - insideHtmlComment = false; - return false; - } - - if (//i.test(line)) { - insideIgnoreBlock = true; - return false; - } - - if (//i.test(line)) { - insideIgnoreBlock = false; - return false; - } - - if (insideIgnoreBlock) return false; - - return ( - !insideHtmlComment && - !/^\s*(\/\/|#|\/\*|\*|)/.test(line) && - !hasIgnoreComment(line) - ); - }); -} - -/** - * Recalculates statistics for a scan result after filtering usages. - * @param scanResult The current scan result - * @returns Updated scanResult with recalculated stats - */ -function calculateStats(scanResult: ScanResult): ScanResult { - const uniqueVariables = new Set( - scanResult.used.map((u: EnvUsage) => u.variable), - ).size; - - scanResult.stats = { - filesScanned: scanResult.stats.filesScanned, - totalUsages: scanResult.used.length, - uniqueVariables, - duration: scanResult.stats.duration, - }; - - return scanResult; -} - /** * Scans the codebase for environment variable usage and compares it with * the selected environment file (.env or .env.example). @@ -226,3 +161,68 @@ export async function scanUsage( return { exitWithError: result.exitWithError || duplicatesFound }; } + +/** + * Filters out commented usages from the list. + * Skipping comments: + * // process.env.API_URL + * # process.env.API_URL + * /* process.env.API_URL + * * process.env.API_URL + * + * @param usages - List of environment variable usages + * @returns Filtered list of environment variable usages + */ +function skipCommentedUsages(usages: EnvUsage[]): EnvUsage[] { + let insideHtmlComment = false; + let insideIgnoreBlock = false; + + return usages.filter((u) => { + if (!u.context) return true; + const line = u.context.trim(); + + if (line.includes('')) { + insideHtmlComment = false; + return false; + } + + if (//i.test(line)) { + insideIgnoreBlock = true; + return false; + } + + if (//i.test(line)) { + insideIgnoreBlock = false; + return false; + } + + if (insideIgnoreBlock) return false; + + return ( + !insideHtmlComment && + !/^\s*(\/\/|#|\/\*|\*|)/.test(line) && + !hasIgnoreComment(line) + ); + }); +} + +/** + * Recalculates statistics for a scan result after filtering usages. + * @param scanResult The current scan result + * @returns Updated scanResult with recalculated stats + */ +function calculateStats(scanResult: ScanResult): ScanResult { + const uniqueVariables = new Set( + scanResult.used.map((u: EnvUsage) => u.variable), + ).size; + + scanResult.stats = { + filesScanned: scanResult.stats.filesScanned, + totalUsages: scanResult.used.length, + uniqueVariables, + duration: scanResult.stats.duration, + }; + + return scanResult; +} diff --git a/src/config/options.ts b/src/config/options.ts index e6e0cac..922fb3b 100644 --- a/src/config/options.ts +++ b/src/config/options.ts @@ -96,8 +96,6 @@ export function normalizeOptions(raw: RawOptions): Options { const excludeFiles = parseList(raw.excludeFiles); const files = parseList(raw.files); - const noCompare = toBool(raw.noCompare); - const ignoreUrls = parseList(raw.ignoreUrls); const uppercaseKeys = raw.uppercaseKeys !== false; const expireWarnings = raw.expireWarnings !== false; @@ -139,7 +137,6 @@ export function normalizeOptions(raw: RawOptions): Options { secrets, strict, ignoreUrls, - noCompare, uppercaseKeys, expireWarnings, inconsistentNamingWarnings, diff --git a/src/config/types.ts b/src/config/types.ts index f7cb596..d9723a3 100644 --- a/src/config/types.ts +++ b/src/config/types.ts @@ -51,7 +51,6 @@ export type Options = { secrets: boolean; strict: boolean | undefined; ignoreUrls?: string[]; - noCompare: boolean; uppercaseKeys: boolean; expireWarnings: boolean; inconsistentNamingWarnings: boolean; @@ -83,7 +82,6 @@ export type RawOptions = { secrets?: boolean; strict?: boolean; ignoreUrls?: string[]; - noCompare?: boolean; init?: boolean; uppercaseKeys?: boolean; expireWarnings?: boolean; @@ -139,7 +137,6 @@ export interface ScanOptions { files?: string[]; secrets?: boolean; ignoreUrls?: string[]; - noCompare?: boolean; } export interface ScanResult { diff --git a/src/core/computeHealthScore.ts b/src/core/computeHealthScore.ts index 348e6c0..6c1f284 100644 --- a/src/core/computeHealthScore.ts +++ b/src/core/computeHealthScore.ts @@ -36,6 +36,9 @@ export function computeHealthScore(scan: ScanResult): number { // === 8. Expiration warnings === score -= (scan.expireWarnings?.length ?? 0) * 5; + // === 9. Inconsistent naming warnings === + score -= (scan.inconsistentNamingWarnings?.length ?? 0) * 3; + // Never go below 0 or above 100 return Math.max(0, Math.min(100, score)); } diff --git a/src/core/determineComparisonFile.ts b/src/core/determineComparisonFile.ts index 6312537..7518e01 100644 --- a/src/core/determineComparisonFile.ts +++ b/src/core/determineComparisonFile.ts @@ -13,9 +13,6 @@ export function determineComparisonFile( ): { path: string; name: string } | undefined { // Priority: explicit flags first, then auto-discovery - if (opts.noCompare) { - return undefined; - } if (opts.examplePath) { const p = resolveFromCwd(opts.cwd, opts.examplePath); if (fs.existsSync(p)) { diff --git a/src/core/helpers/isAllOk.ts b/src/core/helpers/isAllOk.ts index b592312..df83fbb 100644 --- a/src/core/helpers/isAllOk.ts +++ b/src/core/helpers/isAllOk.ts @@ -2,6 +2,7 @@ import type { Filtered } from '../../config/types.js'; /** * Checks if all filtered comparison results are okay (i.e., no issues found). + * This is used in compare.ts to determine if the comparison passed all checks. * @param filtered - The filtered comparison results. * @returns True if all checks pass, false otherwise. */ From 01d86ef2a814e24aa367b50491b051c64dd91f18 Mon Sep 17 00:00:00 2001 From: Chrilleweb Date: Thu, 11 Dec 2025 14:06:22 +0100 Subject: [PATCH 2/8] t3-env integration --- CHANGELOG.md | 1 + README.md | 16 ++ package.json | 2 +- src/cli/program.ts | 2 + src/cli/run.ts | 1 + src/commands/scanUsage.ts | 20 +++ src/config/options.ts | 2 + src/config/types.ts | 39 +++++ src/core/computeHealthScore.ts | 3 + src/core/detectT3Env.ts | 90 +++++++++++ src/core/frameworks/index.ts | 1 + src/core/frameworks/t3EnvRules.ts | 77 +++++++++ src/core/scanJsonOutput.ts | 9 ++ src/services/scanOutputToConsole.ts | 5 + src/ui/scan/printT3EnvWarnings.ts | 29 ++++ test/e2e/cli.t3-env.e2e.test.ts | 242 ++++++++++++++++++++++++++++ 16 files changed, 538 insertions(+), 1 deletion(-) create mode 100644 src/core/detectT3Env.ts create mode 100644 src/core/frameworks/t3EnvRules.ts create mode 100644 src/ui/scan/printT3EnvWarnings.ts create mode 100644 test/e2e/cli.t3-env.e2e.test.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index 10cef6e..2e5d799 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ This project follows [Keep a Changelog](https://keepachangelog.com/) and [Semant ## [Unreleased] ### Added - More jsDOcs for better code documentation. +- t3-env integration to validate environment variable usage against T3 stack schema. ### Changed - diff --git a/README.md b/README.md index 8d8d99b..e92f03a 100644 --- a/README.md +++ b/README.md @@ -166,6 +166,22 @@ To disable this behavior, use the `--no-inconsistent-naming-warnings` flags resp "inconsistentNamingWarnings": false ``` +## t3-env integration + +by default `dotenv-diff` will detect if your project uses t3-env and validate environment variable usage against the T3 stack schema. + +This will give you warnings like this: + +```bashT3-env validation issues: + - API_URL (src\index.ts:25) → Variable "API_URL" is not defined in t3-env schema. Add it to either server or client schema. +``` + +To disable this behavior, use the `--no-t3env` flag or set it to false in the config file: + +```bash +"t3env": false +``` + ## Show unused variables As default, `dotenv-diff` will list variables that are defined in `.env` but never used in your codebase. diff --git a/package.json b/package.json index 808ef1b..eed3f6b 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "dotenv-diff", - "version": "2.3.9", + "version": "2.3.10", "type": "module", "description": "Scan your codebase to find environment variables in use.", "bin": { diff --git a/src/cli/program.ts b/src/cli/program.ts index 57fb31c..9d6f57a 100644 --- a/src/cli/program.ts +++ b/src/cli/program.ts @@ -85,5 +85,7 @@ export function createProgram() { '--no-inconsistent-naming-warnings', 'Disable inconsistent naming pattern warnings', ) + .option('--t3env', 'Warns about specifik Next.js t3env usage patterns') + .option('--no-t3env', 'Disables warnings about Next.js t3env usage patterns') .option('--init', 'Create a sample dotenv-diff.config.json file'); } diff --git a/src/cli/run.ts b/src/cli/run.ts index 9c41ce8..3e59275 100644 --- a/src/cli/run.ts +++ b/src/cli/run.ts @@ -74,6 +74,7 @@ async function runScanMode(opts: Options): Promise { uppercaseKeys: opts.uppercaseKeys ?? true, expireWarnings: opts.expireWarnings, inconsistentNamingWarnings: opts.inconsistentNamingWarnings, + t3env: opts.t3env, ...(opts.files ? { files: opts.files } : {}), }); diff --git a/src/commands/scanUsage.ts b/src/commands/scanUsage.ts index 132e716..6d17b0c 100644 --- a/src/commands/scanUsage.ts +++ b/src/commands/scanUsage.ts @@ -3,6 +3,7 @@ import type { ScanUsageOptions, EnvUsage, ScanResult, + T3EnvWarning, } from '../config/types.js'; import { determineComparisonFile } from '../core/determineComparisonFile.js'; import { outputToConsole } from '../services/scanOutputToConsole.js'; @@ -13,6 +14,8 @@ import { printComparisonError } from '../ui/scan/printComparisonError.js'; import { hasIgnoreComment } from '../core/secretDetectors.js'; import { frameworkValidator } from '../core/frameworkValidator.js'; import { detectSecretsInExample } from '../core/exampleSecretDetector.js'; +import { detectT3Env } from '../core/detectT3Env.js'; +import { applyT3EnvRules } from '../core/frameworks/t3EnvRules.js'; /** * Scans the codebase for environment variable usage and compares it with @@ -60,6 +63,22 @@ export async function scanUsage( scanResult.frameworkWarnings = frameworkWarnings; } + // T3-env validation if t3env option is enabled or auto-detected + if (opts.t3env) { + const t3Detection = await detectT3Env(opts.cwd); + if (t3Detection.detected && t3Detection.schema) { + const t3EnvWarnings: T3EnvWarning[] = []; + + for (const usage of scanResult.used) { + applyT3EnvRules(usage, t3EnvWarnings, t3Detection.schema); + } + + if (t3EnvWarnings.length > 0) { + scanResult.t3EnvWarnings = t3EnvWarnings; + } + } + } + // Determine which file to compare against const compareFile = determineComparisonFile(opts); let envVariables: Record = {}; @@ -143,6 +162,7 @@ export async function scanUsage( (scanResult.secrets?.length ?? 0) > 0)) || (scanResult.exampleWarnings?.length ?? 0) > 0 || (scanResult.frameworkWarnings?.length ?? 0) > 0 || + (scanResult.t3EnvWarnings?.length ?? 0) > 0 || (scanResult.logged?.length ?? 0) > 0 || (scanResult.uppercaseWarnings?.length ?? 0) > 0 || (scanResult.expireWarnings?.length ?? 0) > 0 || diff --git a/src/config/options.ts b/src/config/options.ts index 922fb3b..4330695 100644 --- a/src/config/options.ts +++ b/src/config/options.ts @@ -100,6 +100,7 @@ export function normalizeOptions(raw: RawOptions): Options { const uppercaseKeys = raw.uppercaseKeys !== false; const expireWarnings = raw.expireWarnings !== false; const inconsistentNamingWarnings = raw.inconsistentNamingWarnings !== false; + const t3env = raw.t3env !== false; const cwd = process.cwd(); const envFlag = @@ -140,5 +141,6 @@ export function normalizeOptions(raw: RawOptions): Options { uppercaseKeys, expireWarnings, inconsistentNamingWarnings, + t3env, }; } diff --git a/src/config/types.ts b/src/config/types.ts index d9723a3..a12e89e 100644 --- a/src/config/types.ts +++ b/src/config/types.ts @@ -54,6 +54,7 @@ export type Options = { uppercaseKeys: boolean; expireWarnings: boolean; inconsistentNamingWarnings: boolean; + t3env: boolean; }; /** Type representing the raw options for the comparison @@ -86,6 +87,7 @@ export type RawOptions = { uppercaseKeys?: boolean; expireWarnings?: boolean; inconsistentNamingWarnings?: boolean; + t3env?: boolean; }; /** @@ -160,6 +162,7 @@ export interface ScanResult { uppercaseWarnings?: UppercaseWarning[]; expireWarnings?: ExpireWarning[]; inconsistentNamingWarnings?: InconsistentNamingWarning[]; + t3EnvWarnings?: T3EnvWarning[]; } /** Options for scanning the codebase for environment variable usage. */ @@ -177,6 +180,7 @@ export interface ScanUsageOptions extends ScanOptions { uppercaseKeys?: boolean; expireWarnings?: boolean; inconsistentNamingWarnings?: boolean; + t3env?: boolean; } export interface ScanJsonEntry { @@ -236,6 +240,12 @@ export interface ScanJsonEntry { key2: string; suggestion: string; }>; + t3EnvWarnings?: Array<{ + variable: string; + reason: string; + file: string; + line: number; + }>; } // Type for grouped usages by variable @@ -310,3 +320,32 @@ export interface InconsistentNamingWarning { key2: string; suggestion: string; } + +/** + * Schema structure for t3-env configuration + */ +export interface T3EnvSchema { + server: string[]; + client: string[]; +} + +/** + * Result of t3-env detection + */ +export interface T3EnvDetectionResult { + detected: boolean; + schema?: T3EnvSchema; + detectionMethod: 'config' | null; + configPath?: string; +} + +/** + * Warning for t3-env validation issues + */ +export interface T3EnvWarning { + variable: string; + reason: string; + file: string; + line: number; + framework: 't3-env'; +} diff --git a/src/core/computeHealthScore.ts b/src/core/computeHealthScore.ts index 6c1f284..25cba25 100644 --- a/src/core/computeHealthScore.ts +++ b/src/core/computeHealthScore.ts @@ -39,6 +39,9 @@ export function computeHealthScore(scan: ScanResult): number { // === 9. Inconsistent naming warnings === score -= (scan.inconsistentNamingWarnings?.length ?? 0) * 3; + // === 10. T3-env warnings === + score -= (scan.t3EnvWarnings?.length ?? 0) * 5; + // Never go below 0 or above 100 return Math.max(0, Math.min(100, score)); } diff --git a/src/core/detectT3Env.ts b/src/core/detectT3Env.ts new file mode 100644 index 0000000..e669f95 --- /dev/null +++ b/src/core/detectT3Env.ts @@ -0,0 +1,90 @@ +import fs from 'fs'; +import path from 'path'; +import type { T3EnvDetectionResult, T3EnvSchema } from '../config/types.js'; + +/** + * Detects if a project uses t3-env by looking for env.ts files + * @param cwd - Current working directory to scan + * @returns Detection result with schema if found + */ +export async function detectT3Env(cwd: string): Promise { + // Check common locations for env config files + const envFilePaths = [ + 'src/env.ts', + 'src/env.mjs', + 'env.ts', + 'env.mjs', + 'lib/env.ts', + 'lib/env.mjs' + ]; + + for (const envPath of envFilePaths) { + const fullPath = path.join(cwd, envPath); + + if (fs.existsSync(fullPath)) { + const content = fs.readFileSync(fullPath, 'utf8'); + + // Check if file contains t3-env usage + if (content.includes('createEnv')) { + const schema = parseT3EnvFromContent(content); + if (schema) { + return { + detected: true, + schema, + detectionMethod: 'config', + configPath: envPath + }; + } + } + } + } + + return { + detected: false, + detectionMethod: null + }; +} + +/** + * Parses t3-env schema from file content + */ +export function parseT3EnvFromContent(content: string): T3EnvSchema | null { + try { + // Find server and client schema sections + const serverMatch = content.match(/server\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/s); + const clientMatch = content.match(/client\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/s); + + if (!serverMatch && !clientMatch) { + return null; + } + + const serverKeys = serverMatch && serverMatch[1] ? extractKeysFromSchema(serverMatch[1]) : []; + const clientKeys = clientMatch && clientMatch[1] ? extractKeysFromSchema(clientMatch[1]) : []; + + return { + server: serverKeys, + client: clientKeys + }; + } catch { + return null; + } +} + +/** + * Extracts variable keys from schema block + */ +function extractKeysFromSchema(schemaBlock: string): string[] { + const keys: string[] = []; + + // Match patterns like: VARIABLE_NAME: z.string() + const keyPattern = /([A-Z_][A-Z0-9_]*)\s*:/g; + let match; + + while ((match = keyPattern.exec(schemaBlock)) !== null) { + if (match[1]) { + keys.push(match[1]); + } + } + + return keys; +} diff --git a/src/core/frameworks/index.ts b/src/core/frameworks/index.ts index 13b5954..590a3d3 100644 --- a/src/core/frameworks/index.ts +++ b/src/core/frameworks/index.ts @@ -1,2 +1,3 @@ export { applySvelteKitRules } from './sveltekitRules.js'; export { applyNextJsRules } from './nextJsRules.js'; +export { applyT3EnvRules } from './t3EnvRules.js'; diff --git a/src/core/frameworks/t3EnvRules.ts b/src/core/frameworks/t3EnvRules.ts new file mode 100644 index 0000000..99b1e3f --- /dev/null +++ b/src/core/frameworks/t3EnvRules.ts @@ -0,0 +1,77 @@ +import type { EnvUsage, T3EnvSchema } from '../../config/types.js'; +import type { T3EnvWarning } from '../../config/types.js'; + +/** + * Applies t3-env specific validation rules + * @param u - The environment variable usage information + * @param warnings - The array to push warnings into + * @param schema - The t3-env schema to validate against + */ +export function applyT3EnvRules( + u: EnvUsage, + warnings: T3EnvWarning[], + schema: T3EnvSchema, +): void { + const allServerVars = schema.server; + const allClientVars = schema.client; + + // Check if variable is used in client code but not defined in client schema + const isClientContext = + u.file.includes('/components/') || + u.file.includes('/pages/') || + u.file.includes('/app/') || + u.file.includes('client') || + u.file.includes('browser') || + u.pattern === 'import.meta.env'; + + const isServerContext = + u.file.includes('/api/') || + u.file.includes('server') || + u.file.endsWith('.server.ts') || + u.file.endsWith('.server.js') || + u.pattern === 'process.env'; + + // Variable used in client context but only defined in server schema + if (isClientContext && allServerVars.includes(u.variable) && !allClientVars.includes(u.variable)) { + warnings.push({ + variable: u.variable, + reason: `Variable "${u.variable}" is used in client code but only defined in server schema. Add to client schema or move to server-only code.`, + file: u.file, + line: u.line, + framework: 't3-env', + }); + } + + // Variable used in server context but only defined in client schema + if (isServerContext && allClientVars.includes(u.variable) && !allServerVars.includes(u.variable)) { + warnings.push({ + variable: u.variable, + reason: `Variable "${u.variable}" is used in server code but only defined in client schema. This may expose client variables on the server.`, + file: u.file, + line: u.line, + framework: 't3-env', + }); + } + + // Variable not defined in any schema + if (!allServerVars.includes(u.variable) && !allClientVars.includes(u.variable)) { + warnings.push({ + variable: u.variable, + reason: `Variable "${u.variable}" is not defined in t3-env schema. Add it to either server or client schema.`, + file: u.file, + line: u.line, + framework: 't3-env', + }); + } + + // Warn about NEXT_PUBLIC_ variables in t3-env projects + if (u.variable.startsWith('NEXT_PUBLIC_')) { + warnings.push({ + variable: u.variable, + reason: `Use t3-env client schema instead of NEXT_PUBLIC_ prefix for type-safe environment variables.`, + file: u.file, + line: u.line, + framework: 't3-env', + }); + } +} \ No newline at end of file diff --git a/src/core/scanJsonOutput.ts b/src/core/scanJsonOutput.ts index 226f177..1f62610 100644 --- a/src/core/scanJsonOutput.ts +++ b/src/core/scanJsonOutput.ts @@ -67,6 +67,15 @@ export function createJsonOutput( })); } + if (scanResult.t3EnvWarnings?.length) { + output.t3EnvWarnings = scanResult.t3EnvWarnings.map((w) => ({ + variable: w.variable, + reason: w.reason, + file: w.file, + line: w.line, + })); + } + // Add duplicates if found if (scanResult.duplicates) { output.duplicates = scanResult.duplicates; diff --git a/src/services/scanOutputToConsole.ts b/src/services/scanOutputToConsole.ts index 1115112..f72f3e1 100644 --- a/src/services/scanOutputToConsole.ts +++ b/src/services/scanOutputToConsole.ts @@ -15,6 +15,7 @@ import { printStrictModeError } from '../ui/shared/printStrictModeError.js'; import { printFixTips } from '../ui/shared/printFixTips.js'; import { printAutoFix } from '../ui/shared/printAutoFix.js'; import { printFrameworkWarnings } from '../ui/scan/printFrameworkWarnings.js'; +import { printT3EnvWarnings } from '../ui/scan/printT3EnvWarnings.js'; import { printExampleWarnings } from '../ui/scan/printExampleWarnings.js'; import { printConsolelogWarning } from '../ui/scan/printConsolelogWarning.js'; import { printUppercaseWarning } from '../ui/scan/printUppercaseWarning.js'; @@ -79,6 +80,10 @@ export function outputToConsole( printFrameworkWarnings(scanResult.frameworkWarnings, isJson); } + if (scanResult.t3EnvWarnings && scanResult.t3EnvWarnings.length > 0) { + printT3EnvWarnings(scanResult.t3EnvWarnings, isJson); + } + if (scanResult.uppercaseWarnings && scanResult.uppercaseWarnings.length > 0) { printUppercaseWarning( scanResult.uppercaseWarnings, diff --git a/src/ui/scan/printT3EnvWarnings.ts b/src/ui/scan/printT3EnvWarnings.ts new file mode 100644 index 0000000..9ae1d33 --- /dev/null +++ b/src/ui/scan/printT3EnvWarnings.ts @@ -0,0 +1,29 @@ +import chalk from 'chalk'; +import type { T3EnvWarning } from '../../config/types.js'; + +/** + * Prints t3-env validation warnings to the console. + * @param warnings - List of t3-env validation warnings + * @param json - Whether to output in JSON format + */ +export function printT3EnvWarnings( + warnings: T3EnvWarning[], + json: boolean, +): void { + if (!warnings || warnings.length === 0) return; + + if (json) { + console.log(JSON.stringify({ t3EnvWarnings: warnings }, null, 2)); + return; + } + + console.log(chalk.yellow('⚠️ T3-env validation issues:')); + + for (const w of warnings) { + console.log( + chalk.yellow(` - ${w.variable} (${w.file}:${w.line}) → ${w.reason}`), + ); + } + + console.log(); +} diff --git a/test/e2e/cli.t3-env.e2e.test.ts b/test/e2e/cli.t3-env.e2e.test.ts new file mode 100644 index 0000000..87ec618 --- /dev/null +++ b/test/e2e/cli.t3-env.e2e.test.ts @@ -0,0 +1,242 @@ +import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest'; +import fs from 'fs'; +import path from 'path'; +import { makeTmpDir, rmrf } from '../utils/fs-helpers.js'; +import { buildOnce, runCli, cleanupBuild } from '../utils/cli-helpers.js'; + +const tmpDirs: string[] = []; + +beforeAll(() => { + buildOnce(); +}); + +afterAll(() => { + cleanupBuild(); +}); + +afterEach(() => { + while (tmpDirs.length) { + const dir = tmpDirs.pop(); + if (dir) rmrf(dir); + } +}); + +function tmpDir() { + const dir = makeTmpDir(); + tmpDirs.push(dir); + return dir; +} + +/** + * Minimal t3-env project setup + */ +function makeT3EnvProject(cwd: string) { + fs.mkdirSync(path.join(cwd, 'src'), { recursive: true }); + + fs.writeFileSync( + path.join(cwd, 'src', 'env.ts'), + `import { createEnv } from "@t3-oss/env-nextjs"; +import { z } from "zod"; + +export const env = createEnv({ + server: { + DATABASE_URL: z.string(), + SECRET_KEY: z.string(), + ADMIN_EMAIL: z.string(), + }, + client: { + NEXT_PUBLIC_API_URL: z.string(), + NEXT_PUBLIC_SITE_NAME: z.string(), + }, + runtimeEnv: { + DATABASE_URL: process.env.DATABASE_URL, + SECRET_KEY: process.env.SECRET_KEY, + ADMIN_EMAIL: process.env.ADMIN_EMAIL, + NEXT_PUBLIC_API_URL: process.env.NEXT_PUBLIC_API_URL, + NEXT_PUBLIC_SITE_NAME: process.env.NEXT_PUBLIC_SITE_NAME, + }, +});` + ); + + fs.writeFileSync( + path.join(cwd, '.env'), + `DATABASE_URL=postgresql://localhost:5432/db +SECRET_KEY=secret123 +ADMIN_EMAIL=admin@test.com +NEXT_PUBLIC_API_URL=https://api.test.com +NEXT_PUBLIC_SITE_NAME=Test Site` + ); +} + +describe('t3-env warnings', () => { + it('should detect server variable used in client code', () => { + const cwd = tmpDir(); + makeT3EnvProject(cwd); + + fs.mkdirSync(path.join(cwd, 'src', 'components'), { recursive: true }); + fs.writeFileSync( + path.join(cwd, 'src', 'components', 'ClientComponent.tsx'), + `import React from 'react'; + +export function ClientComponent() { + // Should warn: using server variable in client code + const dbUrl = process.env.DATABASE_URL; + + return
Client Component
; +}` + ); + + const res = runCli(cwd, []); + + expect(res.status).toBe(0); + expect(res.stdout).toContain('T3-env validation issues'); + expect(res.stdout).toContain('DATABASE_URL'); + expect(res.stdout).toContain('Use t3-env client schema instead of NEXT_PUBLIC_ prefix for type-safe environment variables.'); + }); + + it('should detect client variable used in server code', () => { + const cwd = tmpDir(); + makeT3EnvProject(cwd); + + fs.mkdirSync(path.join(cwd, 'src', 'pages', 'api'), { recursive: true }); + fs.writeFileSync( + path.join(cwd, 'src', 'pages', 'api', 'users.ts'), + `import { NextApiRequest, NextApiResponse } from 'next'; + +export default function handler(req: NextApiRequest, res: NextApiResponse) { + // Should warn: using client variable in server code + const siteName = process.env.NEXT_PUBLIC_SITE_NAME; + + res.json({ success: true }); +}` + ); + + const res = runCli(cwd, []); + + expect(res.status).toBe(0); + expect(res.stdout).toContain('T3-env validation issues'); + expect(res.stdout).toContain('NEXT_PUBLIC_SITE_NAME'); + expect(res.stdout).toContain('Use t3-env client schema instead of NEXT_PUBLIC_ prefix for type-safe environment variables.'); + }); + + it('should detect undefined variables not in schema', () => { + const cwd = tmpDir(); + makeT3EnvProject(cwd); + + fs.mkdirSync(path.join(cwd, 'src'), { recursive: true }); + fs.writeFileSync( + path.join(cwd, 'src', 'test.js'), + `const unknownVar = process.env.UNDEFINED_VAR;` + ); + + const res = runCli(cwd, []); + + expect(res.status).toBe(1); + expect(res.stdout).toContain('T3-env validation issues'); + expect(res.stdout).toContain('UNDEFINED_VAR'); + expect(res.stdout).toContain('Variable "UNDEFINED_VAR" is not defined in t3-env schema. Add it to either server or client schema.'); + }); + + it('should warn about NEXT_PUBLIC_ usage in t3-env projects', () => { + const cwd = tmpDir(); + makeT3EnvProject(cwd); + + fs.mkdirSync(path.join(cwd, 'src', 'lib'), { recursive: true }); + fs.writeFileSync( + path.join(cwd, 'src', 'lib', 'client.ts'), + `export const config = { + apiUrl: process.env.NEXT_PUBLIC_OLD_API_URL, +};` + ); + + const res = runCli(cwd, ['--scan-usage', '--t3env']); + + expect(res.status).toBe(1); + expect(res.stdout).toContain('T3-env validation issues'); + expect(res.stdout).toContain('NEXT_PUBLIC_OLD_API_URL'); + expect(res.stdout).toContain('is not defined in t3-env schema. Add it to either server or client schema.'); + }); + + it('should not show t3-env warnings when t3env flag is disabled', () => { + const cwd = tmpDir(); + makeT3EnvProject(cwd); + + fs.writeFileSync( + path.join(cwd, 'src', 'test.js'), + `const key = process.env.UNDEFINED_VAR;` + ); + + const res = runCli(cwd, ['--scan-usage', '--no-t3env']); + + expect(res.stdout).not.toContain('T3-env validation issues'); + expect(res.stdout).not.toContain('not defined in t3-env schema'); + }); + + it('should work with env.mjs files', () => { + const cwd = tmpDir(); + + fs.writeFileSync( + path.join(cwd, 'env.mjs'), + `import { createEnv } from "@t3-oss/env-nextjs"; +import { z } from "zod"; + +export const env = createEnv({ + server: { + DATABASE_URL: z.string(), + }, + client: { + NEXT_PUBLIC_APP_URL: z.string(), + }, +});` + ); + + fs.mkdirSync(path.join(cwd, 'src'), { recursive: true }); + fs.writeFileSync( + path.join(cwd, 'src', 'test.js'), + `// Should warn: server var in client context +const dbUrl = process.env.DATABASE_UPSURL;` + ); + + fs.writeFileSync(path.join(cwd, '.env'), 'DATABASE_URL=test'); + + const res = runCli(cwd, ['--scan-usage', '--t3env']); + console.log(res.stdout); + expect(res.status).toBe(1); + expect(res.stdout).toContain('T3-env validation issues'); + expect(res.stdout).toContain('DATABASE_URL'); + expect(res.stdout).toContain('Variable "DATABASE_UPSURL" is not defined in t3-env schema. Add it to either server or client schema.'); + }); + + it('should handle JSON output format', () => { + const cwd = tmpDir(); + makeT3EnvProject(cwd); + + fs.writeFileSync( + path.join(cwd, 'test.js'), + `const test = process.env.UNDEFINED_VAR;` + ); + + const res = runCli(cwd, ['--json']); + expect(res.status).toBe(1); + const output = JSON.parse(res.stdout); + expect(output.t3EnvWarnings).toBeDefined(); + expect(output.t3EnvWarnings.length).toBeGreaterThan(0); + }); + + it('should detect when no t3-env config exists', () => { + const cwd = tmpDir(); + + // No env.ts file - should not detect t3-env + fs.writeFileSync( + path.join(cwd, 'test.js'), + `const test = process.env.ANY_VAR;` + ); + + fs.writeFileSync(path.join(cwd, '.env'), ''); + + const res = runCli(cwd, ['--scan-usage', '--t3env']); + + expect(res.stdout).not.toContain('T3-env validation issues'); + }); +}); + From 6ddfcc080cc3ce857a153dd7b3e0469ce6d4d1fc Mon Sep 17 00:00:00 2001 From: Chrilleweb Date: Thu, 11 Dec 2025 14:13:31 +0100 Subject: [PATCH 3/8] updated changelog --- CHANGELOG.md | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2e5d799..b3e0ff5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,12 +4,19 @@ This project follows [Keep a Changelog](https://keepachangelog.com/) and [Semant ## [Unreleased] ### Added -- More jsDOcs for better code documentation. -- t3-env integration to validate environment variable usage against T3 stack schema. +- ### Changed - +### Fixed +- + +## [2.3.10] - 2025-12-11 +### Added +- More jsDOcs for better code documentation. +- t3-env integration to validate environment variable usage against T3 stack schema. + ### Fixed - Removed unused code for old --no-compare option. From f834df67edea193812aabeb2343f15f48e7731c5 Mon Sep 17 00:00:00 2001 From: Chrilleweb Date: Thu, 11 Dec 2025 15:04:39 +0100 Subject: [PATCH 4/8] format --- src/cli/program.ts | 5 +++- src/commands/scanUsage.ts | 4 +-- src/core/detectT3Env.ts | 41 ++++++++++++++++++++----------- src/core/frameworks/t3EnvRules.ts | 23 ++++++++++++----- 4 files changed, 50 insertions(+), 23 deletions(-) diff --git a/src/cli/program.ts b/src/cli/program.ts index 9d6f57a..c422a17 100644 --- a/src/cli/program.ts +++ b/src/cli/program.ts @@ -86,6 +86,9 @@ export function createProgram() { 'Disable inconsistent naming pattern warnings', ) .option('--t3env', 'Warns about specifik Next.js t3env usage patterns') - .option('--no-t3env', 'Disables warnings about Next.js t3env usage patterns') + .option( + '--no-t3env', + 'Disables warnings about Next.js t3env usage patterns', + ) .option('--init', 'Create a sample dotenv-diff.config.json file'); } diff --git a/src/commands/scanUsage.ts b/src/commands/scanUsage.ts index 6d17b0c..0b2bb6b 100644 --- a/src/commands/scanUsage.ts +++ b/src/commands/scanUsage.ts @@ -68,11 +68,11 @@ export async function scanUsage( const t3Detection = await detectT3Env(opts.cwd); if (t3Detection.detected && t3Detection.schema) { const t3EnvWarnings: T3EnvWarning[] = []; - + for (const usage of scanResult.used) { applyT3EnvRules(usage, t3EnvWarnings, t3Detection.schema); } - + if (t3EnvWarnings.length > 0) { scanResult.t3EnvWarnings = t3EnvWarnings; } diff --git a/src/core/detectT3Env.ts b/src/core/detectT3Env.ts index e669f95..e805d86 100644 --- a/src/core/detectT3Env.ts +++ b/src/core/detectT3Env.ts @@ -11,19 +11,22 @@ export async function detectT3Env(cwd: string): Promise { // Check common locations for env config files const envFilePaths = [ 'src/env.ts', - 'src/env.mjs', + 'src/env.mjs', + 'src/env.js', 'env.ts', 'env.mjs', + 'env.js', 'lib/env.ts', - 'lib/env.mjs' + 'lib/env.mjs', + 'lib/env.js', ]; for (const envPath of envFilePaths) { const fullPath = path.join(cwd, envPath); - + if (fs.existsSync(fullPath)) { const content = fs.readFileSync(fullPath, 'utf8'); - + // Check if file contains t3-env usage if (content.includes('createEnv')) { const schema = parseT3EnvFromContent(content); @@ -32,7 +35,7 @@ export async function detectT3Env(cwd: string): Promise { detected: true, schema, detectionMethod: 'config', - configPath: envPath + configPath: envPath, }; } } @@ -41,7 +44,7 @@ export async function detectT3Env(cwd: string): Promise { return { detected: false, - detectionMethod: null + detectionMethod: null, }; } @@ -51,19 +54,29 @@ export async function detectT3Env(cwd: string): Promise { export function parseT3EnvFromContent(content: string): T3EnvSchema | null { try { // Find server and client schema sections - const serverMatch = content.match(/server\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/s); - const clientMatch = content.match(/client\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/s); + const serverMatch = content.match( + /server\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/s, + ); + const clientMatch = content.match( + /client\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/s, + ); if (!serverMatch && !clientMatch) { return null; } - const serverKeys = serverMatch && serverMatch[1] ? extractKeysFromSchema(serverMatch[1]) : []; - const clientKeys = clientMatch && clientMatch[1] ? extractKeysFromSchema(clientMatch[1]) : []; + const serverKeys = + serverMatch && serverMatch[1] + ? extractKeysFromSchema(serverMatch[1]) + : []; + const clientKeys = + clientMatch && clientMatch[1] + ? extractKeysFromSchema(clientMatch[1]) + : []; return { server: serverKeys, - client: clientKeys + client: clientKeys, }; } catch { return null; @@ -75,16 +88,16 @@ export function parseT3EnvFromContent(content: string): T3EnvSchema | null { */ function extractKeysFromSchema(schemaBlock: string): string[] { const keys: string[] = []; - + // Match patterns like: VARIABLE_NAME: z.string() const keyPattern = /([A-Z_][A-Z0-9_]*)\s*:/g; let match; - + while ((match = keyPattern.exec(schemaBlock)) !== null) { if (match[1]) { keys.push(match[1]); } } - + return keys; } diff --git a/src/core/frameworks/t3EnvRules.ts b/src/core/frameworks/t3EnvRules.ts index 99b1e3f..8d2f505 100644 --- a/src/core/frameworks/t3EnvRules.ts +++ b/src/core/frameworks/t3EnvRules.ts @@ -16,7 +16,7 @@ export function applyT3EnvRules( const allClientVars = schema.client; // Check if variable is used in client code but not defined in client schema - const isClientContext = + const isClientContext = u.file.includes('/components/') || u.file.includes('/pages/') || u.file.includes('/app/') || @@ -24,7 +24,7 @@ export function applyT3EnvRules( u.file.includes('browser') || u.pattern === 'import.meta.env'; - const isServerContext = + const isServerContext = u.file.includes('/api/') || u.file.includes('server') || u.file.endsWith('.server.ts') || @@ -32,7 +32,11 @@ export function applyT3EnvRules( u.pattern === 'process.env'; // Variable used in client context but only defined in server schema - if (isClientContext && allServerVars.includes(u.variable) && !allClientVars.includes(u.variable)) { + if ( + isClientContext && + allServerVars.includes(u.variable) && + !allClientVars.includes(u.variable) + ) { warnings.push({ variable: u.variable, reason: `Variable "${u.variable}" is used in client code but only defined in server schema. Add to client schema or move to server-only code.`, @@ -43,7 +47,11 @@ export function applyT3EnvRules( } // Variable used in server context but only defined in client schema - if (isServerContext && allClientVars.includes(u.variable) && !allServerVars.includes(u.variable)) { + if ( + isServerContext && + allClientVars.includes(u.variable) && + !allServerVars.includes(u.variable) + ) { warnings.push({ variable: u.variable, reason: `Variable "${u.variable}" is used in server code but only defined in client schema. This may expose client variables on the server.`, @@ -54,7 +62,10 @@ export function applyT3EnvRules( } // Variable not defined in any schema - if (!allServerVars.includes(u.variable) && !allClientVars.includes(u.variable)) { + if ( + !allServerVars.includes(u.variable) && + !allClientVars.includes(u.variable) + ) { warnings.push({ variable: u.variable, reason: `Variable "${u.variable}" is not defined in t3-env schema. Add it to either server or client schema.`, @@ -74,4 +85,4 @@ export function applyT3EnvRules( framework: 't3-env', }); } -} \ No newline at end of file +} From bc0652207e0fe4d6b1d5c35e838a5b4b81278ee1 Mon Sep 17 00:00:00 2001 From: Chrilleweb Date: Thu, 11 Dec 2025 15:13:22 +0100 Subject: [PATCH 5/8] detect also with pacakge.json --- src/config/types.ts | 2 +- src/core/detectT3Env.ts | 37 +++++++++++++++++++++++++++++++-- test/e2e/cli.t3-env.e2e.test.ts | 24 +++++++++++++++++++++ 3 files changed, 60 insertions(+), 3 deletions(-) diff --git a/src/config/types.ts b/src/config/types.ts index a12e89e..feb03f7 100644 --- a/src/config/types.ts +++ b/src/config/types.ts @@ -335,7 +335,7 @@ export interface T3EnvSchema { export interface T3EnvDetectionResult { detected: boolean; schema?: T3EnvSchema; - detectionMethod: 'config' | null; + detectionMethod: 'config' | 'package.json' | null; configPath?: string; } diff --git a/src/core/detectT3Env.ts b/src/core/detectT3Env.ts index e805d86..08ff97a 100644 --- a/src/core/detectT3Env.ts +++ b/src/core/detectT3Env.ts @@ -8,6 +8,15 @@ import type { T3EnvDetectionResult, T3EnvSchema } from '../config/types.js'; * @returns Detection result with schema if found */ export async function detectT3Env(cwd: string): Promise { + const hasT3EnvDependency = await checkPackageJson(cwd); + + if (!hasT3EnvDependency) { + return { + detected: false, + detectionMethod: null, + }; + } + // Check common locations for env config files const envFilePaths = [ 'src/env.ts', @@ -43,8 +52,9 @@ export async function detectT3Env(cwd: string): Promise { } return { - detected: false, - detectionMethod: null, + detected: true, + schema: { server: [], client: [] }, + detectionMethod: 'package.json', }; } @@ -101,3 +111,26 @@ function extractKeysFromSchema(schemaBlock: string): string[] { return keys; } + +/** + * Checks if t3-env is listed in package.json dependencies + */ +async function checkPackageJson(cwd: string): Promise { + const packageJsonPath = path.join(cwd, 'package.json'); + + if (!fs.existsSync(packageJsonPath)) { + return false; + } + + try { + const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')); + const allDeps = { + ...packageJson.dependencies, + ...packageJson.devDependencies, + }; + + return !!(allDeps['@t3-oss/env-core'] || allDeps['@t3-oss/env-nextjs']); + } catch { + return false; + } +} diff --git a/test/e2e/cli.t3-env.e2e.test.ts b/test/e2e/cli.t3-env.e2e.test.ts index 87ec618..cb3d216 100644 --- a/test/e2e/cli.t3-env.e2e.test.ts +++ b/test/e2e/cli.t3-env.e2e.test.ts @@ -32,6 +32,18 @@ function tmpDir() { */ function makeT3EnvProject(cwd: string) { fs.mkdirSync(path.join(cwd, 'src'), { recursive: true }); + + fs.writeFileSync( + path.join(cwd, 'package.json'), + JSON.stringify({ + name: "test-project", + version: "1.0.0", + dependencies: { + "@t3-oss/env-nextjs": "^0.7.0", + "zod": "^3.22.0" + } + }, null, 2) + ); fs.writeFileSync( path.join(cwd, 'src', 'env.ts'), @@ -175,6 +187,18 @@ export default function handler(req: NextApiRequest, res: NextApiResponse) { it('should work with env.mjs files', () => { const cwd = tmpDir(); + fs.writeFileSync( + path.join(cwd, 'package.json'), + JSON.stringify({ + name: "test-project", + version: "1.0.0", + dependencies: { + "@t3-oss/env-nextjs": "^0.7.0", + "zod": "^3.22.0" + } + }, null, 2) + ); + fs.writeFileSync( path.join(cwd, 'env.mjs'), `import { createEnv } from "@t3-oss/env-nextjs"; From de78e2529990c421a29942ad21bb43c9691e1e0e Mon Sep 17 00:00:00 2001 From: Chrilleweb Date: Thu, 11 Dec 2025 15:15:44 +0100 Subject: [PATCH 6/8] folder structure --- src/commands/scanUsage.ts | 4 ++-- src/core/frameworks/index.ts | 1 - src/core/{ => t3env}/detectT3Env.ts | 2 +- src/core/{frameworks => t3env}/t3EnvRules.ts | 0 4 files changed, 3 insertions(+), 4 deletions(-) rename src/core/{ => t3env}/detectT3Env.ts (97%) rename src/core/{frameworks => t3env}/t3EnvRules.ts (100%) diff --git a/src/commands/scanUsage.ts b/src/commands/scanUsage.ts index 0b2bb6b..cb7d65e 100644 --- a/src/commands/scanUsage.ts +++ b/src/commands/scanUsage.ts @@ -14,8 +14,8 @@ import { printComparisonError } from '../ui/scan/printComparisonError.js'; import { hasIgnoreComment } from '../core/secretDetectors.js'; import { frameworkValidator } from '../core/frameworkValidator.js'; import { detectSecretsInExample } from '../core/exampleSecretDetector.js'; -import { detectT3Env } from '../core/detectT3Env.js'; -import { applyT3EnvRules } from '../core/frameworks/t3EnvRules.js'; +import { detectT3Env } from '../core/t3env/detectT3Env.js'; +import { applyT3EnvRules } from '../core/t3env/t3EnvRules.js'; /** * Scans the codebase for environment variable usage and compares it with diff --git a/src/core/frameworks/index.ts b/src/core/frameworks/index.ts index 590a3d3..13b5954 100644 --- a/src/core/frameworks/index.ts +++ b/src/core/frameworks/index.ts @@ -1,3 +1,2 @@ export { applySvelteKitRules } from './sveltekitRules.js'; export { applyNextJsRules } from './nextJsRules.js'; -export { applyT3EnvRules } from './t3EnvRules.js'; diff --git a/src/core/detectT3Env.ts b/src/core/t3env/detectT3Env.ts similarity index 97% rename from src/core/detectT3Env.ts rename to src/core/t3env/detectT3Env.ts index 08ff97a..1e61390 100644 --- a/src/core/detectT3Env.ts +++ b/src/core/t3env/detectT3Env.ts @@ -1,6 +1,6 @@ import fs from 'fs'; import path from 'path'; -import type { T3EnvDetectionResult, T3EnvSchema } from '../config/types.js'; +import type { T3EnvDetectionResult, T3EnvSchema } from '../../config/types.js'; /** * Detects if a project uses t3-env by looking for env.ts files diff --git a/src/core/frameworks/t3EnvRules.ts b/src/core/t3env/t3EnvRules.ts similarity index 100% rename from src/core/frameworks/t3EnvRules.ts rename to src/core/t3env/t3EnvRules.ts From 24aceed8f5e98376c3b46bd2a7f832104948591e Mon Sep 17 00:00:00 2001 From: Chrilleweb Date: Thu, 11 Dec 2025 17:14:34 +0100 Subject: [PATCH 7/8] strict mode for t3-env warnings --- src/services/scanOutputToConsole.ts | 1 + src/ui/shared/printStrictModeError.ts | 3 +++ test/e2e/cli.t3-env.e2e.test.ts | 10 ++++++++++ 3 files changed, 14 insertions(+) diff --git a/src/services/scanOutputToConsole.ts b/src/services/scanOutputToConsole.ts index f72f3e1..e95be8a 100644 --- a/src/services/scanOutputToConsole.ts +++ b/src/services/scanOutputToConsole.ts @@ -194,6 +194,7 @@ export function outputToConsole( expireWarnings: scanResult.expireWarnings?.length ?? 0, inconsistentNamingWarnings: scanResult.inconsistentNamingWarnings?.length ?? 0, + t3EnvWarnings: scanResult.t3EnvWarnings?.length ?? 0, }, isJson, ); diff --git a/src/ui/shared/printStrictModeError.ts b/src/ui/shared/printStrictModeError.ts index a91162d..9b5c04e 100644 --- a/src/ui/shared/printStrictModeError.ts +++ b/src/ui/shared/printStrictModeError.ts @@ -12,6 +12,7 @@ interface StrictModeContext { uppercaseWarnings?: number; expireWarnings?: number; inconsistentNamingWarnings?: number; + t3EnvWarnings?: number; } /** @@ -43,6 +44,8 @@ export function printStrictModeError( warnings.push('expired environment variables'); if (ctx.inconsistentNamingWarnings && ctx.inconsistentNamingWarnings > 0) warnings.push('inconsistent naming patterns'); + if (ctx.t3EnvWarnings && ctx.t3EnvWarnings > 0) + warnings.push('T3 stack environment variable issues'); if (warnings.length === 0) return false; diff --git a/test/e2e/cli.t3-env.e2e.test.ts b/test/e2e/cli.t3-env.e2e.test.ts index cb3d216..b6c1405 100644 --- a/test/e2e/cli.t3-env.e2e.test.ts +++ b/test/e2e/cli.t3-env.e2e.test.ts @@ -262,5 +262,15 @@ const dbUrl = process.env.DATABASE_UPSURL;` expect(res.stdout).not.toContain('T3-env validation issues'); }); + + it('will fail on strict mode when t3-env warnings exist', () => { + const cwd = tmpDir(); + makeT3EnvProject(cwd); + + const res = runCli(cwd, ['--scan-usage', '--t3env', '--strict']); + console.log(res.stdout); + expect(res.status).toBe(1); + expect(res.stdout).toContain('T3-env validation issues'); + }); }); From 11fe666407ff940fcd1def77e489529e66073465 Mon Sep 17 00:00:00 2001 From: Chrilleweb Date: Thu, 11 Dec 2025 17:27:03 +0100 Subject: [PATCH 8/8] new demo on readme --- README.md | 2 +- public/demo2.png | Bin 0 -> 112361 bytes 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 public/demo2.png diff --git a/README.md b/README.md index e92f03a..ae4e889 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # dotenv-diff -![Demo](./public/demo.gif) +![Demo](./public/demo2.png) Scan your codebase to detect which environment variables are used in your code. diff --git a/public/demo2.png b/public/demo2.png new file mode 100644 index 0000000000000000000000000000000000000000..1bb152d92ee939a72665785d69d50a930d0e9889 GIT binary patch literal 112361 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
  • ?p;oW{2l&<@J-2O&P) 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

    3bEsq|6FCZg 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 kxO$$5MUkhp|6i%Q1Vkb<+}OLJg@pLh)-