typelizer 0.5.6 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1c1d02eab4c7f1ea170ecd4b855fa37952273faa3223333cd6f6f2020dad397
-  data.tar.gz: 519c348552314735af8c1ba5072a8cd7cbb492b822d0bf5564b95b965f42ff12
+  metadata.gz: 819c25a9bfc5dd74c3b7c77045bb5f5ef968f518f8a8d228502badb6936ea50d
+  data.tar.gz: c8d8d9affec2d6eb07cf1e58942fe46009fad2782c57689218b8357a85c227f0
 SHA512:
-  metadata.gz: e5d72c98f8ac58bba2a48673ec3f54e86e6aba2d25168312433d5288461aef7c1fd5d0d65aa2137759f03831c432aee5d9a2f5fc626068d302d295749d1f9ca7
-  data.tar.gz: 4134b806f9f788a32920dfb6ae8980b66083c7b22b897be3f3d005915fd5e444712fe12535a409c47c6d5cee4158f91696c11df7692f2ced26361bc169cd91d3
+  metadata.gz: b4b39192ff398bb25c6b537fcb5c73893de40d82f14a09a254e4ef8317a08232819c3285b7e6806938f1c7058f895d0100b03884574158bbaa2e329982518683
+  data.tar.gz: 8971c5a2cc78992fd38dc101e7b2fc1eaefe82ad756f828bca4416a4a6ed54d1ff25eace61fd80cd293cca3dc66b6b6c24706a0fa45156fb275eb9bfe4976c46

data/CHANGELOG.md

@@ -7,6 +7,43 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-01-15
+
+### Changed
+
+- Use DSL hooks instead of TracePoint for `typelize` method. ([@skryukov])
+
+### Fixed
+
+- Apply sorting and quote style configs consistently to all generated files. ([@jonmarkgo], [@skryukov])
+- Fix fingerprint calculations to include all config options. ([@skryukov])
+
+## [0.6.0] - 2026-01-14
+
+### Added
+
+- New `imports_sort_order` configuration option for consistent import ordering in generated TypeScript interfaces. ([@jonmarkgo])
+
+  ```ruby
+  Typelizer.configure do |config|
+    # Sort imports alphabetically
+    config.imports_sort_order = :alphabetical
+  end
+  ```
+
+  Available options:
+  - `:none` (default) - preserve original order
+  - `:alphabetical` - sort imports A-Z (case-insensitive)
+  - `Proc` - custom sorting logic
+
+### Changed
+
+- Rails enum attributes now generate named types (e.g., `PostCategory`) in a separate `Enums.ts` file instead of inline unions. ([@skryukov])
+
+### Fixed
+
+- Fix `index.ts` not being regenerated when traits are added or removed. ([@skryukov])
+
 ## [0.5.6] - 2026-01-12
 
 ### Added
@@ -309,6 +346,7 @@ and this project adheres to [Semantic Versioning].
 
 [@davidrunger]: https://github.com/davidrunger
 [@Envek]: https://github.com/Envek
+[@jonmarkgo]: https://github.com/jonmarkgo
 [@hkamberovic]: https://github.com/hkamberovic
 [@kristinemcbride]: https://github.com/kristinemcbride
 [@nkriege]: https://github.com/nkriege
@@ -320,7 +358,9 @@ and this project adheres to [Semantic Versioning].
 [@prog-supdex]: https://github.com/prog-supdex
 [@ventsislaf]: https://github.com/ventsislaf
 
