typelizer 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0b21f5f78121c64717aa08d6556efbddc0b0b80a3ec6f272d63f699133fff12
-  data.tar.gz: d8df7c3542950c82e6b25d3f9c39ea808aded01fab0e5b5eaada3801a99031a3
+  metadata.gz: d8a6cb6187a0670a589346d969c61a17ae0b9fd60a4e6926c74c2e72c9594130
+  data.tar.gz: 4ef1a1e6e728df5ab1d5198a0254cfa68e5e477da57fb9c3c6b7ae2f7efa945d
 SHA512:
-  metadata.gz: cc42979e0f00e3aec338fdd4cf3848639ba12a2019293a46e864e908a1dfd8f2f2258ef62d07ed15ec3da66ca7ad740907ac63c6e04f9aae29f18db0eae46584
-  data.tar.gz: c9504167e013d6aeff1208207b4531f012fe942018e72368296d2a676fb04460ece7b0582a5ef297cf6c037e071ea0868e39c4632765030bdb014fe9a49884ea
+  metadata.gz: 56296749f1d5478e98457afac0d2e8599e360d5b7864d596772c825e9970471de8b1d0103ada0120b9adeddab2805e65976c496ce0963785dfd39ddc3dffae91
+  data.tar.gz: 25f8667ef0f54560e1c84e8d906b50abc55e01ea761dacff012657bc7d94f7127263166b81c4e317350ee89219f92a070aa042004f42cfad3a6482fe31a0c86f

data/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-02-26
+
+### Added
+
+- Alba: nested attributes (`nested` / `nested_attribute`) now generate inline nested TypeScript types with full type inference support, including within traits. ([@pgiblock])
+
+- OpenAPI: support for traits in schema generation. ([@skryukov])
+
+- Union types in `typelize` for polymorphic associations. Supports serializer class references, pipe-delimited strings, and plain TypeScript type names. ([@skryukov])
+
+  ```ruby
+  typelize commentable: [UserResource, CommentResource]
+  typelize approver: "AuthorResource | null"
+  typelize content: "TextBlock | ImageBlock"
+  ```
+
+### Fixed
+
+- OpenAPI: TypeScript-only types (`any`, `unknown`, `never`) and generic types (`Record<string, unknown>`, `Partial<T>`, etc.) no longer produce invalid `$ref` entries. They are mapped to `{type: :object}` instead. ([@skryukov])
+- OpenAPI: fix nullable arrays producing incorrect schemas. ([@skryukov])
+- Fix Typelizer not loading gracefully when required gems are missing at boot time. ([@skryukov])
+
+### Changed
+
+- **Internal:** Union types are now stored as arrays of symbols instead of pipe-delimited strings. This fixes import resolution for serializer classes inside unions and eliminates redundant string splitting/joining across the DSL, Interface, and OpenAPI layers. ([@skryukov])
+
 ## [0.8.0] - 2026-02-19
 
 ### Added
@@ -381,12 +407,14 @@ and this project adheres to [Semantic Versioning].
 [@NOX73]: https://github.com/NOX73
 [@okuramasafumi]: https://github.com/okuramasafumi
 [@patvice]: https://github.com/patvice
+[@pgiblock]: https://github.com/pgiblock
+[@prog-supdex]: https://github.com/prog-supdex
 [@PedroAugustoRamalhoDuarte]: https://github.com/PedroAugustoRamalhoDuarte
 [@skryukov]: https://github.com/skryukov
-[@prog-supdex]: https://github.com/prog-supdex
 [@ventsislaf]: https://github.com/ventsislaf
 
