@forinda/kickjs-cli 5.0.2 → 5.2.0

package/dist/{typegen-D8MJ2hPX.mjs → typegen-DugZmi-0.mjs}

@@ -1,5 +1,5 @@
 /**
- * @forinda/kickjs-cli v5.0.2
+ * @forinda/kickjs-cli v5.2.0
  *
  * Copyright (c) Felix Orinda
  *
@@ -8,10 +8,12 @@
  *
  * @license MIT
  */
-import { dirname, extname, join, relative, resolve, sep } from "node:path";
-import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { t as __exportAll } from "./rolldown-runtime-CYBbkZNy.mjs";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { statSync } from "node:fs";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { globSync } from "glob";
+import { groupAssetKeys } from "@forinda/kickjs";
 //#region src/typegen/scanner.ts
 /** Decorators that mark a class as DI-managed */
 const DECORATOR_NAMES = [
@@ -729,12 +731,12 @@ function discoverAssets(assetMap, cwd) {
 			posix: true
 		});
 		matches.sort();
-		for (const rel of matches) {
-			const key = stripExt(rel);
-			const logical = `${namespace}/${key}`;
+		const { pairs } = groupAssetKeys(namespace, matches, { strategy: entry.keys ?? "auto" });
+		for (const { key: logical } of pairs) {
+			const subKey = logical.slice(namespace.length + 1);
 			seen.set(logical, {
 				namespace,
-				key
+				key: subKey
 			});
 		}
 	}
