@zyno-io/ts-server-foundation 26.714.5 → 26.714.423

package/dist/src/type-compiler/go/type_expr.go

@@ -10,12 +10,8 @@ func typeExpr(info *fileInfo, reg *registry, raw string) string {
 	return typeExprCtx(info, reg, raw, &typeContext{seen: map[string]bool{}})
 }
 
-func internalTypeExprAt(info *fileInfo, reg *registry, raw string, pos int) string {
-	return typeExprCtx(info, reg, raw, &typeContext{seen: map[string]bool{}, pos: pos})
-}
-
 func typeExprCtx(info *fileInfo, reg *registry, raw string, ctx *typeContext) string {
-	raw = strings.TrimSpace(raw)
+	raw = strings.TrimSpace(stripTypeComments(raw))
 	raw = trimParens(raw)
 	raw = strings.TrimSpace(strings.TrimPrefix(raw, "readonly "))
 	if raw == "" || raw == "unknown" {
@@ -415,7 +411,7 @@ func renderUtilityProperty(info *fileInfo, reg *registry, prop utilityProperty,
 	if prop.owner != nil {
 		owner = prop.owner
 	}
-	t := typeExprCtx(owner, reg, prop.typeText, ctx)
+	t := internalTypeExprForNodeCtx(owner, reg, prop.typeText, prop.typeNode, ctx)
 	if prop.optional {
 		t = "{kind: 12, types: [" + t + ", {kind: 4}]}"
 	}
@@ -436,7 +432,7 @@ func renderPreferredUtilityProperty(info *fileInfo, reg *registry, prop utilityP
 	}
 	var t string
 	if sourceTypeNeedsInternalPropertyMetadata(owner, reg, prop.typeText, &typeContext{seen: map[string]bool{}, pos: pos}, map[string]bool{}) {
-		t = typeExprCtx(owner, reg, prop.typeText, &typeContext{seen: map[string]bool{}, pos: pos})
+		t = internalTypeExprForNode(owner, reg, prop.typeText, prop.typeNode, pos)
 	} else {
 		t = typeExprForNodePreferred(owner, reg, prop.typeText, prop.typeNode, pos, true)
 	}
@@ -634,7 +630,7 @@ func utilitySourceProperties(info *fileInfo, reg *registry, source string, ctx *
 	if class, owner, ok := resolveClassRefAt(info, reg, source, ctx.pos); ok {
 		props := make([]utilityProperty, 0, len(class.properties))
 		for _, prop := range class.properties {
-			props = append(props, utilityProperty{name: prop.name, typeText: prop.typeText, optional: prop.optional, owner: owner})
+			props = append(props, utilityProperty{name: prop.name, typeText: prop.typeText, typeNode: prop.typeNode, optional: prop.optional, owner: owner})
 		}
 		return props, owner, true
 	}
@@ -1097,7 +1093,7 @@ func aliasTypeExprCtx(owner *fileInfo, reg *registry, alias aliasInfo, name stri
 	if strings.TrimSpace(alias.metadataText) != "" {
 		return withTypeName(alias.metadataText, name)
 	}
-	return withTypeName(typeExprCtx(owner, reg, alias.body, ctx), name)
+	return withTypeName(internalTypeExprForNodeCtx(owner, reg, alias.body, alias.typeNode, ctx), name)
 }
 
 func ensureAliasMetadata(owner *fileInfo, reg *registry, name string, alias aliasInfo) aliasInfo {

package/dist/src/type-compiler/go/typia_expr.go

@@ -18,6 +18,7 @@ func typeExprForNode(info *fileInfo, reg *registry, raw string, node *shimast.No
 }
 
 func typeExprForNodePreferred(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int, preferTypia bool) string {
+	raw = strings.TrimSpace(stripTypeComments(raw))
 	if preferTypia {
 		if expr, ok := preferredWrapperTypeExprForNode(info, reg, raw, node, pos); ok {
 			return expr
@@ -25,16 +26,16 @@ func typeExprForNodePreferred(info *fileInfo, reg *registry, raw string, node *s
 		if expr, ok := preferredCachedAliasTypeExpr(info, reg, raw, pos); ok {
 			return expr
 		}
-		if expr, ok := preferredNullishAliasTypeExpr(info, reg, raw, pos); ok {
+		if expr, ok := preferredNullishAliasTypeExpr(info, reg, raw, node, pos); ok {
 			return expr
 		}
-		if expr, ok := preferredDateRootTypeExpr(info, reg, raw, pos); ok {
+		if expr, ok := preferredDateRootTypeExpr(info, reg, raw, node, pos); ok {
 			return expr
 		}
 		if expr, ok := preferredExternalImportedTypeExpr(info, raw); ok {
 			return expr
 		}
-		if expr, ok := preferredExternalImportedCompositeTypeExpr(info, reg, raw, pos); ok {
+		if expr, ok := preferredExternalImportedCompositeTypeExpr(info, reg, raw, node, pos); ok {
 			return expr
 		}
 		if expr, ok := preferredNamedInterfaceTypeExpr(info, reg, raw, pos); ok {
@@ -47,14 +48,78 @@ func typeExprForNodePreferred(info *fileInfo, reg *registry, raw string, node *s
 		}
 	}
 	if shouldUseTextTypeExpr(raw) {
-		return internalTypeExprAt(info, reg, raw, pos)
+		return internalTypeExprForNode(info, reg, raw, node, pos)
 	}
 	if shouldUseTypiaType(info, reg, raw) && canPreferTypiaType(info, reg, raw) {
 		if expr, ok := typiaTypeExprForNode(info, reg, raw, node, pos); ok {
 			return typiaSourceNamedExpr(info, reg, expr, raw)
 		}
 	}
-	return internalTypeExprAt(info, reg, raw, pos)
+	return internalTypeExprForNode(info, reg, raw, node, pos)
+}
+
+func internalTypeExprForNode(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int) string {
+	return internalTypeExprForNodeCtx(info, reg, raw, node, &typeContext{seen: map[string]bool{}, pos: pos})
+}
+
+func internalTypeExprForNodeCtx(info *fileInfo, reg *registry, raw string, node *shimast.Node, ctx *typeContext) string {
+	if ctx == nil {
+		ctx = &typeContext{seen: map[string]bool{}}
+	}
+	if node == nil {
+		return typeExprCtx(info, reg, raw, ctx)
+	}
+	if node.Kind == shimast.KindParenthesizedType {
+		inner := node.AsParenthesizedTypeNode().Type
+		if innerRaw, ok := sourceTypeNodeText(info, inner); ok {
+			return internalTypeExprForNodeCtx(info, reg, innerRaw, inner, ctx)
+		}
+		return typeExprCtx(info, reg, raw, ctx)
+	}
+
+	var kind int
+	var nodes []*shimast.Node
+	switch node.Kind {
+	case shimast.KindUnionType:
+		kind = 12
+		if types := node.AsUnionTypeNode().Types; types != nil {
+			nodes = types.Nodes
+		}
+	case shimast.KindIntersectionType:
+		kind = 13
+		if types := node.AsIntersectionTypeNode().Types; types != nil {
+			nodes = types.Nodes
+		}
+	default:
+		return typeExprCtx(info, reg, raw, ctx)
+	}
+	if len(nodes) < 2 {
+		return typeExprCtx(info, reg, raw, ctx)
+	}
+
+	types := make([]string, 0, len(nodes))
+	for _, child := range nodes {
+		childRaw, ok := sourceTypeNodeText(info, child)
+		if !ok {
+			return typeExprCtx(info, reg, raw, ctx)
+		}
+		types = append(types, internalTypeExprForNodeCtx(info, reg, childRaw, child, ctx))
+	}
+	return "{kind: " + strconv.Itoa(kind) + ", types: [" + strings.Join(types, ", ") + "]}"
+}
+
+func sourceTypeNodeText(info *fileInfo, node *shimast.Node) (string, bool) {
+	if node == nil {
+		return "", false
+	}
+	file := shimast.GetSourceFileOfNode(node)
+	if file == nil && info != nil {
+		file = info.file
+	}
+	if file == nil {
+		return "", false
+	}
+	return nodeText(file, node), true
 }
 
 func preferredCachedAliasTypeExpr(info *fileInfo, reg *registry, raw string, pos int) (string, bool) {
@@ -77,22 +142,46 @@ func preferredCachedAliasTypeExpr(info *fileInfo, reg *registry, raw string, pos
 	return aliasTypeExprCtx(owner, reg, alias, raw, &typeContext{seen: map[string]bool{}, pos: pos}), true
 }
 
-func preferredNullishAliasTypeExpr(info *fileInfo, reg *registry, raw string, pos int) (string, bool) {
+func preferredNullishAliasTypeExpr(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int) (string, bool) {
 	types := []string{}
-	aliasCount, ok := collectNullishAliasTypeExprs(info, reg, raw, pos, &types)
+	aliasCount, ok := collectNullishAliasTypeExprs(info, reg, raw, node, pos, &types)
 	if !ok || aliasCount != 1 || len(types) <= 1 {
 		return "", false
 	}
 	return "{kind: 12, types: [" + strings.Join(types, ", ") + "]}", true
 }
 
-func collectNullishAliasTypeExprs(info *fileInfo, reg *registry, raw string, pos int, types *[]string) (int, bool) {
+func collectNullishAliasTypeExprs(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int, types *[]string) (int, bool) {
 	raw = strings.TrimSpace(trimParens(raw))
+	if node != nil && node.Kind == shimast.KindParenthesizedType {
+		inner := node.AsParenthesizedTypeNode().Type
+		if innerRaw, ok := sourceTypeNodeText(info, inner); ok {
+			return collectNullishAliasTypeExprs(info, reg, innerRaw, inner, pos, types)
+		}
+	}
+	if node != nil && node.Kind == shimast.KindUnionType {
+		union := node.AsUnionTypeNode()
+		if union.Types != nil && len(union.Types.Nodes) > 1 {
+			aliasCount := 0
+			for _, child := range union.Types.Nodes {
+				childRaw, ok := sourceTypeNodeText(info, child)
+				if !ok {
+					return 0, false
+				}
+				count, ok := collectNullishAliasTypeExprs(info, reg, childRaw, child, pos, types)
+				if !ok {
+					return 0, false
+				}
+				aliasCount += count
+			}
+			return aliasCount, true
+		}
+	}
 	parts := nonEmptyParts(splitTop(raw, "|"))
 	if len(parts) > 1 {
 		aliasCount := 0
 		for _, part := range parts {
-			count, ok := collectNullishAliasTypeExprs(info, reg, part, pos, types)
+			count, ok := collectNullishAliasTypeExprs(info, reg, part, nil, pos, types)
 			if !ok {
 				return 0, false
 			}
@@ -117,11 +206,11 @@ func collectNullishAliasTypeExprs(info *fileInfo, reg *registry, raw string, pos
 	}
 }
 
-func preferredDateRootTypeExpr(info *fileInfo, reg *registry, raw string, pos int) (string, bool) {
+func preferredDateRootTypeExpr(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int) (string, bool) {
 	if !sourceTypeIsDateRootType(info, reg, raw, &typeContext{seen: map[string]bool{}, pos: pos}, map[string]bool{}) {
 		return "", false
 	}
-	return internalTypeExprAt(info, reg, raw, pos), true
+	return internalTypeExprForNode(info, reg, raw, node, pos), true
 }
 
 func preferredExternalImportedTypeExpr(info *fileInfo, raw string) (string, bool) {
@@ -136,25 +225,25 @@ func preferredExternalImportedTypeExpr(info *fileInfo, raw string) (string, bool
 	return externalImportedTypeExpr(ref, raw), true
 }
 
-func preferredExternalImportedCompositeTypeExpr(info *fileInfo, reg *registry, raw string, pos int) (string, bool) {
+func preferredExternalImportedCompositeTypeExpr(info *fileInfo, reg *registry, raw string, node *shimast.Node, pos int) (string, bool) {
 	raw = strings.TrimSpace(trimParens(raw))
 	if raw == "" || isIdentifierName(raw) {
 		return "", false
 	}
 	if parts := nonEmptyParts(splitTop(raw, "|")); len(parts) > 1 {
 		if typeContainsExternalImportReferenceInParts(info, reg, parts, map[string]bool{}) {
-			return internalTypeExprAt(info, reg, raw, pos), true
+			return internalTypeExprForNode(info, reg, raw, node, pos), true
 		}
 	}
 	if parts := nonEmptyParts(splitTop(raw, "&")); len(parts) > 1 {
 		if typeContainsExternalImportReferenceInParts(info, reg, parts, map[string]bool{}) {
-			return internalTypeExprAt(info, reg, raw, pos), true
+			return internalTypeExprForNode(info, reg, raw, node, pos), true
 		}
 	}
 	if strings.HasPrefix(raw, "[") && strings.HasSuffix(raw, "]") {
 		parts := nonEmptyParts(splitTop(strings.TrimSpace(raw[1:len(raw)-1]), ","))
 		if typeContainsExternalImportReferenceInParts(info, reg, parts, map[string]bool{}) {
-			return internalTypeExprAt(info, reg, raw, pos), true
+			return internalTypeExprForNode(info, reg, raw, node, pos), true
 		}
 	}
 	return "", false

package/docs/content/database.md

@@ -63,14 +63,14 @@ The migration generator reads entity metadata to infer table names, column names
 
 Database I/O does not run the reflected HTTP-input deserializer or validator over whole entities. TSF instead performs a small set of column-aware storage conversions and otherwise relies on the database driver and database engine.
 
-| Path                                           | Outbound conversion                                           | Inbound conversion                                               | Reflected validation |
-| ---------------------------------------------- | ------------------------------------------------------------- | ---------------------------------------------------------------- | -------------------- |
-| Entity `save()` / `saveEntity()`               | Column-aware                                                  | N/A                                                              | No                   |
-| Query-builder filters and patches              | Column-aware                                                  | N/A                                                              | No                   |
-| Query-builder entity hydration                 | N/A                                                           | Column-aware                                                     | No                   |
-| `createEntity()` and related constructors      | None; assigns application values and fills framework defaults | N/A                                                              | No                   |
-| `rawFind<T>()` / `rawFindOne<T>()`             | Generic SQL binding normalization only                        | Driver values returned unchanged                                 | No                   |
-| `rawFindUnsafe<T>()` / `rawFindOneUnsafe<T>()` | Generic SQL binding normalization only                        | Reflected `deserialize<T>()` when compiler metadata is available | No                   |
+| Path                                           | Outbound conversion                                           | Inbound conversion                                                 | Reflected validation |
+| ---------------------------------------------- | ------------------------------------------------------------- | ------------------------------------------------------------------ | -------------------- |
+| Entity `save()` / `saveEntity()`               | Column-aware                                                  | N/A                                                                | No                   |
+| Query-builder filters and patches              | Column-aware                                                  | N/A                                                                | No                   |
+| Query-builder entity hydration                 | N/A                                                           | Column-aware                                                       | No                   |
+| `createEntity()` and related constructors      | None; assigns application values and fills framework defaults | N/A                                                                | No                   |
+| `rawFind<T>()` / `rawFindOne<T>()`             | Generic SQL binding normalization only                        | Driver values returned unchanged                                   | No                   |
+| `rawFindUnsafe<T>()` / `rawFindOneUnsafe<T>()` | Generic SQL binding normalization only                        | Type-directed `deserialize<T>()` with an explicit or inferable `T` | No                   |
 
 Column-aware writes perform these conversions:
 
@@ -340,7 +340,9 @@ await db.rawExecute(
 
 `rawQuery<T>()` is the base row-returning method, and `rawFind<T>()` is its alias. `rawFindOne()` returns the first row or `undefined`. `rawExecute()` returns `{ affectedRows, rowCount?, insertId?, warningStatus? }`.
 
-The generic type on `rawFind<T>()` is a TypeScript-only assertion: returned rows keep the values produced by the database driver. The unsafe string methods have an additional compiler-injected reflected type slot, so `rawFindUnsafe<T>()` and `rawFindOneUnsafe<T>()` pass rows through `deserialize<T>()` when that metadata is available. That operation can coerce nested values or construct reflected classes, but it does not validate the rows. Prefer the query builder when entity column-aware hydration is required.
+The generic type on `rawFind<T>()` is a TypeScript-only assertion: returned rows keep the values produced by the database driver. The unsafe string methods have an additional compiler-injected reflected type slot, so an explicit or otherwise inferable `T` on `rawFindUnsafe<T>()` and `rawFindOneUnsafe<T>()` passes rows through `deserialize<T>()`. A call without a resolvable row type keeps the driver's values unchanged.
+
+Reflected raw-row deserialization is type-directed rather than column-aware. It recursively converts numeric boolean values such as MySQL `TINYINT(1)` (`0`, `1`, or other numeric values) to booleans, converts numeric strings to numbers when the target is `number`, and can construct reflected classes. Consequently, type precision-sensitive `DECIMAL` results as `string`, not `number`, and treat deserialized entity instances as unmanaged objects without ORM snapshots. The operation does not validate rows; prefer the query builder when entity column-aware hydration and persistence tracking are required.
 
 The unsafe variants accept a SQL string and bindings:
 

package/docs/content/sql.md

@@ -107,7 +107,7 @@ await session.rawExecuteUnsafe('UPDATE users SET active = ? WHERE id = ?', [fals
 
 Prefer the `sql` tag for new code because identifiers and values stay explicit in the same expression.
 
-When TSF's metadata compiler can provide `T`, `rawFindUnsafe<T>()` and `rawFindOneUnsafe<T>()` reflected-deserialize returned rows. They still do not validate them. This behavior is specific to the unsafe methods' receive-type signature; use query-builder entity reads for column-aware hydration.
+When TSF's metadata compiler can resolve an explicit or inferable `T`, `rawFindUnsafe<T>()` and `rawFindOneUnsafe<T>()` reflected-deserialize returned rows. Numeric values targeting booleans are converted to `true` or `false`, including MySQL `TINYINT(1)` results. Numeric strings targeting `number` are also converted, so precision-sensitive `DECIMAL` results should be typed as `string`. Calls without a resolvable row type keep driver-native values. Typed raw reads do not validate rows or attach ORM persistence state; use query-builder entity reads for column-aware hydration.
 
 ## Rendering For Logs Or Tests
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zyno-io/ts-server-foundation",
-    "version": "26.714.5",
+    "version": "26.714.423",
     "description": "TypeScript server foundation with reflected type metadata",
     "license": "MIT",
     "bin": {