@firtoz/worker-helper 1.3.4 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @firtoz/worker-helper
 
+## 1.5.0
+
+### Minor Changes
+
+- [`894ee47`](https://github.com/firtoz/fullstack-toolkit/commit/894ee4775393f4c536397e7db869ccfb31d3f045) Thanks [@firtoz](https://github.com/firtoz)! - Allow passing extra arguments to `wrangler types` via cf-typegen. Any arguments after the directory are forwarded to the wrangler command (e.g. `--env-interface WebAppEnv`, `-c wrangler.jsonc`).
+
+## 1.4.0
+
+### Minor Changes
+
+- [`6e96ebb`](https://github.com/firtoz/fullstack-toolkit/commit/6e96ebb05a992cc33ea339e5466b608774be62c3) Thanks [@firtoz](https://github.com/firtoz)! - cf-typegen now discovers wrangler configs from the npm/bun workspace definition (root package.json `workspaces` field) instead of using `git ls-files`. Untracked workspace packages (e.g. new durable objects like fal-user-do) are included in type generation without needing to be committed first.
+
 ## 1.3.4
 
 ### Patch Changes

package/README.md

@@ -54,6 +54,20 @@ cd your-worker-package
 bun run cf-typegen
 ```
 
+Any arguments after the directory are passed through to `wrangler types`. For example, to use a custom env interface or config:
+
+```bash
+bun run cf-typegen -- --env-interface WebAppEnv
+# or with a custom config path
+bun run cf-typegen -- -c wrangler.jsonc --env-interface WebAppEnv
+```
+
+When invoking the script directly, pass the directory first, then extra args:
+
+```bash
+bun --cwd ../../packages/worker-helper cf-typegen $(pwd) --env-interface WebAppEnv
+```
+
 **Output:**
 ```
 Running CF typegen for: /path/to/your-worker

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@firtoz/worker-helper",
-	"version": "1.3.4",
+	"version": "1.5.0",
 	"description": "Type-safe Web Worker helper with Zod validation and Cloudflare Workers utilities (cf-typegen)",
 	"main": "./src/index.ts",
 	"module": "./src/index.ts",
@@ -67,8 +67,8 @@
 		"zod": "^4.3.6"
 	},
 	"devDependencies": {
-		"@types/node": "^25.2.1",
+		"@types/node": "^25.2.3",
 		"@firtoz/maybe-error": "^1.5.2",
-		"bun-types": "^1.3.8"
+		"bun-types": "^1.3.9"
 	}
 }

package/src/cf-typegen-discovery.ts