@@ -798,7 +800,7 @@ export {}
 }
 const LEAF = Symbol("asset-leaf");
 function renderTree(node, indent) {
-	const keys = Object.keys(node).sort();
+	const keys = Object.keys(node).toSorted();
 	const lines = [];
 	for (const key of keys) {
 		const child = node[key];
@@ -822,10 +824,6 @@ function isDir(path) {
 		return false;
 	}
 }
-function stripExt(path) {
-	const ext = extname(path);
-	return ext ? path.slice(0, -ext.length) : path;
-}
 //#endregion
 //#region src/typegen/generator.ts
 /**
@@ -953,7 +951,7 @@ export type ${typeName} = never
 `;
 	return `${HEADER}
 export type ${typeName} =
-${[...new Set(names)].sort().map((n) => `  | '${n}'`).join("\n")}
+${[...new Set(names)].toSorted().map((n) => `  | '${n}'`).join("\n")}
 `;
 }
 /** Render the barrel index that re-exports the union types */
@@ -969,203 +967,11 @@ export type { ModuleToken } from './modules'
 // \`dependsOn: ['TenantAdapter']\`, \`assets.mails.welcome()\`, and
 // \`@Value('PORT')\` to resolve.
 import './registry'
-import './routes'
+import './kick__routes'
 import './plugins'
 import './augmentations'
 import './assets'
-${includeEnv ? "import './env'\n" : ""}`;
-}
-/**
-* Render the `query` field's TypeScript type for a single route.
-*
-* - When `@ApiQueryParams` is absent (`queryFilterable === null`), emits
-*   `unknown` so the user gets nothing extra.
-* - When the decorator is present, emits an object literal whose keys
-*   are the standard query string keys (`filter`, `sort`, `q`, `page`,
-*   `limit`). `sort` is narrowed to a string-literal union of allowed
-*   field names with optional `-` direction prefix.
-*/
-function renderQueryShape(m) {
-	if (m.queryFilterable === null) return "unknown";
-	const sortable = m.querySortable ?? [];
-	return `{ filter?: string | string[]; sort?: ${sortable.length > 0 ? sortable.flatMap((f) => [`'${f}'`, `'-${f}'`]).join(" | ") : "string"}; q?: string; page?: string; limit?: string }`;
-}
-/** Render JSDoc lines summarising the @ApiQueryParams whitelist */
-function renderQueryDocLines(m) {
-	const lines = [];
-	if (m.queryFilterable && m.queryFilterable.length > 0) lines.push(`Filterable: ${m.queryFilterable.join(", ")}`);
-	if (m.querySortable && m.querySortable.length > 0) lines.push(`Sortable: ${m.querySortable.join(", ")}`);
-	if (m.querySearchable && m.querySearchable.length > 0) lines.push(`Searchable: ${m.querySearchable.join(", ")}`);
-	return lines;
-}
-/**
-* Plan a schema import for hoisting at the top of `routes.ts`. Returns
-* the alias the in-namespace code should use, or `null` if the schema
-* cannot be referenced (no validator configured, or source unresolvable).
-*
-* Aliases are unique per (alias-counter) so two schemas named
-* `createTaskSchema` from different modules don't collide.
-*/
-function planSchemaImport(schema, routeFilePath, routesOutFile, schemaValidator, imports) {
-	if (!schema || schemaValidator !== "zod") return null;
-	if (schema.source === null) return null;
-	const specifier = resolveSchemaImportSpecifier(schema.source, routeFilePath, routesOutFile);
-	if (specifier === "unknown") return null;
-	const key = `${specifier}::${schema.identifier}`;
-	let alias = imports.get(key)?.specifier;
-	if (!alias) {
-		alias = `_S${imports.size}`;
-		imports.set(key, {
-			identifier: schema.identifier,
-			specifier: alias
-		});
-	} else alias = imports.get(key).specifier;
-	return alias;
-}
-/** Build the `import type { ... } from '...'` lines for hoisted schema imports */
-function renderSchemaImports(imports) {
-	if (imports.size === 0) return "";
-	const lines = [];
-	for (const [key, value] of imports) {
-		const [path] = key.split("::");
-		lines.push(`import type { ${value.identifier} as ${value.specifier} } from '${path}'`);
-	}
-	return lines.join("\n") + "\n";
-}
-/**
-* Compute the import specifier the generated `routes.d.ts` should use to
-* reach a schema declared either in the controller file (empty string)
-* or imported from elsewhere (relative path or bare module name).
-*
-* - Bare module names (`zod`, `@scope/pkg`) are returned as-is.
-* - Relative paths (`./users.dto`, `../shared/schema`) are resolved
-*   against the controller's file path, then re-relativised against the
-*   directory containing `routes.d.ts`.
-* - Empty string (same-file schema) becomes a relative path from the
-*   `routes.d.ts` directory back to the controller file.
-*/
-function resolveSchemaImportSpecifier(source, routeFilePath, routesOutFile) {
-	if (source === null) return "unknown";
-	const routesDir = dirname(routesOutFile);
-	if (source === "") {
-		let rel = relative(routesDir, routeFilePath).split(sep).join("/");
-		rel = rel.replace(/\.(ts|tsx|mts|cts)$/i, "");
-		if (!rel.startsWith(".")) rel = "./" + rel;
-		return rel;
-	}
-	if (!source.startsWith(".") && !source.startsWith("/")) return source;
-	let rel = relative(routesDir, resolve(dirname(routeFilePath), source)).split(sep).join("/");
-	rel = rel.replace(/\.(ts|tsx|mts|cts)$/i, "");
-	if (!rel.startsWith(".")) rel = "./" + rel;
-	return rel;
-}
-/**
-* Render the `KickEnv` + `NodeJS.ProcessEnv` augmentation file from a
-* detected env schema. Mirrors the routes.ts pattern: emits as a `.ts`
-* file (not `.d.ts`) so the top-level `import type schema from '...'`
-* actually resolves under `moduleResolution: 'bundler'`.
-*
-* Returns `null` when no env file was discovered, so the caller can
-* skip writing the file altogether (rather than emitting an empty
-* augmentation that would shadow `KickEnv` to a useless `{}`).
-*/
-function renderEnv(env, envOutFile) {
-	if (!env) return null;
-	let rel = relative(dirname(envOutFile), env.filePath).split(sep).join("/");
-	rel = rel.replace(/\.(ts|tsx|mts|cts)$/i, "");
-	if (!rel.startsWith(".")) rel = "./" + rel;
-	return `${HEADER}
-// Importing the schema as a type lets us infer its shape without
-// pulling in any runtime code. \`Awaited<>\` strips an accidental
-// Promise wrap on dynamic-imported defaults.
-import type _envSchema from '${rel}'
-
-// Local type alias — interfaces can only \`extend\` an identifier,
-// not an inline import expression, so we resolve the schema's
-// inferred shape into a named type first.
-type _KickEnvShape = import('zod').infer<typeof _envSchema>
-
-declare global {
-  /**
-   * Typed environment registry. Augmented from \`${env.relativePath}\`
-   * so \`@Value('PORT')\`, \`Env<'PORT'>\`, and \`process.env.PORT\` are
-   * all type-safe and autocomplete.
-   */
-  interface KickEnv extends _KickEnvShape {}
-
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace NodeJS {
-    /**
-     * Narrow \`process.env\` so known keys exist as \`string\` (the raw
-     * pre-Zod-coercion form). \`@Value\` and the \`ConfigService\` apply
-     * the schema's transforms internally; access \`process.env\` directly
-     * only when you need the raw string. Unknown keys still resolve to
-     * \`string | undefined\` via the base @types/node declaration.
-     */
-    interface ProcessEnv extends Record<keyof KickEnv, string> {}
-  }
-}
-
-export {}
-`;
-}
-/**
-* Render the `KickRoutes` global namespace augmentation. Each interface
-* inside corresponds to a controller class; each property is a single
-* route method on that controller, conforming to `RouteShape`.
-*
-* Fills `params` from URL patterns, `query` from `@ApiQueryParams`, and
-* `body`/`query`/`params` (when schema-validated) from the configured
-* schema validator. `response` is emitted as `unknown`.
-*/
-function renderRoutes(routes, routesOutFile, schemaValidator) {
-	if (routes.length === 0) return `${HEADER}
-// (no routes discovered yet — annotate a controller method with
-//  @Get/@Post/@Put/@Delete/@Patch and re-run \`kick typegen\`)
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace KickRoutes {}
-}
-
-export {}
-`;
-	const byController = /* @__PURE__ */ new Map();
-	for (const r of routes) {
-		const arr = byController.get(r.controller) ?? [];
-		arr.push(r);
-		byController.set(r.controller, arr);
-	}
-	const schemaImports = /* @__PURE__ */ new Map();
-	const renderField = (schema, routeFilePath) => {
-		const alias = planSchemaImport(schema, routeFilePath, routesOutFile, schemaValidator, schemaImports);
-		return alias ? `import('zod').infer<typeof ${alias}>` : null;
-	};
-	const interfaces = [];
-	for (const [controller, methods] of byController) {
-		const lines = [`    interface ${controller} {`];
-		for (const m of methods) {
-			const urlParamsType = m.pathParams.length > 0 ? `{ ${m.pathParams.map((p) => `${p}: string`).join("; ")} }` : "{}";
-			const bodySchemaType = renderField(m.bodySchema, m.filePath);
-			const querySchemaType = renderField(m.querySchema, m.filePath);
-			const paramsType = renderField(m.paramsSchema, m.filePath) ?? urlParamsType;
-			const bodyType = bodySchemaType ?? "unknown";
-			const queryType = querySchemaType ?? renderQueryShape(m);
-			const docLines = renderQueryDocLines(m);
-			lines.push(`      /**`, `       * ${m.httpMethod} ${m.path}`, ...docLines.map((d) => `       * ${d}`), `       */`, `      ${m.method}: {`, `        params: ${paramsType}`, `        body: ${bodyType}`, `        query: ${queryType}`, `        response: unknown`, `      }`);
-		}
-		lines.push("    }");
-		interfaces.push(lines.join("\n"));
-	}
-	return `${HEADER}${renderSchemaImports(schemaImports)}
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace KickRoutes {
-${interfaces.join("\n")}
-  }
-}
-
-export {}
-`;
+${includeEnv ? "import './kick__env'\n" : ""}`;
 }
 /**
 * Render the `KickJsPluginRegistry` augmentation. Each entry maps the
@@ -1182,7 +988,7 @@ export {}
 function renderPlugins(items) {
 	const byName = /* @__PURE__ */ new Map();
 	for (const item of items) if (!byName.has(item.name)) byName.set(item.name, item);