-[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.8.0...HEAD
+[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.9.0...HEAD
+[0.9.0]: https://github.com/skryukov/typelizer/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/skryukov/typelizer/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/skryukov/typelizer/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/skryukov/typelizer/compare/v0.5.6...v0.6.0

data/README.md

@@ -149,6 +149,57 @@ class PostResource < ApplicationResource
 end
 ```
 
+Union types are supported for polymorphic associations. You can use serializer class references, which resolve to their generated type names:
+
+```ruby
+class PostResource < ApplicationResource
+  attributes :id, :title
+
+  # Union of two serializers — resolves to generated type names
+  typelize commentable: [UserResource, CommentResource]
+  attribute :commentable
+
+  # Nullable union — extracts null and marks as nullable
+  typelize approver: "AuthorResource | null"
+  attribute :approver
+
+  # Pipe-delimited string with serializer names
+  typelize target: "UserResource | CommentResource"
+  attribute :target
+
+  # String and class constant can be mixed
+  typelize item: ["Namespace::UserResource", CommentResource]
+  attribute :item
+end
+```
+
+You can also use plain TypeScript type names for custom types that aren't backed by serializers:
+
+```ruby
+class PostResource < ApplicationResource
+  attributes :id, :title
+
+  # Plain type names — passed through as-is to TypeScript
+  typelize content: "TextBlock | ImageBlock"
+  attribute :content
+
+  # Works with arrays too
+  typelize sections: ["TextBlock", "ImageBlock"]
+  attribute :sections
+end
+```
+
+This generates:
+
+```typescript
+type Post = {
+  id: number;
+  title: string;
+  content: TextBlock | ImageBlock;
+  sections: TextBlock | ImageBlock;
+}
+```
+
 For more complex type definitions, use the full API:
 
 ```ruby

data/lib/tasks/generate.rake

@@ -24,6 +24,8 @@ namespace :typelizer do
     end
 
     interfaces = Typelizer.interfaces
+    raise ArgumentError, "No serializers found. Please ensure all your serializers include Typelizer::DSL." if interfaces.empty?
+
     puts "Finished in #{time} seconds"
     puts "Found #{interfaces.size} serializers:"
     puts interfaces.map { |i| "\t#{i.name}" }.join("\n")

data/lib/typelizer/delegate_tracker.rb

@@ -15,7 +15,7 @@ module Typelizer
     module Hook
       def delegate(*methods, to:, allow_nil: nil, prefix: nil, **)
         super.tap do
-          next unless is_a?(Class) && defined?(ActiveRecord::Base) && self < ActiveRecord::Base
+          next unless is_a?(Class) && defined?(ActiveRecord::Base) && !ActiveRecord.autoload?(:Base) && self < ActiveRecord::Base
 
           method_prefix = if prefix == true
             "#{to}_"

data/lib/typelizer/dsl.rb

@@ -104,16 +104,16 @@ module Typelizer
           options = attrs.last.is_a?(Hash) ? attrs.pop : {}
 
           if attrs.any?
-            # Parse type shortcuts and merge options
             parsed_types = attrs.map { |t| TypeParser.parse(t) }
-            type_names = parsed_types.map { |p| p[:type] }
-            options[:type] = type_names.join(" | ")
-
-            # Merge modifier flags from all parsed types
+            all_types = parsed_types.flat_map { |p| Array(p[:type]) }
             parsed_types.each do |parsed|
               options[:optional] = true if parsed[:optional]
               options[:multi] = true if parsed[:multi]
+              options[:nullable] = true if parsed[:nullable]
             end
+            options[:nullable] = true if all_types.delete(:null)
+            # Unwrap single-element arrays: typelize field: ["string"] behaves like typelize field: "string"
+            options[:type] = (all_types.size == 1) ? all_types.first : all_types
           end
 
           instance_variable_get(instance_variable)[name.to_sym] ||= {}

data/lib/typelizer/generator.rb

@@ -11,7 +11,7 @@ module Typelizer
 
       Typelizer.configuration.writers.each do |writer_name, writer_config|
         interfaces = Typelizer.interfaces(writer_name: writer_name)
-        raise ArgumentError, "No serializers found. Please ensure all your serializers include Typelizer::DSL." if interfaces.empty?
+        next if interfaces.empty?
 
         Writer.new(writer_config).call(interfaces, force: force)
       end

data/lib/typelizer/interface.rb

@@ -1,5 +1,9 @@
+require_relative "type_inference"
+
 module Typelizer
   class Interface
+    include TypeInference
+
     attr_reader :serializer, :context
 
     def initialize(serializer:, context:)
@@ -60,7 +64,7 @@ module Typelizer
 
     def enum_types
       @enum_types ||= begin
-        all_properties = properties + trait_interfaces.flat_map(&:properties)
+        all_properties = collect_all_properties(properties + trait_interfaces.flat_map(&:properties))
         all_properties
           .select(&:enum_definition)
           .uniq(&:enum_type_name)
@@ -104,12 +108,12 @@ module Typelizer
 
     def imports
       @imports ||= begin
-        # Include both main properties and trait properties for import collection
-        all_properties = properties_to_print + trait_interfaces.flat_map(&:properties)
+        # Include both main properties and trait properties for import collection,
+        # recursively including nested sub-properties
+        all_properties = collect_all_properties(properties_to_print + trait_interfaces.flat_map(&:properties))
 
-        association_serializers, attribute_types = all_properties.filter_map(&:type)
-          .uniq
-          .partition { |type| type.is_a?(Interface) }
+        flat_types = all_properties.filter_map(&:type).flat_map { |t| Array(t) }.uniq
+        association_serializers, attribute_types = flat_types.partition { |type| type.is_a?(Interface) }
 
         serializer_types = association_serializers
           .filter_map { |interface| interface.name if interface.name != name && !interface.inline? }
@@ -158,6 +162,16 @@ module Typelizer
 
     private
 
+    def collect_all_properties(props)
+      props.flat_map do |prop|
+        if prop.nested_properties&.any?
+          [prop] + collect_all_properties(prop.nested_properties)
+        else
+          [prop]
+        end
+      end
+    end
+
     def self_type_name
       serializer.name.match(/(\w+::)?(\w+)(Serializer|Resource)/)[2]
     end
@@ -182,6 +196,7 @@ module Typelizer
           .then { |p| has_dsl ? p : apply_model_inference(p) }
           .then { |p| apply_multi_flag(p, multi_attrs) }
           .then { |p| apply_metadata(p) }
+          .then { |p| infer_nested_property_types(p) }
       end
     end
 
@@ -199,47 +214,38 @@ module Typelizer
 
     def resolve_class_type(attrs)
       type = attrs[:type]
-      return attrs unless type.is_a?(String) || type.is_a?(Symbol)
-
-      klass = Object.const_get(type.to_s)
-      return attrs unless klass.respond_to?(:typelizer_config)
 
-      attrs.merge(type: context.interface_for(klass))
-    rescue NameError
-      attrs
+      case type
+      when Array
+        resolve_union_class_types(attrs)
+      when String, Symbol
+        resolve_single_class_type(attrs)
+      else
+        attrs
+      end
     end
 
-    def apply_model_inference(prop)
-      model_plugin.infer_types(prop)
+    def resolve_single_class_type(attrs)
+      attrs.merge(type: resolve_type_part(attrs[:type]))
     end
 
-    def apply_multi_flag(prop, multi_attrs)
-      return prop unless multi_attrs.include?(prop.column_name.to_sym)
-
-      prop.with(multi: true)
+    def resolve_union_class_types(attrs)
+      resolved = attrs[:type].map { |part| resolve_type_part(part) }
+      # Unwrap single-element arrays (e.g., after null extraction from ["Serializer", null])
+      attrs.merge(type: (resolved.size == 1) ? resolved.first : resolved)
     end
 
-    def apply_metadata(prop)
-      prop.tap do |p|
-        p.comment ||= model_plugin.comment_for(p) if config.comments && p.comment != false
-        p.enum ||= model_plugin.enum_for(p) if p.enum != false
-      end
+    def resolve_type_part(part)
+      klass = Object.const_get(part.to_s)
+      klass.respond_to?(:typelizer_config) ? context.interface_for(klass) : part
+    rescue NameError
+      part
     end
 
-    def model_class
-      return serializer._typelizer_model_name if serializer.respond_to?(:_typelizer_model_name)
-
-      # Execute the `serializer_model_mapper` lambda in the context of the `config` object
-      # This giving a possibility to access other lambdas, for example, `serializer_name_mapper`
-      config.instance_exec(serializer, &config.serializer_model_mapper)
-    rescue NameError => e
-      Typelizer.logger.debug("model_mapper failed for serializer #{serializer.name}: #{e.class}: #{e.message}")
-
-      nil
-    end
+    def apply_multi_flag(prop, multi_attrs)
+      return prop unless multi_attrs.include?(prop.column_name.to_sym)
 
-    def model_plugin
-      @model_plugin ||= config.model_plugin.new(model_class: model_class, config: config)
+      prop.with(multi: true)
     end
   end
 end

data/lib/typelizer/openapi.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module Typelizer
-  class OpenAPI
+  module OpenAPI
     SUPPORTED_VERSIONS = ["3.0", "3.1"].freeze
+
     OPENAPI_TYPES = %i[integer number string boolean object array null].freeze
+    TS_OBJECT_TYPES = %w[any unknown never Record Partial Pick Omit].freeze
 
     COLUMN_TYPE_MAP = {
       integer: {type: :integer},
@@ -25,100 +27,188 @@ module Typelizer
       cidr: {type: :string}
     }.freeze
 
-    def self.schema_for(interface, openapi_version: "3.0")
-      raise ArgumentError, "Unsupported openapi_version: #{openapi_version}. Must be one of: #{SUPPORTED_VERSIONS.join(", ")}" unless SUPPORTED_VERSIONS.include?(openapi_version.to_s)
+    class << self
+      def schema_for(interface, openapi_version: "3.0")
+        validate_version!(openapi_version)
 
-      required_props = interface.properties.reject(&:optional).map(&:name)
-      schema = {
-        type: :object,
-        properties: interface.properties.to_h { |prop| [prop.name, property_schema(prop, openapi_version: openapi_version)] }
-      }
-      schema[:required] = required_props if required_props.any?
-      schema
-    end
+        required_props = interface.properties.reject(&:optional).map(&:name)
+        schema = {
+          type: :object,
+          properties: interface.properties.to_h { |prop| [prop.name, property_schema(prop, openapi_version: openapi_version)] }
+        }
+        schema[:required] = required_props if required_props.any?
+        schema
+      end
 
-    def self.property_schema(property, openapi_version: "3.0")
-      raise ArgumentError, "Unsupported openapi_version: #{openapi_version}. Must be one of: #{SUPPORTED_VERSIONS.join(", ")}" unless SUPPORTED_VERSIONS.include?(openapi_version.to_s)
+      def property_schema(property, openapi_version: "3.0")
+        if property.type.is_a?(Array)
+          return union_schema(property, openapi_version: openapi_version)
+        end
 
-      definition = base_type(property)
-      ref = definition.delete("$ref")
+        definition = base_type(property, openapi_version: openapi_version)
+        ref = definition.delete("$ref")
+
+        definition = if ref
+          ref_schema(ref, property, openapi_version: openapi_version)
+        else
+          inline_schema(definition, property, openapi_version: openapi_version)
+        end
 
-      definition = if ref
-        ref_schema(ref, property, openapi_version: openapi_version)
-      else
-        inline_schema(definition, property, openapi_version: openapi_version)
+        definition = wrap_traits(definition, property, openapi_version: openapi_version)
+        wrap_multi(definition, property, openapi_version: openapi_version)
       end
 
-      if property.multi
-        definition = {type: :array, items: definition}
-        if property.nullable
-          if openapi_version.to_s >= "3.1"
-            definition[:type] = [:array, :null]
+      private
+
+      def ref_schema(ref, property, openapi_version:)
+        ref_obj = {"$ref" => ref}
+        item_nullable = !property.multi && property.nullable
+
+        if v31?(openapi_version)
+          definition = item_nullable ? {oneOf: [ref_obj, {type: :null}]} : ref_obj
+        else
+          needs_wrapper = item_nullable || (!property.multi && (property.comment.is_a?(String) || property.deprecated))
+          definition = needs_wrapper ? {allOf: [ref_obj]} : ref_obj
+          definition[:nullable] = true if item_nullable
+        end
+
+        apply_metadata(definition, property) unless property.multi
+        definition
+      end
+
+      def inline_schema(definition, property, openapi_version:)
+        unless property.multi
+          apply_nullable(definition, property, openapi_version: openapi_version)
+          apply_metadata(definition, property)
+        end
+        if property.enum.is_a?(Array)
+          items_nullable = !property.multi && property.nullable
+          definition[:enum] = (items_nullable && !property.enum.include?(nil)) ? property.enum + [nil] : property.enum
+        end
+        definition
+      end
+
+      def union_schema(property, openapi_version:)
+        schemas = property.type.map { |part| union_member_schema(part) }
+
+        definition = {anyOf: schemas}
+
+        unless property.multi
+          apply_nullable(definition, property, openapi_version: openapi_version)
+          apply_metadata(definition, property)
+        end
+
+        wrap_multi(definition, property, openapi_version: openapi_version)
+      end
+
+      def union_member_schema(type)
+        if type.respond_to?(:properties)
+          {"$ref" => "#/components/schemas/#{type.name}"}
+        else
+          sym = type.to_sym
+          if OPENAPI_TYPES.include?(sym)
+            {type: sym}
+          elsif ts_only_type?(type.to_s)
+            {type: :object}
           else
-            definition[:nullable] = true
+            {"$ref" => "#/components/schemas/#{type}"}
           end
         end
       end
 
-      definition
-    end
+      def wrap_traits(definition, property, openapi_version:)
+        return definition unless property.respond_to?(:with_traits) && property.with_traits&.any? && property.type.respond_to?(:name)
 
-    def self.ref_schema(ref, property, openapi_version:)
-      has_siblings = property.nullable || property.comment.is_a?(String) || property.deprecated
-      ref_obj = {"$ref" => ref}
+        trait_refs = property.with_traits.map do |t|
+          {"$ref" => "#/components/schemas/#{property.type.name}#{t.to_s.camelize}Trait"}
+        end
 
-      if openapi_version.to_s >= "3.1"
-        definition = property.nullable ? {oneOf: [ref_obj, {type: :null}]} : ref_obj
-      else
-        # In 3.0, $ref must stand alone — use allOf wrapper when siblings are needed
-        definition = has_siblings ? {allOf: [ref_obj]} : ref_obj
-        definition[:nullable] = true if property.nullable
+        base_ref = definition.delete("$ref")
+        if base_ref
+          definition = {allOf: [{"$ref" => base_ref}] + trait_refs}
+        elsif definition[:oneOf]
+          non_null = definition[:oneOf].reject { |s| s[:type] == :null }
+          null_schemas = definition[:oneOf].select { |s| s[:type] == :null }
+          all_of = non_null + trait_refs
+          definition = null_schemas.any? ? {oneOf: [{allOf: all_of}, *null_schemas]} : {allOf: all_of}
+        elsif definition[:allOf]
+          definition[:allOf].concat(trait_refs)
+        else
+          raise ArgumentError, "Unexpected schema shape for traits on property #{property.name}: #{definition.inspect}"
+        end
+
+        definition[:nullable] = true if !v31?(openapi_version) && property.nullable
+        definition
       end
 
-      definition[:description] = property.comment if property.comment.is_a?(String)
-      definition[:deprecated] = true if property.deprecated
-      definition
-    end
+      def apply_metadata(definition, property)
+        definition[:description] = property.comment if property.comment.is_a?(String)
+        definition[:deprecated] = true if property.deprecated
+      end
 
-    def self.inline_schema(definition, property, openapi_version:)
-      # For multi properties, nullable is applied to the array container in property_schema
-      unless property.multi
+      def apply_nullable(definition, property, openapi_version:)
+        return unless property.nullable
+
+        if definition[:anyOf]
+          v31?(openapi_version) ? definition[:anyOf] << {type: :null} : definition[:nullable] = true
+        elsif definition[:type]
+          v31?(openapi_version) ? definition[:type] = [definition[:type], :null] : definition[:nullable] = true
+        end
+      end
+
+      def wrap_multi(definition, property, openapi_version:)
+        return definition unless property.multi
+
+        definition = {type: :array, items: definition}
+        apply_metadata(definition, property)
         if property.nullable
-          if openapi_version.to_s >= "3.1"
-            definition[:type] = [definition[:type], :null]
+          v31?(openapi_version) ? definition[:type] = [:array, :null] : definition[:nullable] = true
+        end
+        definition
+      end
+
+      def base_type(property, openapi_version:)
+        if property.type.respond_to?(:properties)
+          if property.type.respond_to?(:inline?) && property.type.inline?
+            schema_for(property.type, openapi_version: openapi_version)
           else
-            definition[:nullable] = true
+            {"$ref" => "#/components/schemas/#{property.type.name}"}
           end
+        elsif property.type.nil? && property.respond_to?(:nested_properties) && property.nested_properties&.any?
+          nested_schema(property, openapi_version: openapi_version)
+        elsif property.column_type && COLUMN_TYPE_MAP.key?(property.column_type)
+          result = COLUMN_TYPE_MAP[property.column_type].dup
+          result[:type] = :string if property.enum
+          result
+        elsif (property.type.is_a?(String) || property.type.is_a?(Symbol)) && !OPENAPI_TYPES.include?(property.type.to_sym) && !ts_only_type?(property.type.to_s)
+          {"$ref" => "#/components/schemas/#{property.type}"}
+        else
+          type = property.type.to_s.to_sym
+          OPENAPI_TYPES.include?(type) ? {type: type} : {type: :object}
         end
       end
-      definition[:description] = property.comment if property.comment.is_a?(String)
-      if property.enum.is_a?(Array)
-        items_nullable = !property.multi && property.nullable
-        definition[:enum] = (items_nullable && !property.enum.include?(nil)) ? property.enum + [nil] : property.enum
+
+      def nested_schema(property, openapi_version:)
+        required = property.nested_properties.reject(&:optional).map(&:name)
+        schema = {
+          type: :object,
+          properties: property.nested_properties.to_h { |p| [p.name, property_schema(p, openapi_version: openapi_version)] }
+        }
+        schema[:required] = required if required.any?
+        schema
       end
-      definition[:deprecated] = true if property.deprecated
-      definition
-    end
-    private_class_method :ref_schema, :inline_schema
-
-    def self.base_type(property)
-      if property.type.respond_to?(:properties)
-        {"$ref" => "#/components/schemas/#{property.type.name}"}
-      elsif property.column_type && COLUMN_TYPE_MAP.key?(property.column_type)
-        result = COLUMN_TYPE_MAP[property.column_type].dup
-        result[:type] = :string if property.enum
-        result
-      elsif property.type.is_a?(String) && !OPENAPI_TYPES.include?(property.type.to_sym)
-        {"$ref" => "#/components/schemas/#{property.type}"}
-      else
-        type = property.type.to_s.to_sym
-        if OPENAPI_TYPES.include?(type)
-          {type: type}
-        else
-          {type: :object}
-        end
+
+      def v31?(openapi_version)
+        openapi_version.to_s == "3.1"
+      end
+
+      def ts_only_type?(type_str)
+        type_str.start_with?("{") || type_str.include?("<") || TS_OBJECT_TYPES.include?(type_str)
+      end
+
+      def validate_version!(openapi_version)
+        raise ArgumentError, "Unsupported openapi_version: #{openapi_version}. Must be one of: #{SUPPORTED_VERSIONS.join(", ")}" unless SUPPORTED_VERSIONS.include?(openapi_version.to_s)
       end
     end
-    private_class_method :base_type
   end
 end

data/lib/typelizer/property.rb

@@ -2,7 +2,7 @@ module Typelizer
   Property = Struct.new(
     :name, :type, :optional, :nullable,
     :multi, :column_name, :column_type, :comment, :enum, :enum_type_name, :deprecated,
-    :with_traits,
+    :with_traits, :nested_properties, :nested_typelizes,
     keyword_init: true
   ) do
     def with(**attrs)
@@ -52,8 +52,13 @@ module Typelizer
     def fingerprint
       # Use array format for consistent output across Ruby versions
       # (Hash#inspect format changed in Ruby 3.4)
-      # Exclude fields that do not affect generated TypeScript output
-      to_h.except(:column_type).merge(type: UnionTypeSorter.sort(type_name(sort_order: :alphabetical), :alphabetical))
+      # Exclude fields that do not affect generated TypeScript output.
+      # Exclude nested_properties/nested_typelizes from to_h to avoid changing
+      # fingerprints for properties that don't use them.
+      # nested_typelizes is excluded entirely as it only affects inference, not output.
+      to_h.except(:column_type, :nested_properties, :nested_typelizes)
+        .merge(type: UnionTypeSorter.sort(type_name(sort_order: :alphabetical), :alphabetical))
+        .then { |h| nested_properties&.any? ? h.merge(nested_properties: nested_properties.map(&:fingerprint)) : h }
         .to_a.inspect
     end
 
@@ -90,7 +95,20 @@ module Typelizer
         return enum_values.join(" | ")
       end
 
-      type.respond_to?(:name) ? type.name : type || "unknown"
+      if type.nil? && nested_properties&.any?
+        inner = nested_properties.map { |p|
+          rendered = p.render(sort_order: sort_order, prefer_double_quotes: prefer_double_quotes) + ";"
+          rendered.gsub(/^/, "  ")
+        }.join("\n")
+        return "{\n#{inner}\n}"
+      end
+
+      case type
+      when Array
+        type.map { |t| t.respond_to?(:name) ? t.name : t.to_s }.join(" | ")
+      else
+        type.respond_to?(:name) ? type.name : type&.to_s || "unknown"
+      end
     end
   end
 end

data/lib/typelizer/serializer_plugins/alba/{trait_attribute_collector.rb → block_attribute_collector.rb}

@@ -2,7 +2,7 @@
 
 module Typelizer
   module SerializerPlugins
-    class Alba::TraitAttributeCollector
+    class Alba::BlockAttributeCollector
       attr_reader :collected_attributes, :collected_typelizes
 
       def initialize
@@ -53,15 +53,26 @@ module Typelizer
         end
       end
 
-      # Simple struct to hold association info from traits
-      TraitAssociation = Struct.new(:name, :resource, :with_traits, :multi, :key, keyword_init: true)
+      # Simple struct to hold association info from blocks
+      BlockAssociation = Struct.new(:name, :resource, :with_traits, :multi, :key, keyword_init: true)
+
+      # Struct to hold nested attribute info captured within a block
+      BlockNestedAttribute = Struct.new(:name, :block, keyword_init: true)
+
+      def nested_attribute(name, **options, &block)
+        raise ArgumentError, "Block is required for nested_attribute" unless block
+
+        @collected_attributes[name] = BlockNestedAttribute.new(name: name, block: block)
+      end
+
+      alias_method :nested, :nested_attribute
 
       # Support association methods that might be used in traits
       def one(name, **options, &block)
         resource = options[:resource] || options[:serializer]
         with_traits = options[:with_traits]
         key = options[:key] || name
-        @collected_attributes[key] = TraitAssociation.new(
+        @collected_attributes[key] = BlockAssociation.new(
           name: name,
           resource: resource,
           with_traits: with_traits,
@@ -77,7 +88,7 @@ module Typelizer
         resource = options[:resource] || options[:serializer]
         with_traits = options[:with_traits]
         key = options[:key] || name
-        @collected_attributes[key] = TraitAssociation.new(
+        @collected_attributes[key] = BlockAssociation.new(
           name: name,
           resource: resource,
           with_traits: with_traits,

data/lib/typelizer/serializer_plugins/alba/trait_interface.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative "../../type_inference"
+
 module Typelizer
   module SerializerPlugins
     class Alba::TraitInterface
+      include TypeInference
+
       attr_reader :serializer, :trait_name, :context, :plugin
 
       def initialize(serializer:, trait_name:, context:, plugin:)
@@ -33,31 +37,13 @@ module Typelizer
 
       def infer_types(props, typelizes)
         props.map do |prop|
-          # First check for typelize DSL in the trait
           dsl_type = typelizes[prop.column_name.to_sym] || typelizes[prop.name.to_sym]
-          if dsl_type&.any?
-            next prop.with(**dsl_type).tap do |property|
-              property.comment ||= model_plugin.comment_for(property) if config.comments && property.comment != false
-              property.enum ||= model_plugin.enum_for(property) if property.enum != false
-            end
-          end
-
-          # Fall back to model plugin for type inference
-          model_plugin.infer_types(prop)
+          prop
+            .then { |p| dsl_type&.any? ? p.with(**dsl_type) : apply_model_inference(p) }
+            .then { |p| apply_metadata(p) }
+            .then { |p| infer_nested_property_types(p) }
         end
       end
-
-      def model_class
-        return serializer._typelizer_model_name if serializer.respond_to?(:_typelizer_model_name)
-
-        config.instance_exec(serializer, &config.serializer_model_mapper)
-      rescue NameError
-        nil
-      end
-
-      def model_plugin
-        @model_plugin ||= config.model_plugin.new(model_class: model_class, config: config)
-      end
     end
   end
 end

data/lib/typelizer/serializer_plugins/alba.rb

@@ -48,19 +48,19 @@ module Typelizer
         return [], {} unless trait_block
 
         # Create a collector to capture attributes defined in the trait block
-        collector = TraitAttributeCollector.new
+        collector = BlockAttributeCollector.new
         collector.instance_exec(&trait_block)
 
         props = collector.collected_attributes.map do |name, attr|
-          build_trait_property(name.is_a?(Symbol) ? name.name : name, attr)
+          build_collected_property(name.is_a?(Symbol) ? name.name : name, attr)
         end
 
         [props, collector.collected_typelizes]
       end
 
-      def build_trait_property(name, attr)
+      def build_collected_property(name, attr)
         case attr
-        when TraitAttributeCollector::TraitAssociation
+        when BlockAttributeCollector::BlockAssociation
           with_traits = Array(attr.with_traits) if attr.with_traits
           resource = attr.resource || infer_resource_from_name(name)
 
@@ -73,6 +73,19 @@ module Typelizer
             column_name: name,
             with_traits: with_traits
           )
+        when BlockAttributeCollector::BlockNestedAttribute
+          prop_name = has_transform_key?(serializer) ? fetch_key(serializer, name) : name
+          nested_props, nested_typelizes = collect_nested_block(attr.block)
+          Property.new(
+            name: prop_name,
+            type: nil,
+            optional: false,
+            nullable: false,
+            multi: false,
+            column_name: name,
+            nested_properties: nested_props,
+            nested_typelizes: nested_typelizes
+          )
         else
           build_property(name, attr)
         end
@@ -95,7 +108,7 @@ module Typelizer
       end
 
       def trait_interfaces
-        traits.map do |trait_name, _|
+        @trait_interfaces ||= traits.map do |trait_name, _|
           TraitInterface.new(
             serializer: serializer,
             trait_name: trait_name,
@@ -164,6 +177,8 @@ module Typelizer
             **options
           )
         when ::Alba::NestedAttribute
+          block = attr.instance_variable_get(:@block)
+          nested_props, nested_typelizes = collect_nested_block(block)
           Property.new(
             name: name,
             type: nil,
@@ -171,6 +186,8 @@ module Typelizer
             nullable: false,
             multi: false,
             column_name: column_name,
+            nested_properties: nested_props,
+            nested_typelizes: nested_typelizes,
             **options
           )
         when ::Alba::ConditionalAttribute
@@ -192,14 +209,24 @@ module Typelizer
         ::Alba.transform_key(key, transform_type: serializer._transform_type)
       end
 
-      private
-
       def ts_mapper
         config.plugin_configs.dig(:alba, :ts_mapper) || ALBA_TS_MAPPER
       end
+
+      def collect_nested_block(block)
+        collector = BlockAttributeCollector.new
+        collector.instance_exec(&block)
+
+        props = collector.collected_attributes.map do |attr_name, attr|
+          attr_name_str = attr_name.is_a?(Symbol) ? attr_name.name : attr_name
+          build_collected_property(attr_name_str, attr)
+        end
+
+        [props, collector.collected_typelizes]
+      end
     end
   end
 end
 
-require_relative "alba/trait_attribute_collector"
+require_relative "alba/block_attribute_collector"
 require_relative "alba/trait_interface"

data/lib/typelizer/type_inference.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module TypeInference
+    private
+
+    def apply_model_inference(prop)
+      model_plugin.infer_types(prop)
+    end
+
+    def apply_metadata(prop)
+      prop.tap do |p|
+        p.comment ||= model_plugin.comment_for(p) if config.comments && p.comment != false
+        p.enum ||= model_plugin.enum_for(p) if p.enum != false
+      end
+    end
+
+    def infer_nested_property_types(prop)
+      return prop unless prop.nested_properties&.any?
+
+      typelizes = prop.nested_typelizes || {}
+      inferred = prop.nested_properties.map do |sub_prop|
+        dsl_type = typelizes[sub_prop.column_name.to_sym] || typelizes[sub_prop.name.to_sym]
+        sub_prop
+          .then { |p| dsl_type&.any? ? p.with(**dsl_type) : apply_model_inference(p) }
+          .then { |p| apply_metadata(p) }
+          .then { |p| infer_nested_property_types(p) }
+      end
+
+      prop.with(nested_properties: inferred)
+    end
+
+    def model_class
+      return serializer._typelizer_model_name if serializer.respond_to?(:_typelizer_model_name)
+
+      config.instance_exec(serializer, &config.serializer_model_mapper)
+    rescue NameError => e
+      Typelizer.logger.debug("model_mapper failed for serializer #{serializer.name}: #{e.class}: #{e.message}")
+
+      nil
+    end
+
+    def model_plugin
+      @model_plugin ||= config.model_plugin.new(model_class: model_class, config: config)
+    end
+  end
+end

data/lib/typelizer/type_parser.rb

@@ -14,6 +14,8 @@ module Typelizer
         return options if type_def.nil?
 
         type_str = type_def.to_s
+        return parse_union(type_str, **options) if type_str.include?("|")
+
         match = TYPE_PATTERN.match(type_str)
 
         return {type: type_def}.merge(options) unless match
@@ -34,6 +36,18 @@ module Typelizer
         type_str = type_def.to_s
         type_str.end_with?("?", "[]")
       end
+
+      private
+
+      def parse_union(type_str, **options)
+        parts = type_str.split(/\s*\|\s*/)
+        options[:nullable] = true if parts.delete("null")
+        if parts.size == 1
+          parse(parts.first, **options)
+        else
+          {type: parts.map(&:to_sym)}.merge(options)
+        end
+      end
     end
   end
 end

data/lib/typelizer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Typelizer
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/typelizer.rb

@@ -72,7 +72,14 @@ module Typelizer
     end
 
     def openapi_schemas(writer_name: nil, openapi_version: "3.0")
-      interfaces(writer_name: writer_name).to_h { |i| [i.name, OpenAPI.schema_for(i, openapi_version: openapi_version)] }
+      result = {}
+      interfaces(writer_name: writer_name).each do |i|
+        result[i.name] = OpenAPI.schema_for(i, openapi_version: openapi_version)
+        i.trait_interfaces.each do |trait|
+          result[trait.name] = OpenAPI.schema_for(trait, openapi_version: openapi_version)
+        end
+      end
+      result
     end
 
     private
@@ -85,7 +92,10 @@ module Typelizer
       resolved = base_classes.filter_map do |base_class|
         Object.const_get(base_class) if Object.const_defined?(base_class)
       end
-      raise ArgumentError, "No serializers found. Please ensure all your serializers include Typelizer::DSL." if base_classes.any? && resolved.none?
+      if base_classes.any? && resolved.none?
+        logger.warn("Typelizer: No serializers found. Ensure your serializers include Typelizer::DSL.")
+        return []
+      end
 
       (resolved + resolved.flat_map(&:descendants)).uniq
         .reject { |serializer| reject_class.call(serializer: serializer) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typelizer
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Svyatoslav Kryukov
@@ -72,7 +72,7 @@ files:
 - lib/typelizer/renderer.rb
 - lib/typelizer/serializer_config_layer.rb
 - lib/typelizer/serializer_plugins/alba.rb
-- lib/typelizer/serializer_plugins/alba/trait_attribute_collector.rb
+- lib/typelizer/serializer_plugins/alba/block_attribute_collector.rb
 - lib/typelizer/serializer_plugins/alba/trait_interface.rb
 - lib/typelizer/serializer_plugins/ams.rb
 - lib/typelizer/serializer_plugins/auto.rb
@@ -86,6 +86,7 @@ files:
 - lib/typelizer/templates/inheritance.ts.erb
 - lib/typelizer/templates/inline_type.ts.erb
 - lib/typelizer/templates/interface.ts.erb
+- lib/typelizer/type_inference.rb
 - lib/typelizer/type_parser.rb
 - lib/typelizer/union_type_sorter.rb
 - lib/typelizer/version.rb