-[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.5.6...HEAD
+[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.7.0...HEAD
+[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
 [0.5.6]: https://github.com/skryukov/typelizer/compare/v0.5.5...v0.5.6
 [0.5.5]: https://github.com/skryukov/typelizer/compare/v0.5.4...v0.5.5
 [0.5.4]: https://github.com/skryukov/typelizer/compare/v0.5.3...v0.5.4

data/README.md

@@ -493,6 +493,12 @@ Typelizer.configure do |config|
   # Proc - custom sorting function receiving array of Property objects
   config.properties_sort_order = :none
 
+  # Strategy for ordering imports in generated TypeScript interfaces
+  # :none - preserve original order (default)
+  # :alphabetical - sort imports A-Z (case-insensitive)
+  # Proc - custom sorting function receiving array of import strings
+  config.imports_sort_order = :none
+
   # Plugin for model type inference (default: ModelPlugins::Auto)
   config.model_plugin = Typelizer::ModelPlugins::Auto
 

data/lib/typelizer/config.rb

@@ -19,11 +19,46 @@ module Typelizer
 
   DEFAULT_TYPES_GLOBAL = %w[Array Date Record File FileList].freeze
 
+  # Config keys that affect generated file content and must be included in fingerprints.
+  # When adding a new config, add it here if it affects output, or to CONFIGS_NOT_AFFECTING_OUTPUT.
+  CONFIGS_AFFECTING_OUTPUT = %i[
+    types_import_path
+    types_global
+    prefer_double_quotes
+    comments
+    verbatim_module_syntax
+    imports_sort_order
+    properties_sort_order
+  ].freeze
+
+  # Subset of CONFIGS_AFFECTING_OUTPUT that specifically affect index.ts output.
+  CONFIGS_AFFECTING_INDEX_OUTPUT = %i[
+    verbatim_module_syntax
+    prefer_double_quotes
+    imports_sort_order
+  ].freeze
+
+  # Config keys that don't affect file content (runtime behavior, or effects captured via properties).
+  CONFIGS_NOT_AFFECTING_OUTPUT = %i[
+    serializer_name_mapper
+    serializer_model_mapper
+    properties_transformer
+    model_plugin
+    serializer_plugin
+    plugin_configs
+    type_mapping
+    null_strategy
+    output_dir
+    inheritance_strategy
+    associations_strategy
+  ].freeze
+
   Config = Struct.new(
     :serializer_name_mapper,
     :serializer_model_mapper,
     :properties_transformer,
     :properties_sort_order,
+    :imports_sort_order,
     :model_plugin,
     :serializer_plugin,
     :plugin_configs,
@@ -79,6 +114,7 @@ module Typelizer
         types_global: DEFAULT_TYPES_GLOBAL,
         properties_transformer: nil,
         properties_sort_order: :none,
+        imports_sort_order: :none,
         verbatim_module_syntax: false
       }
     end

data/lib/typelizer/dsl/hooks/alba.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module DSL
+    module Hooks
+      module Alba
+        include Methods
+        extend Builder
+
+        hook :attribute, :association, :one, :has_one
+        hook :nested_attribute, :nested, :meta
+        hook :many, :has_many, multi: true
+        hook_method_added
+      end
+    end
+  end
+end

data/lib/typelizer/dsl/hooks/ams.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module DSL
+    module Hooks
+      module AMS
+        include Methods
+        extend Builder
+
+        hook :attribute, :has_one, :belongs_to
+        hook :has_many, multi: true
+      end
+    end
+  end
+end

data/lib/typelizer/dsl/hooks/oj_serializers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module DSL
+    module Hooks
+      module OjSerializers
+        include Methods
+        extend Builder
+
+        hook :attribute, :has_one, :belongs_to, :flat_one
+        hook :has_many, multi: true
+      end
+    end
+  end
+end

data/lib/typelizer/dsl/hooks/panko.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module DSL
+    module Hooks
+      module Panko
+        include Methods
+        extend Builder
+
+        hook :has_one
+        hook :has_many, multi: true
+        hook_method_added
+      end
+    end
+  end
+end

data/lib/typelizer/dsl/hooks.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module DSL
+    module Hooks
+      def self.install(base)
+        # Always install hooks to capture multi associations.
+        # The hooks only record data to a Set, so overhead is minimal.
+        if defined?(::Alba::Resource) && base.ancestors.include?(::Alba::Resource)
+          require_relative "hooks/alba"
+          base.singleton_class.prepend(Alba)
+        elsif defined?(::ActiveModel::Serializer) && base.ancestors.include?(::ActiveModel::Serializer)
+          require_relative "hooks/ams"
+          base.singleton_class.prepend(AMS)
+        elsif defined?(::Oj::Serializer) && base.ancestors.include?(::Oj::Serializer)
+          require_relative "hooks/oj_serializers"
+          base.singleton_class.prepend(OjSerializers)
+        elsif defined?(::Panko::Serializer) && base.ancestors.include?(::Panko::Serializer)
+          require_relative "hooks/panko"
+          base.singleton_class.prepend(Panko)
+        end
+      end
+
+      # Shared methods available to all hook modules
+      module Methods
+        private
+
+        def consume_keyless_type(name)
+          return unless keyless_type
+
+          type, attrs = keyless_type
+          typelize(name => [type, attrs])
+          self.keyless_type = nil
+        end
+
+        def record_multi(name)
+          _own_typelizer_multi_attributes << name.to_sym
+        end
+      end
+
+      # DSL for defining hooks with less boilerplate
+      module Builder
+        def hook(*methods, multi: false)
+          methods.each do |method|
+            define_method(method) do |name = nil, *args, **kwargs, &block|
+              if name
+                record_multi(name) if multi
+                consume_keyless_type(name)
+              end
+              super(name, *args, **kwargs, &block)
+            end
+          end
+        end
+
+        def hook_method_added
+          define_method(:method_added) do |method_name|
+            consume_keyless_type(method_name)
+            super(method_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/typelizer/dsl.rb

@@ -1,3 +1,6 @@
+require "set"
+require_relative "dsl/hooks"
+
 module Typelizer
   module DSL
     # typelize_from Model
@@ -6,11 +9,13 @@ module Typelizer
     def self.included(base)
       Typelizer.base_classes << base.to_s if base.name
       base.extend(ClassMethods)
+      Hooks.install(base)
     end
 
     def self.extended(base)
       Typelizer.base_classes << base.to_s if base.name
       base.extend(ClassMethods)
+      Hooks.install(base)
     end
 
     module ClassMethods
@@ -49,6 +54,21 @@ module Typelizer
 
       attr_accessor :keyless_type
 
+      # Returns union of own + ancestors' multi attributes
+      def _typelizer_multi_attributes
+        result = @_typelizer_multi_attributes || Set.new
+        if superclass.respond_to?(:_typelizer_multi_attributes)
+          superclass._typelizer_multi_attributes | result
+        else
+          result
+        end
+      end
+
+      # Returns own Set (initializing if needed) for writing
+      def _own_typelizer_multi_attributes
+        @_typelizer_multi_attributes ||= Set.new
+      end
+
       def typelize_meta(**attributes)
         assign_type_information(:_typelizer_meta_attributes, attributes)
       end

data/lib/typelizer/generator.rb

@@ -9,15 +9,9 @@ module Typelizer
     def call(force: false)
       return [] unless Typelizer.enabled?
 
-      # plugin scan per run cache
-      @scan_plugin_cache = {}
-
-      read_serializers
+      load_serializers
       serializers = target_serializers
 
-      # For each writer, build a dedicated WriterContext. The context holds that writer's
-      # configuration and resolves the effective Config for every Interface (per serializer)
-      # by merging global, writer, and per-serializer (DSL) overrides
       Typelizer.configuration.writers.each do |writer_name, writer_config|
         context = WriterContext.new(writer_name: writer_name)
         interfaces = serializers.map { |klass| context.interface_for(klass) }
@@ -30,6 +24,12 @@ module Typelizer
 
     private
 
+    def load_serializers
+      Typelizer.dirs.flat_map { |dir| Dir["#{dir}/**/*.rb"] }.each do |file|
+        require file
+      end
+    end
+
     def target_serializers
       base_classes = Typelizer.base_classes.filter_map do |base_class|
         Object.const_get(base_class) if Object.const_defined?(base_class)
@@ -41,51 +41,5 @@ module Typelizer
         .reject { |serializer| Typelizer.reject_class.call(serializer: serializer) }
         .sort_by(&:name)
     end
-
-    def read_serializers(files = nil)
-      files ||= Typelizer.dirs.flat_map { |dir| Dir["#{dir}/**/*.rb"] }
-      files.each do |file|
-        trace = TracePoint.new(:call) do |tp|
-          next unless typelized_class?(tp.self)
-
-          serializer_plugin = build_scan_plugin_for(tp.self)
-          next unless serializer_plugin
-
-          if tp.callee_id.in?(serializer_plugin.methods_to_typelize)
-            type, attrs = tp.self.keyless_type
-            name = tp.binding.local_variable_get(:name) if tp.binding.local_variable_defined?(:name)
-            tp.self.typelize(**serializer_plugin.typelize_method_transform(method: tp.callee_id, binding: tp.binding, name: name, type: type, attrs: attrs || {}))
-            tp.self.keyless_type = nil
-          end
-        end
-
-        trace.enable
-        require file
-        trace.disable
-      end
-    end
-
-    def typelized_class?(klass)
-      klass.is_a?(Class) && klass.respond_to?(:typelizer_config)
-    rescue
-      false
-    end
-
-    # Builds a minimal plugin instance used only during scan time for TracePoint
-    def build_scan_plugin_for(serializer_klass)
-      return @scan_plugin_cache[serializer_klass] if @scan_plugin_cache&.key?(serializer_klass)
-
-      base = Typelizer.configuration.writer_config(:default)
-      local_configuration = serializer_klass.typelizer_config.to_h.slice(:serializer_plugin, :plugin_configs)
-      cfg = base.with_overrides(**local_configuration)
-
-      @scan_plugin_cache[serializer_klass] = cfg.serializer_plugin.new(
-        serializer: serializer_klass,
-        config: cfg,
-        context: Typelizer::ScanContext
-      )
-    rescue NameError
-      nil
-    end
   end
 end

data/lib/typelizer/import_sorter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Typelizer
+  module ImportSorter
+    def self.sort(imports, sort_order)
+      case sort_order
+      when :none, nil
+        imports
+      when :alphabetical
+        imports.sort_by { |i| i.to_s.downcase }
+      when Proc
+        result = sort_order.call(imports)
+        result.is_a?(Array) ? result : imports
+      else
+        imports
+      end
+    rescue => e
+      Typelizer.logger.warn("ImportSorter error: #{e.message}, preserving original order")
+      imports
+    end
+  end
+end

data/lib/typelizer/interface.rb

@@ -25,7 +25,7 @@ module Typelizer
 
     def name
       if inline?
-        Renderer.call("inline_type.ts.erb", properties: properties).strip
+        Renderer.call("inline_type.ts.erb", properties: properties, sort_order: config.properties_sort_order).strip
       else
         config.serializer_name_mapper.call(serializer).tr_s(":", "")
       end
@@ -58,6 +58,15 @@ module Typelizer
       @trait_interfaces ||= serializer_plugin.trait_interfaces
     end
 
+    def enum_types
+      @enum_types ||= begin
+        all_properties = properties + trait_interfaces.flat_map(&:properties)
+        all_properties
+          .select(&:enum_definition)
+          .uniq(&:enum_type_name)
+      end
+    end
+
     def properties
       @properties ||= begin
         props = serializer_plugin.properties
@@ -119,7 +128,11 @@ module Typelizer
           prop.with_traits.map { |t| "#{prop.type.name}#{t.to_s.camelize}Trait" }
         end
 
-        (custom_type_imports + serializer_types + trait_imports + Array(parent_interface&.name)).uniq - [self_type_name, name]
+        # Collect enum type names from properties
+        enum_imports = all_properties.filter_map(&:enum_type_name)
+
+        result = (custom_type_imports + serializer_types + trait_imports + enum_imports + Array(parent_interface&.name)).uniq - [self_type_name, name]
+        ImportSorter.sort(result, config.imports_sort_order)
       end
     end
 
@@ -128,12 +141,15 @@ module Typelizer
     end
 
     def fingerprint
-      if trait_interfaces.empty?
-        "<#{self.class.name} #{name} properties=[#{properties_to_print.map(&:fingerprint).join(", ")}]>"
-      else
-        traits_fingerprint = trait_interfaces.map { |t| "#{t.name}=[#{t.properties.map(&:fingerprint).join(", ")}]" }.join(", ")
-        "<#{self.class.name} #{name} properties=[#{properties_to_print.map(&:fingerprint).join(", ")}] traits=[#{traits_fingerprint}]>"
-      end
+      [
+        name,
+        properties_to_print.map(&:fingerprint),
+        parent_interface&.name,
+        root_key,
+        meta_fields.map(&:fingerprint),
+        trait_interfaces.map { |t| [t.name, t.properties.map(&:fingerprint)] },
+        CONFIGS_AFFECTING_OUTPUT.map { |key| config.public_send(key) }
+      ].inspect
     end
 
     def quote(str)
@@ -155,18 +171,41 @@ module Typelizer
     end
 
     def infer_types(props, hash_name = :_typelizer_attributes)
+      dsl_attrs = serializer.respond_to?(hash_name) ? serializer.public_send(hash_name) : {}
+      multi_attrs = serializer.respond_to?(:_typelizer_multi_attributes) ? serializer._typelizer_multi_attributes : Set.new
+
       props.map do |prop|
-        if serializer.respond_to?(hash_name)
-          dsl_type = serializer.public_send(hash_name)[prop.column_name.to_sym]
-          if dsl_type&.any?
-            next Property.new(prop.to_h.merge(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
-        end
+        has_dsl = dsl_attrs[prop.column_name.to_sym]&.any?
+
+        prop
+          .then { |p| apply_dsl_type(p, dsl_attrs) }
+          .then { |p| has_dsl ? p : apply_model_inference(p) }
+          .then { |p| apply_multi_flag(p, multi_attrs) }
+          .then { |p| apply_metadata(p) }
+      end
+    end
+
+    def apply_dsl_type(prop, dsl_attrs)
+      dsl_type = dsl_attrs[prop.column_name.to_sym]
+      return prop unless dsl_type&.any?
+
+      prop.with(**dsl_type)
+    end
+
+    def apply_model_inference(prop)
+      model_plugin.infer_types(prop)
+    end
+
+    def apply_multi_flag(prop, multi_attrs)
+      return prop unless multi_attrs.include?(prop.column_name.to_sym)
+
+      prop.with(multi: true)
+    end
 
-        model_plugin.infer_types(prop)
+    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
 

data/lib/typelizer/model_plugins/active_record.rb

@@ -28,6 +28,8 @@ module Typelizer
         return unless model_class&.defined_enums&.key?(prop.column_name.to_s)
 
         prop.enum = model_class.defined_enums[prop.column_name.to_s].keys
+        prop.enum_type_name = "#{model_class.name.demodulize}#{prop.column_name.to_s.camelize}"
+        prop.enum
       end
 
       private

data/lib/typelizer/property.rb

@@ -1,10 +1,14 @@
 module Typelizer
   Property = Struct.new(
     :name, :type, :optional, :nullable,
-    :multi, :column_name, :comment, :enum, :deprecated,
+    :multi, :column_name, :comment, :enum, :enum_type_name, :deprecated,
     :with_traits,
     keyword_init: true
   ) do
+    def with(**attrs)
+      dup.tap { |p| attrs.each { |k, v| p[k] = v } }
+    end
+
     def inspect
       props = to_h.merge(type: type_name).map { |k, v| "#{k}=#{v.inspect}" }.join(" ")
       "<#{self.class.name} #{props}>"
@@ -16,8 +20,17 @@ module Typelizer
       fingerprint == other.fingerprint
     end
 
+    # Default to_s for backward compatibility (no sorting)
     def to_s
-      type_str = type_name
+      render(sort_order: :none)
+    end
+
+    # Renders the property as a TypeScript property string
+    # @param sort_order [Symbol, Proc, nil] Sort order for union types (:none, :alphabetical, or Proc)
+    # @param prefer_double_quotes [Boolean] Whether to use double quotes for string values
+    # @return [String] The property string like "name?: Type1 | Type2"
+    def render(sort_order: :none, prefer_double_quotes: false)
+      type_str = type_name(sort_order: sort_order, prefer_double_quotes: prefer_double_quotes)
 
       # Handle intersection types for traits
       if with_traits&.any? && type.respond_to?(:name)
@@ -26,23 +39,55 @@ module Typelizer
       end
 
       type_str = "Array<#{type_str}>" if multi
+
+      # Apply union sorting to the final type string (handles Array<...> unions too)
+      type_str = UnionTypeSorter.sort(type_str, sort_order)
+
+      # Add nullable at the end (null should always be last in sorted output)
       type_str = "#{type_str} | null" if nullable
 
       "#{name}#{"?" if optional}: #{type_str}"
     end
 
     def fingerprint
-      props = to_h
-      props[:type] = type_name
-      props.each_with_object(+"<#{self.class.name}") do |(k, v), fp|
-        fp << " #{k}=#{v.inspect}" unless v.nil?
-      end << ">"
+      # Use array format for consistent output across Ruby versions
+      # (Hash#inspect format changed in Ruby 3.4)
+      to_h.merge(type: UnionTypeSorter.sort(type_name(sort_order: :alphabetical), :alphabetical))
+        .to_a.inspect
+    end
+
+    # Generates a TypeScript type definition for named enums
+    # @param sort_order [Symbol, Proc, nil] Sort order for enum values (:none, :alphabetical, or Proc)
+    # @param prefer_double_quotes [Boolean] Whether to use double quotes for string values
+    # @return [String, nil] The type definition like "type UserRole = 'admin' | 'user'"
+    def enum_definition(sort_order: :none, prefer_double_quotes: false)
+      return unless enum && enum_type_name
+
+      values = enum.map { |v| quote_string(v.to_s, prefer_double_quotes) }
+      values = values.sort_by(&:downcase) if sort_order == :alphabetical
+      "type #{enum_type_name} = #{values.join(" | ")}"
     end
 
     private
 
-    def type_name
-      return enum.map { |v| v.to_s.inspect }.join(" | ") if enum
+    def quote_string(str, prefer_double_quotes)
+      prefer_double_quotes ? "\"#{str}\"" : "'#{str}'"
+    end
+
+    # Returns the type name, optionally sorting union members
+    # @param sort_order [Symbol, Proc, nil] Sort order for union types
+    # @param prefer_double_quotes [Boolean] Whether to use double quotes for string values
+    # @return [String] The type name
+    def type_name(sort_order: :none, prefer_double_quotes: false)
+      # If enum_type_name is set, use it (named enum type)
+      return enum_type_name if enum_type_name
+
+      if enum
+        # Sort enum values if alphabetical sorting is requested
+        enum_values = enum.map { |v| quote_string(v.to_s, prefer_double_quotes) }
+        enum_values = enum_values.sort_by(&:downcase) if sort_order == :alphabetical
+        return enum_values.join(" | ")
+      end
 
       type.respond_to?(:name) ? type.name : type || "unknown"
     end

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

@@ -36,7 +36,7 @@ module Typelizer
           # First check for typelize DSL in the trait
           dsl_type = typelizes[prop.column_name.to_sym]
           if dsl_type&.any?
-            next Property.new(prop.to_h.merge(dsl_type)).tap do |property|
+            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

data/lib/typelizer/serializer_plugins/alba.rb

@@ -17,29 +17,6 @@ module Typelizer
         end
       end
 
-      def methods_to_typelize
-        [
-          :association, :one, :has_one,
-          :many, :has_many,
-          :attributes, :attribute,
-          :method_added,
-          :nested_attribute, :nested,
-          :meta
-        ]
-      end
-
-      def typelize_method_transform(method:, name:, binding:, type:, attrs:)
-        if method == :method_added && binding.local_variable_defined?(:method_name)
-          name = binding.local_variable_get(:method_name)
-        end
-
-        if [:many, :has_many].include?(method)
-          return {name => [type, attrs.merge(multi: true)]}
-        end
-
-        super
-      end
-
       def root_key
         root = serializer.new({}).send(:_key)
         if !root.nil? && has_transform_key?(serializer) && should_transform_root_key?(serializer)

data/lib/typelizer/serializer_plugins/ams.rb

@@ -3,19 +3,6 @@ require_relative "base"
 module Typelizer
   module SerializerPlugins
     class AMS < Base
-      def methods_to_typelize
-        [
-          :has_many, :has_one, :belongs_to,
-          :attribute, :attributes
-        ]
-      end
-
-      def typelize_method_transform(method:, name:, binding:, type:, attrs:)
-        return {binding.local_variable_get(:attr) => [type, attrs]} if method == :attribute
-
-        super
-      end
-
       def properties
         serializer._attributes_data.merge(serializer._reflections).flat_map do |key, association|
           type = association.options[:serializer] ? context.interface_for(association.options[:serializer]) : nil

data/lib/typelizer/serializer_plugins/base.rb

@@ -15,14 +15,6 @@ module Typelizer
         nil
       end
 
-      def typelize_method_transform(method:, name:, binding:, type:, attrs:)
-        {name => [type, attrs]}
-      end
-
-      def methods_to_typelize
-        []
-      end
-
       def properties
         []
       end

data/lib/typelizer/serializer_plugins/oj_serializers.rb

@@ -3,13 +3,6 @@ require_relative "base"
 module Typelizer
   module SerializerPlugins
     class OjSerializers < Base
-      def methods_to_typelize
-        [
-          :has_many, :has_one, :belongs_to,
-          :flat_one, :attribute, :attributes
-        ]
-      end
-
       def properties
         transform_keys = serializer.try(:_transform_keys)
         attributes = serializer._attributes

data/lib/typelizer/serializer_plugins/panko.rb

@@ -3,10 +3,6 @@ require_relative "base"
 module Typelizer
   module SerializerPlugins
     class Panko < Base
-      def methods_to_typelize
-        [:has_many, :has_one, :attributes, :method_added]
-      end
-
       def properties
         descriptor = serializer.new.instance_variable_get(:@descriptor)
         attributes = descriptor.attributes
@@ -25,14 +21,6 @@ module Typelizer
         end
       end
 
-      def typelize_method_transform(method:, name:, binding:, type:, attrs:)
-        if method == :method_added && binding.local_variable_defined?(:method)
-          name = binding.local_variable_get(:method)
-        end
-
-        super
-      end
-
       private
 
       def attribute_property(att)

data/lib/typelizer/templates/enums.ts.erb

@@ -0,0 +1,3 @@
+<%- enums.each do |property| -%>
+export <%= property.enum_definition(sort_order: sort_order, prefer_double_quotes: prefer_double_quotes) %>;
+<%- end -%>

data/lib/typelizer/templates/index.ts.erb

@@ -1,7 +1,12 @@
+<%- if enums.any? -%>
+<%- enums_path = prefer_double_quotes ? '"./Enums"' : "'./Enums'" -%>
+export type { <%= ImportSorter.sort(enums.map(&:enum_type_name), imports_sort_order).join(", ") %> } from <%= enums_path %>
+<%- end -%>
 <%- interfaces.each do |interface| -%>
+<%- sorted_traits = ImportSorter.sort(interface.trait_interfaces.map(&:name), interface.config.imports_sort_order) -%>
 <%- if interface.config.verbatim_module_syntax -%>
-export type { <%= interface.name %><%= ", " + interface.trait_interfaces.map(&:name).join(", ") if interface.trait_interfaces.any? %> } from <%= interface.quote('./' + interface.filename) %>
+export type { <%= interface.name %><%= ", " + sorted_traits.join(", ") if sorted_traits.any? %> } from <%= interface.quote('./' + interface.filename) %>
 <%- else -%>
-export type { default as <%= interface.name %><%= ", " + interface.trait_interfaces.map(&:name).join(", ") if interface.trait_interfaces.any? %> } from <%= interface.quote('./' + interface.filename) %>
+export type { default as <%= interface.name %><%= ", " + sorted_traits.join(", ") if sorted_traits.any? %> } from <%= interface.quote('./' + interface.filename) %>
 <%- end -%>
 <%- end -%>

data/lib/typelizer/templates/inheritance.ts.erb

@@ -1 +1,5 @@
-<%= interface.overwritten_properties.any? ? "Omit<" : "" %><%= interface.parent_interface.name %><%= "[" + interface.quote(interface.parent_interface.root_key) + "]" if interface.parent_interface.root_key %><%= interface.overwritten_properties.any? ? ", " + interface.overwritten_properties.map { |pr| interface.quote(pr.name) }.join(' | ') + ">" : ""%>
+<%
+  omit_props = interface.overwritten_properties.map { |pr| interface.quote(pr.name) }
+  omit_props = omit_props.sort_by(&:downcase) if interface.config.properties_sort_order == :alphabetical
+-%>
+<%= interface.overwritten_properties.any? ? "Omit<" : "" %><%= interface.parent_interface.name %><%= "[" + interface.quote(interface.parent_interface.root_key) + "]" if interface.parent_interface.root_key %><%= interface.overwritten_properties.any? ? ", " + omit_props.join(' | ') + ">" : ""%>

data/lib/typelizer/templates/inline_type.ts.erb

@@ -1,5 +1,5 @@
 {
 <%- properties.each do |property| -%>
-<%= indent(property) %>;
+<%= indent(property.render(sort_order: sort_order || :none)) %>;
 <%- end -%>
 }

data/lib/typelizer/templates/interface.ts.erb

@@ -9,14 +9,14 @@ render("inheritance.ts.erb", interface: interface).strip if interface.parent_int
 <%= " & " if interface.parent_interface %>{
 <% interface.properties_to_print.each do |property| -%>
 <%= render("comment.ts.erb", interface: interface, property: property) -%>
-<%= indent(property) %>;
+<%= indent(property.render(sort_order: interface.config.properties_sort_order, prefer_double_quotes: interface.config.prefer_double_quotes)) %>;
 <% end -%>
 }
 <% end %><% if interface.root_key %>
 type <%= interface.name %> = {
 <%= indent(interface.root_key) %>: <%= interface.name %>Data;
 <% interface.meta_fields&.each do |property| -%>
-<%= indent(property) %>;
+<%= indent(property.render(sort_order: interface.config.properties_sort_order, prefer_double_quotes: interface.config.prefer_double_quotes)) %>;
 <% end -%>
 }
 <% end -%>
@@ -24,16 +24,17 @@ type <%= interface.name %> = {
 
 type <%= trait.name %> = {
 <% trait.properties.each do |property| -%>
-<%= indent(property) %>;
+<%= indent(property.render(sort_order: interface.config.properties_sort_order, prefer_double_quotes: interface.config.prefer_double_quotes)) %>;
 <% end -%>
 }
 <% end -%>
 
+<% sorted_trait_names = ImportSorter.sort(interface.trait_interfaces.map(&:name), interface.config.imports_sort_order) -%>
 <% if interface.config.verbatim_module_syntax -%>
-export type { <%= interface.name %><%= ", " + interface.trait_interfaces.map(&:name).join(", ") if interface.trait_interfaces.any? %> };
+export type { <%= interface.name %><%= ", " + sorted_trait_names.join(", ") if sorted_trait_names.any? %> };
 <% else -%>
 export default <%= interface.name %>;
-<% if interface.trait_interfaces.any? -%>
-export type { <%= interface.trait_interfaces.map(&:name).join(", ") %> };
+<% if sorted_trait_names.any? -%>
+export type { <%= sorted_trait_names.join(", ") %> };
 <% end -%>
 <% end -%>

data/lib/typelizer/union_type_sorter.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Typelizer
+  # Sorts union type members within TypeScript type strings.
+  # Handles types like "Type3 | Type1 | Type2" -> "Type1 | Type2 | Type3"
+  # Also handles complex nested types like "Array<Type3 | Type1>" -> "Array<Type1 | Type3>"
+  module UnionTypeSorter
+    # Sorts union type members in a type string
+    # @param type_str [String] The type string potentially containing unions
+    # @param sort_order [Symbol, Proc, nil] The sort order (:none, :alphabetical, or Proc)
+    # @return [String] The type string with sorted union members
+    def self.sort(type_str, sort_order)
+      return type_str if type_str.nil? || type_str.empty?
+
+      case sort_order
+      when :none, nil
+        type_str
+      when :alphabetical
+        sort_unions_alphabetically(type_str)
+      when Proc
+        result = sort_order.call(type_str)
+        result.is_a?(String) ? result : type_str
+      else
+        type_str
+      end
+    rescue => e
+      Typelizer.logger.warn("UnionTypeSorter error: #{e.message}, preserving original order")
+      type_str
+    end
+
+    # Sorts union members alphabetically while preserving structure
+    # @param type_str [String] The type string to sort
+    # @return [String] The sorted type string
+    def self.sort_unions_alphabetically(type_str)
+      # Handle the string by sorting unions at each level
+      # We need to be careful with nested generics like Array<A | B | C>
+
+      result = type_str.dup
+
+      # First, handle unions inside angle brackets (generics)
+      # Match content inside < > and sort unions within
+      result = result.gsub(/<([^<>]+)>/) do |match|
+        inner = Regexp.last_match(1)
+        sorted_inner = sort_simple_union(inner)
+        "<#{sorted_inner}>"
+      end
+
+      # Then handle any remaining top-level unions
+      # But avoid sorting if the string has unbalanced brackets
+      if balanced_brackets?(result)
+        result = sort_top_level_union(result)
+      end
+
+      result
+    end
+
+    # Sorts a simple union string (no nested generics)
+    # @param union_str [String] String like "Type3 | Type1 | Type2"
+    # @return [String] Sorted string like "Type1 | Type2 | Type3"
+    def self.sort_simple_union(union_str)
+      return union_str unless union_str.include?("|")
+
+      parts = split_union_members(union_str)
+      return union_str if parts.size <= 1
+
+      # Sort while preserving special cases:
+      # - 'null' should typically stay at the end
+      # - Keep the relative order of complex nested types
+      regular_parts, null_parts = parts.partition { |p| p.strip.downcase != "null" }
+
+      sorted_regular = regular_parts.sort_by { |p| p.strip.downcase }
+      (sorted_regular + null_parts).join(" | ")
+    end
+
+    # Sorts top-level union (handles cases where unions aren't inside generics)
+    # @param type_str [String] The type string
+    # @return [String] The sorted type string
+    def self.sort_top_level_union(type_str)
+      return type_str unless type_str.include?("|")
+
+      parts = split_union_members(type_str)
+      return type_str if parts.size <= 1
+
+      # Separate null from other types
+      regular_parts, null_parts = parts.partition { |p| p.strip.downcase != "null" }
+
+      sorted_regular = regular_parts.sort_by { |p| p.strip.downcase }
+      (sorted_regular + null_parts).join(" | ")
+    end
+
+    # Splits union members while respecting nested brackets
+    # @param str [String] The string to split
+    # @return [Array<String>] Array of union members
+    def self.split_union_members(str)
+      members = []
+      current = +""
+      depth = 0
+
+      str.each_char do |char|
+        case char
+        when "<", "("
+          depth += 1
+          current << char
+        when ">", ")"
+          depth -= 1
+          current << char
+        when "|"
+          if depth == 0
+            members << current.strip unless current.strip.empty?
+            current = +""
+          else
+            current << char
+          end
+        else
+          current << char
+        end
+      end
+
+      members << current.strip unless current.strip.empty?
+      members
+    end
+
+    # Checks if brackets are balanced in the string
+    # @param str [String] The string to check
+    # @return [Boolean] True if brackets are balanced
+    def self.balanced_brackets?(str)
+      angle_depth = 0
+      paren_depth = 0
+
+      str.each_char do |char|
+        case char
+        when "<"
+          angle_depth += 1
+        when ">"
+          angle_depth -= 1
+          return false if angle_depth < 0
+        when "("
+          paren_depth += 1
+        when ")"
+          paren_depth -= 1
+          return false if paren_depth < 0
+        end
+      end
+
+      angle_depth == 0 && paren_depth == 0
+    end
+  end
+end

data/lib/typelizer/version.rb

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

data/lib/typelizer/writer.rb

@@ -22,7 +22,10 @@ module Typelizer
       begin
         written_files.concat(valid_interfaces.map { |interface| write_interface(interface) })
 
-        written_files << write_index(valid_interfaces)
+        enums = collect_enums(valid_interfaces)
+        written_files << write_enums(enums) if enums.any?
+
+        written_files << write_index(valid_interfaces, enums: enums)
 
         cleanup_stale_files(written_files) unless force
 
@@ -49,9 +52,29 @@ module Typelizer
       File.delete(*stale_files) unless stale_files.empty?
     end
 
-    def write_index(interfaces)
-      write_file("index.ts", interfaces.map(&:filename).join) do
-        render_template("index.ts.erb", interfaces: interfaces)
+    def collect_enums(interfaces)
+      interfaces
+        .flat_map(&:enum_types)
+        .uniq(&:enum_type_name)
+        .sort_by(&:enum_type_name)
+    end
+
+    def write_enums(enums)
+      fingerprint = [enums.map(&:fingerprint), config.properties_sort_order, config.prefer_double_quotes].inspect
+      write_file("Enums.ts", fingerprint) do
+        render_template("enums.ts.erb", enums: enums, sort_order: config.properties_sort_order, prefer_double_quotes: config.prefer_double_quotes)
+      end
+    end
+
+    def write_index(interfaces, enums: [])
+      fingerprint = [
+        enums.map(&:enum_type_name),
+        interfaces.map { |i|
+          [i.name, i.filename, i.trait_interfaces.map(&:name), CONFIGS_AFFECTING_INDEX_OUTPUT.map { |key| i.config.public_send(key) }]
+        }
+      ].inspect
+      write_file("index.ts", fingerprint) do
+        render_template("index.ts.erb", interfaces: interfaces, enums: enums, imports_sort_order: config.imports_sort_order, prefer_double_quotes: config.prefer_double_quotes)
       end
     end
 

data/lib/typelizer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "typelizer/version"
+require_relative "typelizer/union_type_sorter"
 require_relative "typelizer/property"
 require_relative "typelizer/model_plugins/auto"
 require_relative "typelizer/serializer_plugins/auto"
@@ -10,8 +11,8 @@ require_relative "typelizer/configuration"
 require_relative "typelizer/serializer_config_layer"
 
 require_relative "typelizer/contexts/writer_context"
-require_relative "typelizer/contexts/scan_context"
 require_relative "typelizer/property_sorter"
+require_relative "typelizer/import_sorter"
 require_relative "typelizer/interface"
 require_relative "typelizer/renderer"
 require_relative "typelizer/writer"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typelizer
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.7.0
 platform: ruby
 authors:
 - Svyatoslav Kryukov
@@ -50,10 +50,15 @@ files:
 - lib/typelizer.rb
 - lib/typelizer/config.rb
 - lib/typelizer/configuration.rb
-- lib/typelizer/contexts/scan_context.rb
 - lib/typelizer/contexts/writer_context.rb
 - lib/typelizer/dsl.rb
+- lib/typelizer/dsl/hooks.rb
+- lib/typelizer/dsl/hooks/alba.rb
+- lib/typelizer/dsl/hooks/ams.rb
+- lib/typelizer/dsl/hooks/oj_serializers.rb
+- lib/typelizer/dsl/hooks/panko.rb
 - lib/typelizer/generator.rb
+- lib/typelizer/import_sorter.rb
 - lib/typelizer/interface.rb
 - lib/typelizer/listen.rb
 - lib/typelizer/model_plugins/active_record.rb
@@ -73,12 +78,14 @@ files:
 - lib/typelizer/serializer_plugins/oj_serializers.rb
 - lib/typelizer/serializer_plugins/panko.rb
 - lib/typelizer/templates/comment.ts.erb
+- lib/typelizer/templates/enums.ts.erb
 - lib/typelizer/templates/fingerprint.ts.erb
 - lib/typelizer/templates/index.ts.erb
 - lib/typelizer/templates/inheritance.ts.erb
 - lib/typelizer/templates/inline_type.ts.erb
 - lib/typelizer/templates/interface.ts.erb
 - lib/typelizer/type_parser.rb
+- lib/typelizer/union_type_sorter.rb
 - lib/typelizer/version.rb
 - lib/typelizer/writer.rb
 homepage: https://github.com/skryukov/typelizer

data/lib/typelizer/contexts/scan_context.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Typelizer
-  # Builds a minimal plugin used during scan time
-  class ScanContext
-    class InvalidOperationError < StandardError; end
-
-    # Interface creation is not available during DSL scanning phase (TracePoint)
-    def self.interface_for(serializer_class)
-      class_name = serializer_class&.name || "unknown class"
-      raise InvalidOperationError,
-        "Interface creation is not allowed during DSL scan (#{class_name})"
-    end
-
-    # just in case, if we call ScanContext like an object
-    def interface_for(serializer_class)
-      self.class.interface_for(serializer_class)
-    end
-  end
-end