@dudousxd/nestjs-codegen 0.22.1 → 0.24.0

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @dudousxd/nestjs-codegen
 
+## 0.24.0
+
+### Minor Changes
+
+- c8d7eec: A mapped column's two declared types can disagree, so both are now emitted.
+
+  **If you upgraded to 0.23.0, you were affected** wherever an entity declares a mapped column — `@Property({ columnType: 'date', type: DateType }) x?: Opt<string>`, or a DECIMAL read back as a string. Those fields kept being emitted, but with the wrong kind, so every union a client derives from it rejected them: `.lt('serviceEndDate', …)` stopped compiling on a column that had been orderable all along.
+
+  The cause was the brand unwrapping itself. `classifyFieldType` consults the column decorator ONLY when the TS type resolves to `unknown` — so before 0.23.0 an `Opt<string>` fell through to `columnType: 'date'` and classified `date`, correctly and by accident. Making the TS side resolve meant the decorator was never reached.
+
+  The fix is not to pick a winner, because both are true and each is needed for a different question. `kind` now carries what the COLUMN is — the semantics an operator set derives from — and a new optional `valueKind` carries what the VALUE is, when they differ. A DATE column read back as `'YYYY-MM-DD'` emits `kind: 'date'` and `valueKind: 'string'`.
+
+  Collapsing them loses one or the other. Answer `string` and the field stops accepting the ordering and range operators the column supports. Answer `date` and the emitted type promises a `Date` the value never holds — which a type-preserving wire format like superjson then contradicts at runtime, since it faithfully transports the string that is actually there. That second failure predates 0.23.0 and is fixed here too: these columns used to emit as `Date` while carrying a string.
+
+  `valueKind` is absent when the two agree, which is the overwhelming majority of columns, so nothing changes for them.
+
+  Also teaches the decorator reader `columnType` (MikroORM's raw DDL slot) alongside `type`, and a mapped-type class (`type: DateType`) alongside a keyword string. It read neither, which is why the conflict was invisible from that side.
+
+## 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

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) {
@@ -1497,12 +1503,19 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
             return { kind: "string" };
           }
         }
-        const typeProp = arg.getProperty("type");
-        if (typeProp && import_ts_morph4.Node.isPropertyAssignment(typeProp)) {
+        for (const key of ["columnType", "type"]) {
+          const typeProp = arg.getProperty(key);
+          if (!typeProp || !import_ts_morph4.Node.isPropertyAssignment(typeProp)) continue;
           const init = typeProp.getInitializer();
-          if (init && import_ts_morph4.Node.isStringLiteral(init)) {
+          if (!init) continue;
+          if (import_ts_morph4.Node.isStringLiteral(init)) {
             const kind = classifyTypeKeyword(init.getLiteralValue());
             if (kind) return { kind };
+            continue;
+          }
+          if (import_ts_morph4.Node.isIdentifier(init)) {
+            const kind = classifyTypeKeyword(init.getText());
+            if (kind) return { kind };
           }
         }
       }
@@ -1514,12 +1527,18 @@ function classifyFromColumnDecorator(prop, sourceFile, project) {
 function classifyFieldType(prop, sourceFile, project) {
   let nullable = prop.hasQuestionToken();
   const typeNode = prop.getTypeNode();
+  const fromDecorator = classifyFromColumnDecorator(prop, sourceFile, project);
   if (typeNode) {
     const r = classifyTypeNode(typeNode, sourceFile, project);
     if (r.nullable) nullable = true;
-    if (r.kind !== "unknown") return markNullable(r, nullable);
+    if (r.kind !== "unknown") {
+      const conflicts = fromDecorator !== null && fromDecorator.kind !== "unknown" && fromDecorator.kind !== r.kind;
+      if (conflicts) {
+        return markNullable({ ...fromDecorator, valueKind: r.kind }, nullable);
+      }
+      return markNullable(r, nullable);
+    }
   }
-  const fromDecorator = classifyFromColumnDecorator(prop, sourceFile, project);
   if (fromDecorator) {
     return markNullable(fromDecorator, nullable || fromDecorator.nullable === true);
   }
@@ -1527,6 +1546,7 @@ function classifyFieldType(prop, sourceFile, project) {
 }
 function toFilterFieldType(name, r) {
   const ft = { name, kind: r.kind };
+  if (r.valueKind && r.valueKind !== r.kind) ft.valueKind = r.valueKind;
   if (r.enumValues && r.enumValues.length > 0) ft.enumValues = r.enumValues;
   if (r.nullable) ft.nullable = true;
   if (r.numericEnum) ft.numericEnum = true;
@@ -3332,7 +3352,7 @@ function kindToTs(kind, enumValues, numericEnum) {
 }
 function emitFieldTypesLiteral(fts) {
   const entries = fts.map((f) => {
-    let t = f.typeRef ? f.typeRef.name : kindToTs(f.kind, f.enumValues, f.numericEnum);
+    let t = f.typeRef ? f.typeRef.name : kindToTs(f.valueKind ?? f.kind, f.enumValues, f.numericEnum);
     if (f.nullable) t = `${t} | null`;
     return `${JSON.stringify(f.name)}: ${t}`;
   });
@@ -5253,7 +5273,7 @@ async function watch(config, onChange, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.22.1";
+var VERSION = "0.24.0";
 
 // src/cli/codegen.ts
 async function runCodegen(opts = {}) {