@dudousxd/nestjs-codegen 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @dudousxd/nestjs-codegen
 
+## 0.23.0
+
+### Minor Changes
+
+- 4b13eef: Classify through transparent type brands, so a MikroORM entity's columns stop coming back `unknown`.
+
+  `Opt<T>` is how MikroORM marks a column optional on insert, and it is how nearly every nullable column in a MikroORM entity is written. It is a compile-time marker with no runtime shape of its own — an `Opt<string>` column holds a string — but the classifier saw a type reference it did not recognise and answered `unknown`. On a real entity that meant 31 of 35 fields unclassified, including plain `Opt<string>` names; the four that worked were the two written as bare primitives and the two written `Date & Opt<Date>`, where the intersection happens to expose a type the classifier already knew.
+
+  That is not a cosmetic gap. `unknown` is indistinguishable from "the classifier could not tell", so every consumer that reads a kind — operator sets, a number/date gate, a UI picking a filter control from the column's type — has to fall back to permissive for an entity that had in fact declared its types perfectly well.
+
+  `Opt<T>` and `Hidden<T>` are now unwrapped to their argument, recursively, so `Opt<Hidden<number>>` is a number.
+
+  Deliberately a short allowlist rather than "unwrap any single-argument reference". `Ref<T>`, `Rel<T>`, `Collection<T>` and `IdentifiedReference<T>` are **not** transparent: their runtime value is a reference or a collection, not a `T`. Unwrapping those would classify a relation as whatever its target's shape happens to be — silently, and only visibly far downstream.
+
+## 0.22.1
+
+### Patch Changes
+
+- da8ec39: Order routes by file path, so an unchanged source tree always generates the same client
+
+  Route order decided the order of everything emitted from it — the groups in
+  `api.ts`, the entries in `routes.ts` — and it was whatever order discovery
+  happened to reach the files in. The cold path adds controllers in `fast-glob`'s
+  directory-walk order, which is I/O-completion order from a concurrent walk: it
+  holds while the FS cache is warm and can differ on a cold one, so regenerating
+  an untouched project could move a controller group to a different position. The
+  watcher appended each newly-created controller to the end of its set, so from
+  the moment a file was added its output no longer matched a cold run's, for the
+  rest of the session.
+
+  Both extraction entry points now sort their roots by path. `discoverPages` has
+  sorted its glob from the start, which is why only the controller-derived
+  artifacts ever moved.
+
+  Nothing about the generated client changes except the order of its blocks —
+  same routes, same types, same members. Consumers who commit their generated
+  directory should expect one reorder-only diff on the first run after upgrading.
+
 ## 0.22.0
 
 ### Minor Changes

package/dist/cli/main.cjs

@@ -1369,6 +1369,7 @@ function classifyTypeKeyword(raw) {
 function markNullable(r, nullable) {
   return nullable ? { ...r, nullable: true } : r;
 }
+var TRANSPARENT_TYPE_BRANDS = /* @__PURE__ */ new Set(["Opt", "Hidden"]);
 function classifyTypeNode(typeNode, sourceFile, project, opts) {
   if (import_ts_morph4.Node.isUnionTypeNode(typeNode)) {
     let nullable = false;
@@ -1427,6 +1428,11 @@ function classifyTypeNode(typeNode, sourceFile, project, opts) {
     const refName = typeNode.getTypeName().getText();
     if (refName === "Date") return { kind: "date" };
     if (refName === "Record" || refName === "Object") return { kind: "json" };
+    const unwrapped = TRANSPARENT_TYPE_BRANDS.has(refName) ? typeNode.getTypeArguments()[0] : void 0;
+    if (unwrapped) {
+      const inner = classifyTypeNode(unwrapped, sourceFile, project, opts);
+      return inner;
+    }
     const typeRef = opts?.resolveRef?.(refName) ?? null;
     const en = resolveEnumValues(refName, sourceFile, project);
     if (en) {
@@ -2754,7 +2760,7 @@ function bindDiscoveryContext(project, cwd, tsconfigPath, tsconfig = loadDiscove
 }
 function extractRoutesFrom(project, controllerPaths) {
   const routes = [];
-  for (const path of controllerPaths) {
+  for (const path of byPath([...controllerPaths])) {
     const sourceFile = project.getSourceFile(path);
     if (sourceFile) routes.push(...extractFromSourceFile(sourceFile, project));
   }
@@ -2762,11 +2768,17 @@ function extractRoutesFrom(project, controllerPaths) {
 }
 function extractAllRoutes(project) {
   const routes = [];
-  for (const sourceFile of project.getSourceFiles()) {
+  for (const sourceFile of byPath(project.getSourceFiles(), (f) => f.getFilePath())) {
     routes.push(...extractFromSourceFile(sourceFile, project));
   }
   return routes;
 }
+function byPath(items, path = String) {
+  return [...items].sort((a, b) => {
+    const [x, y] = [path(a), path(b)];
+    return x < y ? -1 : x > y ? 1 : 0;
+  });
+}
 var PersistentDiscovery = class _PersistentDiscovery {
   project;
   cwd;
@@ -5247,7 +5259,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.22.0";
+var VERSION = "0.23.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {