@dudousxd/nestjs-codegen 0.15.0 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,61 @@
 # @dudousxd/nestjs-codegen
 
+## 0.17.0
+
+### Minor Changes
+
+- abe5172: Extensions can declare input files the host's globs don't cover, via `ExtensionContext.trackInput`.
+
+  The skip-when-unchanged hash is built from `contracts.glob`, `forms.watch` and `pages.glob`. An extension that reads outside them therefore produced output that nothing could invalidate: `@dudousxd/nestjs-filter-codegen` resolves each route's `@ApplyFilter(FilterClass)` target and turns its `@Computed` / `@Filterable({ computed })` declarations into `filterFields` entries, but a filter class matches none of those globs — so editing one left the hash untouched and the next run reported "up to date, skipped" while serving stale types. The only way out was deleting `outDir`.
+
+  Extensions like that cannot declare their inputs up front (they need the discovered routes to know which files to read), so this works like a compiler depfile instead: paths reported during a run are recorded in the manifest as `extraInputs`, and the next run folds their contents into the hash. A file that becomes a dependency for the first time is picked up on the run after it is first read — in practice not a gap, since wiring a new filter class also edits a controller, which the globs already cover.
+
+  Deleting a tracked file invalidates too (it hashes as a `missing` marker rather than throwing), and a tracked path a glob already covers is hashed once, not twice.
+
+  Purely additive for existing extensions. `trackInput` is a no-op on the standalone `emitApi` path, which writes no manifest.
+
+## 0.16.0
+
+### Minor Changes
+
+- Discover routes on mixin (factory-produced) controllers.
+
+  A `@Controller` class whose heritage clause is a factory call now contributes the
+  decorated methods of the class that factory returns:
+
+  ```ts
+  @Controller("base/util/search")
+  export class SearchUtilController extends createTableController(Util, {
+    dto: UtilDTO,
+  }) {}
+  ```
+
+  NestJS already routes inherited methods at runtime via the prototype chain; the
+  static discovery pass now follows the same link. Each such route carries a new
+  `controllerRef.mixin` binding recording the factory and its call-site class
+  arguments — the decorator arguments _inside_ a factory reference its own
+  parameters, so the concrete entity is only knowable from the call site.
+
+  That binding drives two things:
+
+  - **`filterFields`** are derived from the call-site entity, so
+    `@ApplyFilter(GeneratedFilter)` works even though the filter class is declared
+    inside the factory and its `@Filterable({ entity })` names a parameter. This is
+    also what flips these routes from mutation to query in the emitted client.
+  - **Response types** are instantiated against the derived class, so
+    `Paginated<D>` resolves to the concrete `D`. This needs the type checker, which
+    needs lib files — the discovery Project sets `skipLoadingLibFiles` for
+    cold-start speed, so mixin response types resolve through a second Project
+    built lazily on the first mixin controller.
+
+  **Behaviour change:** `joinPaths` now always emits a leading slash.
+  `@Controller('items')` + `@Post(':id')` previously produced `items/:id` while
+  `@Controller('items')` alone produced `/items` — the prefix+suffix branch was the
+  only one that did not add it. The client's `buildUrl()` normalises before
+  requesting, so no URL was ever broken by this, but the raw value reaches the
+  emitted `ROUTES` map and the OpenAPI export, where a path without a leading slash
+  is invalid.
+
 ## 0.15.0
 
 ### Minor Changes