@firtoz/worker-helper 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @firtoz/worker-helper
 
+## 1.2.0
+
+### Minor Changes
+
+- [`2725815`](https://github.com/firtoz/fullstack-toolkit/commit/27258158dd318b34b44ed77b88b2ac9b2b4b6a3d) Thanks [@firtoz](https://github.com/firtoz)! - Improved workspace-wide type generation and environment setup
+
+  - Refactored `cf-typegen.ts` to automatically discover all wrangler configs using `git ls-files`
+  - Uses git for workspace discovery - fast, respects .gitignore, and finds all tracked configs
+  - Added `prepareEnvFiles` utility to handle .env file creation from .env.example templates
+  - Type generation now includes bindings from all workspace projects for better DX
+
 ## 1.1.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@firtoz/worker-helper",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "Type-safe Web Worker helper with Zod validation and Cloudflare Workers utilities (cf-typegen)",
 	"main": "./src/index.ts",
 	"module": "./src/index.ts",
@@ -61,10 +61,10 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"zod": "^4.3.5"
+		"zod": "^4.3.6"
 	},
 	"devDependencies": {
-		"@types/node": "^25.0.9",
+		"@types/node": "^25.0.10",
 		"@firtoz/maybe-error": "^1.5.2",
 		"bun-types": "^1.3.6"
 	}

package/src/cf-typegen.ts

@@ -2,6 +2,7 @@ import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
+import { prepareEnvFiles } from "./utils/prepare-env";
 
 // Use the current working directory
 const cwd = process.argv[2];