-	const entries = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name)).map((item) => `    '${item.name}': '${item.kind}'`).join("\n");
+	const entries = [...byName.values()].toSorted((a, b) => a.name.localeCompare(b.name)).map((item) => `    '${item.name}': '${item.kind}'`).join("\n");
 	return `${HEADER}
 declare module '@forinda/kickjs' {
   /**
@@ -1225,7 +1031,7 @@ export {}
 	const byName = /* @__PURE__ */ new Map();
 	for (const item of items) if (!byName.has(item.name)) byName.set(item.name, item);
 	const blocks = [];
-	for (const item of [...byName.values()].sort((a, b) => a.name.localeCompare(b.name))) {
+	for (const item of [...byName.values()].toSorted((a, b) => a.name.localeCompare(b.name))) {
 		const docLines = [];
 		if (item.description) for (const line of item.description.split("\n")) docLines.push(` * ${line}`);
 		if (item.example) {
@@ -1254,14 +1060,12 @@ async function generateTypes(opts) {
 	const { classes, routes = [], tokens = [], injects = [], collisions = [], env = null, pluginsAndAdapters = [], augmentations = [], assets = {
 		entries: [],
 		count: 0
-	}, outDir, allowDuplicates = false, schemaValidator = false } = opts;
+	}, outDir, allowDuplicates = false, schemaValidator: _schemaValidator = false } = opts;
 	if (collisions.length > 0 && !allowDuplicates) throw new TokenCollisionError(collisions);
 	await mkdir(outDir, { recursive: true });
 	const registryFile = join(outDir, "registry.d.ts");
 	const servicesFile = join(outDir, "services.d.ts");
 	const modulesFile = join(outDir, "modules.d.ts");
-	const routesFile = join(outDir, "routes.ts");
-	const envFile = join(outDir, "env.ts");
 	const pluginsFile = join(outDir, "plugins.d.ts");
 	const augmentationsFile = join(outDir, "augmentations.d.ts");
 	const assetsFile = join(outDir, "assets.d.ts");
@@ -1279,16 +1083,13 @@ async function generateTypes(opts) {
 	const modules = classes.filter((c) => c.decorator === "Module").map((c) => c.className);
 	const servicesContent = renderUnion("ServiceToken", allServices, "(no tokens discovered — declare with createToken<T>() or `kick g service <name>`)");
 	const modulesContent = renderUnion("ModuleToken", modules, "(no @Module classes discovered — `kick g module <name>` to add one)");
-	const routesContent = renderRoutes(routes, routesFile, schemaValidator);
-	const envContent = renderEnv(env, envFile);
 	const pluginsContent = renderPlugins(pluginsAndAdapters);
 	const augmentationsContent = renderAugmentations(augmentations);
 	const assetsContent = renderAssetTypes(assets);
-	const indexContent = renderIndex(envContent !== null);
+	const indexContent = renderIndex(env !== null);
 	await writeFile(registryFile, registryContent, "utf-8");
 	await writeFile(servicesFile, servicesContent, "utf-8");
 	await writeFile(modulesFile, modulesContent, "utf-8");
-	await writeFile(routesFile, routesContent, "utf-8");
 	await writeFile(pluginsFile, pluginsContent, "utf-8");
 	await writeFile(augmentationsFile, augmentationsContent, "utf-8");
 	await writeFile(assetsFile, assetsContent, "utf-8");
@@ -1297,16 +1098,11 @@ async function generateTypes(opts) {
 		registryFile,
 		servicesFile,
 		modulesFile,
-		routesFile,
 		pluginsFile,
 		augmentationsFile,
 		assetsFile,
 		indexFile
 	];
-	if (envContent) {
-		await writeFile(envFile, envContent, "utf-8");
-		written.push(envFile);
-	}
 	await writeFile(join(dirname(outDir), ".gitignore"), "# Auto-generated by kick typegen\n*\n", "utf-8");
 	const uniquePluginNames = new Set(pluginsAndAdapters.map((p) => p.name)).size;
 	const uniqueAugmentations = new Set(augmentations.map((a) => a.name)).size;
@@ -1318,7 +1114,7 @@ async function generateTypes(opts) {
 		pluginEntries: uniquePluginNames,
 		augmentationEntries: uniqueAugmentations,
 		assetEntries: assets.count,
-		envWritten: envContent !== null,
+		envWritten: env !== null,
 		written,
 		resolvedCollisions: collisions.length
 	};
@@ -1374,6 +1170,10 @@ function suggestRename(name) {
 *
 * @module @forinda/kickjs-cli/typegen
 */
+var typegen_exports = /* @__PURE__ */ __exportAll({
+	runTypegen: () => runTypegen,
+	watchTypegen: () => watchTypegen
+});
 /** Resolve options to absolute paths */
 function resolveOptions(opts) {
 	const cwd = opts.cwd ?? process.cwd();
@@ -1419,6 +1219,20 @@ async function runTypegen(opts = {}) {
 		allowDuplicates,
 		schemaValidator
 	});
+	if (opts.runPlugins !== false) try {
+		const { runAllPluginTypegens } = await import("./run-plugins-B1R0HG0g.mjs");
+		const { loadKickConfig } = await import("./config-DDrgs-I3.mjs").then((n) => n.n);
+		await runAllPluginTypegens({
+			cwd,
+			config: await loadKickConfig(cwd),
+			silent: true
+		});
+	} catch (err) {
+		if (!silent) {
+			const msg = err instanceof Error ? err.message : String(err);
+			console.warn(`  kick typegen: plugin pipeline failed (${msg}) — continuing`);
+		}
+	}
 	const tokenWarnings = validateTokenConventions(scan.tokens);
 	const elapsed = Date.now() - start;
 	if (!silent) {
@@ -1444,7 +1258,96 @@ async function runTypegen(opts = {}) {
 		tokenWarnings
 	};
 }
+/**
+* Watch mode for `kick typegen --watch`.
+*
+* Uses Node's built-in `fs.watch` (recursive, available on Linux 22+ and
+* macOS 19+). Falls back gracefully if recursive watch is not supported.
+*
+* Debounces re-runs by 100ms so a bulk file change (e.g. `kick g module`
+* creating 5 files at once) emits one regen, not five.
+*
+* In watch mode collisions are reported but never thrown — the watcher
+* keeps running so the user can fix the rename and the next scan
+* recovers automatically.
+*
+* Returns a `stop()` function that closes the watcher.
+*/
+async function watchTypegen(opts = {}) {
+	const resolved = resolveOptions(opts);
+	const { srcDir, silent, cwd } = resolved;
+	const runOpts = {
+		...resolved,
+		allowDuplicates: true,
+		runPlugins: false
+	};
+	const forcePolling = process.env.KICKJS_WATCH_POLLING === "1" || process.env.KICKJS_WATCH_POLLING === "true";
+	const [{ runAllPluginTypegens }, { loadKickConfig }] = await Promise.all([import("./run-plugins-B1R0HG0g.mjs"), import("./config-DDrgs-I3.mjs").then((n) => n.n)]);
+	const pluginConfig = await loadKickConfig(cwd);
+	const runPlugins = () => runAllPluginTypegens({
+		cwd,
+		config: pluginConfig,
+		silent: true
+	}).catch(() => {});
+	await safeRun(runOpts, silent);
+	await runPlugins();
+	const { watch } = await import("node:fs");
+	let timer = null;
+	const trigger = (filename) => {
+		if (!filename) return;
+		if (!/\.(ts|tsx|mts|cts)$/.test(filename)) return;
+		if (filename.includes(".kickjs")) return;
+		if (filename.endsWith(".d.ts")) return;
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			safeRun(runOpts, silent);
+			runPlugins();
+		}, 100);
+	};
+	if (forcePolling) {
+		if (!silent) console.log("  kick typegen: polling mode (KICKJS_WATCH_POLLING)");
+		const interval = setInterval(() => {
+			safeRun({
+				...runOpts,
+				silent: true
+			}, true);
+		}, 2e3);
+		return () => clearInterval(interval);
+	}
+	let watcher;
+	try {
+		watcher = watch(srcDir, { recursive: true }, (_event, filename) => {
+			trigger(filename);
+		});
+	} catch (err) {
+		if (!silent) console.warn(`  kick typegen: watch mode unavailable (${err?.message ?? err}). Falling back to polling.`);
+		const interval = setInterval(() => {
+			safeRun({
+				...runOpts,
+				silent: true
+			}, true);
+		}, 2e3);
+		return () => clearInterval(interval);
+	}
+	return () => {
+		if (timer) clearTimeout(timer);
+		watcher.close();
+	};
+}
+/** Run typegen swallowing errors so the watcher loop never dies */
+async function safeRun(opts, silent) {
+	try {
+		await runTypegen(opts);
+	} catch (err) {
+		if (silent) return;
+		if (err instanceof TokenCollisionError) console.error("\n" + err.message + "\n");
+		else {
+			const msg = err instanceof Error ? err.message : String(err);
+			console.error(`  kick typegen failed: ${msg}`);
+		}
+	}
+}
 //#endregion
-export { runTypegen };
+export { discoverAssets as a, TokenCollisionError as i, typegen_exports as n, renderAssetTypes as o, watchTypegen as r, scanProject as s, runTypegen as t };
 
-//# sourceMappingURL=typegen-D8MJ2hPX.mjs.map
+//# sourceMappingURL=typegen-DugZmi-0.mjs.map