@@ -0,0 +1,110 @@
+import * as fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Find workspace root by walking up from startPath until we find a package.json
+ * with a "workspaces" field (npm/bun convention).
+ */
+export function findWorkspaceRoot(startPath: string): string | null {
+	let dir = path.resolve(startPath);
+	for (;;) {
+		const pkgPath = path.join(dir, "package.json");
+		if (fs.existsSync(pkgPath)) {
+			try {
+				const content = fs.readFileSync(pkgPath, "utf8");
+				const pkg = JSON.parse(content) as { workspaces?: unknown };
+				if (
+					pkg.workspaces != null &&
+					(Array.isArray(pkg.workspaces) ||
+						(typeof pkg.workspaces === "object" &&
+							"packages" in pkg.workspaces))
+				) {
+					return dir;
+				}
+			} catch {
+				// ignore parse errors
+			}
+		}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+
+/**
+ * Expand workspace glob patterns (e.g. "packages/*", "tests/*") to absolute paths.
+ * Only supports single-level globs; each pattern must be exactly "dirname/*".
+ */
+export function expandWorkspacePatterns(
+	root: string,
+	patterns: string[],
+): string[] {
+	const dirs: string[] = [];
+	for (const pattern of patterns) {
+		if (!pattern.endsWith("/*")) continue;
+		const base = pattern.slice(0, -2);
+		const basePath = path.join(root, base);
+		try {
+			const entries = fs.readdirSync(basePath, { withFileTypes: true });
+			for (const e of entries) {
+				if (e.isDirectory()) {
+					dirs.push(path.join(basePath, e.name));
+				}
+			}
+		} catch {
+			// base path may not exist
+		}
+	}
+	return dirs;
+}
+
+/**
+ * Get workspace package paths from root package.json (workspaces field).
+ * Returns absolute paths to each workspace member directory.
+ */
+export function getWorkspacePaths(root: string): string[] {
+	const pkgPath = path.join(root, "package.json");
+	try {
+		const content = fs.readFileSync(pkgPath, "utf8");
+		const pkg = JSON.parse(content) as {
+			workspaces?: string[] | { packages?: string[] };
+		};
+		const raw = Array.isArray(pkg.workspaces)
+			? pkg.workspaces
+			: pkg.workspaces?.packages;
+		if (!Array.isArray(raw)) return [];
+		return expandWorkspacePatterns(root, raw);
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Find all wrangler config files under the given workspace member paths.
+ * Does not rely on git; includes untracked configs (e.g. new durable objects).
+ */
+export function findWranglerConfigsInPaths(workspacePaths: string[]): string[] {
+	const results: string[] = [];
+	for (const dir of workspacePaths) {
+		for (const name of ["wrangler.json", "wrangler.jsonc"]) {
+			const fullPath = path.join(dir, name);
+			if (fs.existsSync(fullPath)) {
+				results.push(fullPath);
+				break; // at most one per dir
+			}
+		}
+	}
+	return results.sort((a, b) => (a < b ? -1 : 1));
+}
+
+/**
+ * Discover all wrangler config paths for the workspace containing cwd.
+ * Returns empty array if not in a workspace or if root has no workspaces field.
+ */
+export function discoverWranglerConfigs(cwd: string): string[] {
+	const workspaceRoot = findWorkspaceRoot(cwd);
+	if (!workspaceRoot) return [];
+	const workspacePaths = getWorkspacePaths(workspaceRoot);
+	return findWranglerConfigsInPaths(workspacePaths);
+}

package/src/cf-typegen.ts

@@ -1,12 +1,18 @@
 #!/usr/bin/env bun
-import { execSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
+import {
+	discoverWranglerConfigs,
+	findWorkspaceRoot,
+} from "./cf-typegen-discovery";
 import { prepareEnvFiles } from "./utils/prepare-env";
 
-// Use the current working directory
+// First arg: directory (cwd). Remaining args: passed through to `wrangler types`.
 const cwd = process.argv[2];
+const extraWranglerArgs = process.argv.slice(3);
+
 if (!cwd || !fs.existsSync(cwd)) {
 	console.error(
 		"Please specify a directory as the first parameter. Usually $(pwd).",
@@ -16,72 +22,28 @@ if (!cwd || !fs.existsSync(cwd)) {
 
 console.log(`Running CF typegen for: ${cwd}`);
 
-/**
- * Find the git root directory using git command
- */
-function findGitRoot(startPath: string): string | null {
-	try {
-		const output = execSync("git rev-parse --show-toplevel", {
-			cwd: startPath,
-			encoding: "utf8",
-		});
-		return output.trim();
-	} catch {
-		return null;
-	}
-}
-
-/**
- * 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" "**/wrangler.jsonc"',
-			{
-				cwd: gitRoot,
-				encoding: "utf8",
-			},
-		);
-
-		return output
-			.trim()
-			.split("\n")
-			.filter((line) => line.length > 0)
-			.map((relativePath) => path.join(gitRoot, relativePath))
-			.sort((a, b) => (a < b ? -1 : 1));
-	} catch (err) {
-		console.warn("⚠ Failed to run git ls-files:", err);
-		return [];
-	}
-}
-
 function runWranglerTypes() {
 	const envFiles = prepareEnvFiles(cwd);
 
 	console.log("Running wrangler types...");
 
-	// 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");
+	// Discover wrangler configs from npm/bun workspace definition (includes untracked packages)
+	const workspaceRoot = findWorkspaceRoot(cwd);
+	let allConfigs: string[];
+	if (workspaceRoot) {
+		allConfigs = discoverWranglerConfigs(cwd);
+	} else {
+		console.warn("⚠ No workspace root found, using current directory only");
+		allConfigs = [];
 	}
 
-	// Find all wrangler configs in the workspace
-	const allConfigs = gitRoot ? findAllWranglerConfigs(gitRoot) : [];
-
 	if (allConfigs.length > 0) {
 		console.log(`  Found ${allConfigs.length} wrangler config(s) in workspace`);
 	}
 
-	// Build the command with multiple -c flags
+	// Build args for wrangler types: multiple -c flags, --env-file, then any extra args
 	// The first config should be the current directory's wrangler.jsonc
-	const configFlags = ["-c wrangler.jsonc"];
+	const args: string[] = ["types", "-c", "wrangler.jsonc"];
 
 	// Add other configs (relative to cwd for better readability)
 	const currentWranglerJsonc = path.join(cwd, "wrangler.jsonc");
@@ -98,27 +60,27 @@ function runWranglerTypes() {
 		}
 		// Make path relative to cwd
 		const relativePath = path.relative(cwd, configPath);
-		configFlags.push(`-c ${relativePath}`);
+		args.push("-c", relativePath);
 	}
 
 	for (const envFile of envFiles) {
-		configFlags.push(`--env-file ${envFile}`);
+		args.push("--env-file", envFile);
 	}
 
-	const command = `wrangler types ${configFlags.join(" ")}`;
+	args.push(...extraWranglerArgs);
 
+	const command = `wrangler ${args.join(" ")}`;
 	console.log(`  Command: ${command}`);
 
-	try {
-		execSync(command, {
-			cwd,
-			stdio: "inherit",
-		});
-		console.log("✓ Wrangler types generated with all workspace bindings");
-	} catch {
+	const result = spawnSync("wrangler", args, {
+		cwd,
+		stdio: "inherit",
+	});
+	if (result.status !== 0) {
 		console.error("Failed to run wrangler types");
 		process.exit(1);
 	}
+	console.log("✓ Wrangler types generated with all workspace bindings");
 }
 
 // Run all steps