@@ -15,112 +16,100 @@ if (!cwd || !fs.existsSync(cwd)) {
 console.log(`Running CF typegen for: ${cwd}`);
 
 /**
- * Extracts required env vars from .env.local.example
+ * Find the git root directory using git command
  */
-function getRequiredEnvVars(examplePath: string): string[] {
+function findGitRoot(startPath: string): string | null {
 	try {
-		if (!fs.existsSync(examplePath)) {
-			return [];
-		}
-
-		const content = fs.readFileSync(examplePath, "utf8");
-		const vars: string[] = [];
-
-		// Parse .env format: VAR_NAME=value
-		for (const line of content.split("\n")) {
-			const trimmed = line.trim();
-			// Skip comments and empty lines
-			if (!trimmed || trimmed.startsWith("#")) continue;
+		const output = execSync("git rev-parse --show-toplevel", {
+			cwd: startPath,
+			encoding: "utf8",
+		});
+		return output.trim();
+	} catch {
+		return null;
+	}
+}
 
-			const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=/);
-			if (match) {
-				vars.push(match[1]);
-			}
-		}
+/**
+ * Find all wrangler config files using git ls-files
+ * This is more efficient and respects .gitignore
+ */
+function findAllWranglerConfigs(gitRoot: string): string[] {
+	try {
+		// Use git ls-files to find all tracked wrangler configs
+		const output = execSync('git ls-files "**/wrangler.json*"', {
+			cwd: gitRoot,
+			encoding: "utf8",
+		});
 
-		return vars;
+		return output
+			.trim()
+			.split("\n")
+			.filter((line) => line.length > 0)
+			.map((relativePath) => path.join(gitRoot, relativePath));
 	} catch (err) {
-		console.warn(`Failed to read ${examplePath}:`, err);
+		console.warn("⚠ Failed to run git ls-files:", err);
 		return [];
 	}
 }
 
-/**
- * Ensures .env.local exists with required env vars from .env.local.example
- */
-function prepareEnvLocal(): { created: boolean; added: string[] } {
-	const envPath = path.join(cwd, ".env.local");
-	const examplePath = path.join(cwd, ".env.local.example");
+function runWranglerTypes() {
+	const envFiles = prepareEnvFiles(cwd);
 
-	if (!fs.existsSync(examplePath)) {
-		console.log("No .env.local.example found, skipping env preparation");
-		return { created: false, added: [] };
-	}
+	console.log("Running wrangler types...");
 
-	const requiredVars = getRequiredEnvVars(examplePath);
-	if (requiredVars.length === 0) {
-		console.log("No vars found in .env.local.example");
-		return { created: false, added: [] };
+	// Find git root to discover all wrangler configs
+	const gitRoot = findGitRoot(cwd);
+	if (!gitRoot) {
+		console.warn(
+			"⚠ Could not find git root, skipping workspace config discovery",
+		);
+		console.log("  Generating types for current directory only");
 	}
 
-	let content = "";
-	let created = false;
-	const added: string[] = [];
+	// Find all wrangler configs in the workspace
+	const allConfigs = gitRoot ? findAllWranglerConfigs(gitRoot) : [];
 
-	if (fs.existsSync(envPath)) {
-		content = fs.readFileSync(envPath, "utf8");
-	} else {
-		created = true;
+	if (allConfigs.length > 0) {
+		console.log(`  Found ${allConfigs.length} wrangler config(s) in workspace`);
 	}
 
-	// Check which vars are missing
-	for (const varName of requiredVars) {
-		const regex = new RegExp(`^${varName}=`, "m");
-		if (!regex.test(content)) {
-			if (content && !content.endsWith("\n")) {
-				content += "\n";
-			}
-			content += `${varName}=\n`;
-			added.push(varName);
+	// Build the command with multiple -c flags
+	// The first config should be the current directory's wrangler.jsonc
+	const configFlags = ["-c wrangler.jsonc"];
+
+	// Add other configs (relative to cwd for better readability)
+	const currentWranglerJsonc = path.join(cwd, "wrangler.jsonc");
+	const currentWranglerJson = path.join(cwd, "wrangler.json");
+
+	for (const configPath of allConfigs) {
+		const resolvedPath = path.resolve(configPath);
+		// Skip if it's the current directory's config
+		if (
+			resolvedPath === currentWranglerJsonc ||
+			resolvedPath === currentWranglerJson
+		) {
+			continue;
 		}
+		// Make path relative to cwd
+		const relativePath = path.relative(cwd, configPath);
+		configFlags.push(`-c ${relativePath}`);
 	}
 
-	// Write if there were any changes
-	if (created || added.length > 0) {
-		fs.writeFileSync(envPath, content);
+	for (const envFile of envFiles) {
+		configFlags.push(`--env-file ${envFile}`);
 	}
 
-	return { created, added };
-}
+	const command = `wrangler types ${configFlags.join(" ")}`;
 
-// Step 1: Prepare .env.local with required vars from wrangler.jsonc
-function prepareEnv() {
-	try {
-		const updates = prepareEnvLocal();
-		if (updates.created) {
-			console.log("✓ Created .env.local");
-		}
-		if (updates.added.length > 0) {
-			console.log(`✓ Added missing env vars: ${updates.added.join(", ")}`);
-		}
-		if (!updates.created && updates.added.length === 0) {
-			console.log("✓ .env.local file already has all required vars");
-		}
-	} catch (error) {
-		console.error(String(error));
-		process.exit(1);
-	}
-}
+	console.log(`  Command: ${command}`);
 
-// Step 2: Run wrangler types
-function runWranglerTypes() {
-	console.log("Running wrangler types...");
 	try {
-		execSync("wrangler types -c wrangler.jsonc --env-file .env.local", {
+		execSync(command, {
 			cwd,
 			stdio: "inherit",
 		});
-		console.log("✓ Wrangler types generated");
+		console.log("✓ Wrangler types generated with all workspace bindings");
 	} catch {
 		console.error("Failed to run wrangler types");
 		process.exit(1);
@@ -129,7 +118,6 @@ function runWranglerTypes() {
 
 // Run all steps
 try {
-	prepareEnv();
 	runWranglerTypes();
 	console.log("\n✓ CF typegen completed successfully");
 } catch (error: unknown) {

package/src/utils/prepare-env.ts

@@ -0,0 +1,58 @@
+import * as fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Ensures a .env and .env.local file exists in the target directory.
+ * If it doesn't exist, copies from .env.example and .env.local.example.
+ *
+ * @param targetDir - The directory where the .env and .env.local files should exist
+ * @returns An array of the files that were created or already existed
+ */
+export function prepareEnvFiles(targetDir: string): string[] {
+	const exampleEnvPath = path.join(targetDir, ".env.example");
+	const exampleEnvLocalPath = path.join(targetDir, ".env.local.example");
+
+	const exampleEnvExists = fs.existsSync(exampleEnvPath);
+	const exampleLocalEnvExists = fs.existsSync(exampleEnvLocalPath);
+
+	const envPath = path.join(targetDir, ".env");
+	const envLocalPath = path.join(targetDir, ".env.local");
+
+	let envExists = fs.existsSync(envPath);
+	let envLocalExists = fs.existsSync(envLocalPath);
+
+	if (exampleEnvExists) {
+		if (!envExists) {
+			fs.cpSync(exampleEnvPath, envPath);
+
+			console.log("✓ Created .env from .env.example");
+			envExists = true;
+		}
+	}
+
+	if (exampleLocalEnvExists) {
+		if (!envLocalExists) {
+			fs.cpSync(exampleEnvLocalPath, envLocalPath);
+
+			console.log("✓ Created .env.local from .env.local.example");
+			envLocalExists = true;
+		}
+	}
+
+	const result: string[] = [];
+	// The order matters, because latter files' values will override former files' values
+	if (exampleEnvExists) {
+		result.push(".env.example");
+	}
+	if (exampleLocalEnvExists) {
+		result.push(".env.local.example");
+	}
+	if (envExists) {
+		result.push(".env");
+	}
+	if (envLocalExists) {
+		result.push(".env.local");
+	}
+
+	return result;
+}