typelizer 0.4.1 → 0.5.0

data/lib/typelizer/contexts/writer_context.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Typelizer
+  # Context for a single writer during a generation pass.
+  # - Caches one Interface per serializer class (prevents duplicates/loops)
+  # - Computes per-serializer effective Config:
+  #   library defaults < global (flat setters) < writer < DSL (parent → child)
+  class WriterContext
+    attr_reader :writer_config, :writer_name
+
+    def initialize(writer_name: nil, configuration: Typelizer.configuration)
+      @configuration = configuration
+      @writer_name = (writer_name || Configuration::DEFAULT_WRITER_NAME).to_sym
+      @writer_config = configuration.writer_config(@writer_name)
+
+      @interface_cache = {}
+      @config_cache = {}
+      @dsl_cache = {}
+    end
+
+    # Returns a memoized Interface for the given serializer class within this writer context
+    # Guarantees a single Interface instance per serializer (in this context), which:
+    # - preserves object identity across associations,
+    # - prevents infinite loops on cyclic relations,
+    # - and avoids redundant recomputation
+    # The cache is scoped to WriterContext (i.e., per writer and per generation run)
+    def interface_for(serializer_class)
+      raise ArgumentError, "Serializer class cannot be nil" if serializer_class.nil?
+
+      @interface_cache[serializer_class] ||= Interface.new(
+        serializer: serializer_class,
+        context: self
+      )
+    end
+
+    # Resolves the effective configuration for a serializer class by merging
+    # configuration layers in priority order:
+    #  Library defaults
+    #  Global configuration settings
+    #  Writer-specific configuration
+    #  DSL configuration with inheritance (highest priority)
+    def config_for(serializer_class)
+      raise ArgumentError, "Serializer class cannot be nil" unless serializer_class
+
+      @config_cache[serializer_class] ||= build_config(serializer_class)
+    end
+
+    private
+
+    # Builds the correct configuration by merging all configuration layers
+    def build_config(serializer_class)
+      global_settings = @configuration.global_settings
+      writer_settings = @writer_config.to_h
+      dsl_settings = dsl_config_for(serializer_class)
+
+      # Merge in priority order: global < writer < DSL
+      merged_config = deep_merge(global_settings, writer_settings)
+      merged_config = deep_merge(merged_config, dsl_settings)
+
+      Config.build(**merged_config).freeze
+    end
+
+    def dsl_config_for(klass)
+      return @dsl_cache[klass] if @dsl_cache.key?(klass)
+
+      # Recursively get the parent's DSL config. If no parent or parent is not
+      # a Typelizer serializer, the base is an empty hash.
+      parent_dsl = (parent = klass.superclass).respond_to?(:typelizer_config) ? dsl_config_for(parent) : {}
+
+      # Get this class's own local overrides.
+      local_dsl = klass.respond_to?(:typelizer_config) ? klass.typelizer_config.to_h : {}
+
+      @dsl_cache[klass] = deep_merge(parent_dsl, local_dsl).freeze
+    end
+
+    def deep_merge(hash_one, hash_two)
+      # If Active Support's `deep_merge` exists, use it
+      return hash_one.deep_merge(hash_two) if hash_one.respond_to?(:deep_merge)
+
+      return hash_one if hash_one == hash_two
+      return hash_one if hash_two.empty?
+      return hash_two if hash_one.empty?
+
+      hash_one.merge(hash_two) do |_, old_v, new_v|
+        (old_v.is_a?(Hash) && new_v.is_a?(Hash)) ? deep_merge(old_v, new_v) : new_v
+      end
+    end
+  end
+end

data/lib/typelizer/dsl.rb

@@ -14,18 +14,16 @@ module Typelizer
     end
 
     module ClassMethods
-      def typelizer_config
-        @typelizer_config ||=
-          begin
-            parent_config = superclass.respond_to?(:typelizer_config) ? superclass.typelizer_config : Config
-            Config.new(parent_config.to_h.transform_values(&:dup))
-          end
-        yield @typelizer_config if block_given?
-        @typelizer_config
-      end
+      def typelizer_config(&block)
+        # Lazily initializes and memoizes the hash for local overrides at the class level.
+        # This ensures that all subsequent DSL calls for this specific serializer class
+        # modify the same single hash, allowing settings to be accumulated
+        @serializer_overrides ||= {}
+
+        @config_layer ||= SerializerConfigLayer.new(@serializer_overrides)
+        @config_layer.instance_eval(&block) if block
 
-      def typelizer_interface
-        @typelizer_interface ||= Interface.new(serializer: self)
+        @config_layer
       end
 
       # save association of serializer to model

data/lib/typelizer/generator.rb

@@ -6,24 +6,26 @@ module Typelizer
       new.call(**args)
     end
 
-    def initialize(config = Typelizer::Config)
-      @config = config
-      @writer = Writer.new
-    end
-
-    attr_reader :config, :writer
-
     def call(force: false)
-      return unless Typelizer.enabled?
+      return [] unless Typelizer.enabled?
 
-      found_interfaces = interfaces
-      writer.call(found_interfaces, force: force)
-      found_interfaces
-    end
+      # plugin scan per run cache
+      @scan_plugin_cache = {}
 
-    def interfaces
       read_serializers
-      target_serializers.map(&:typelizer_interface).reject(&:empty?)
+      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) }
+
+        Writer.new(writer_config).call(interfaces, force: force)
+      end
+
+      serializers
     end
 
     private
@@ -44,9 +46,10 @@ module Typelizer
       files ||= Typelizer.dirs.flat_map { |dir| Dir["#{dir}/**/*.rb"] }
       files.each do |file|
         trace = TracePoint.new(:call) do |tp|
-          next unless tp.self.is_a?(Class) && tp.self.respond_to?(:typelizer_interface) && tp.self.typelizer_interface.is_a?(Interface)
+          next unless tp.self.is_a?(Class) && tp.self.respond_to?(:typelizer_config)
 
-          serializer_plugin = tp.self.typelizer_interface.serializer_plugin
+          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
@@ -61,5 +64,22 @@ module Typelizer
         trace.disable
       end
     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/interface.rb

@@ -1,14 +1,22 @@
 module Typelizer
   class Interface
-    attr_reader :serializer, :serializer_plugin
+    attr_reader :serializer, :context
+
+    def initialize(serializer:, context:)
+      @serializer = serializer
+      @context = context
+    end
 
     def config
-      serializer.typelizer_config
+      context.config_for(serializer)
     end
 
-    def initialize(serializer:)
-      @serializer = serializer
-      @serializer_plugin = config.serializer_plugin.new(serializer: serializer, config: config)
+    def serializer_plugin
+      @serializer_plugin ||= config.serializer_plugin.new(
+        serializer: serializer,
+        config: config,
+        context: context
+      )
     end
 
     def inline?
@@ -69,12 +77,14 @@ module Typelizer
 
     def parent_interface
       return if config.inheritance_strategy == :none
-      return unless serializer.superclass.respond_to?(:typelizer_interface)
 
-      interface = serializer.superclass.typelizer_interface
-      return if interface.empty?
+      parent_class = serializer.superclass
+      return unless parent_class.respond_to?(:typelizer_config)
+
+      parent_interface = context.interface_for(parent_class)
+      return if parent_interface.empty?
 
-      interface
+      parent_interface
     end
 
     def imports
@@ -140,8 +150,12 @@ module Typelizer
     def model_class
       return serializer._typelizer_model_name if serializer.respond_to?(:_typelizer_model_name)
 
-      config.serializer_model_mapper.call(serializer)
-    rescue NameError
+      # 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
 

data/lib/typelizer/model_plugins/active_record.rb

@@ -9,33 +9,61 @@ module Typelizer
       attr_reader :model_class, :config
 
       def infer_types(prop)
-        if (association = model_class&.reflect_on_association(prop.column_name.to_sym))
-          case association.macro
-          when :belongs_to
-            foreign_key = association.foreign_key
-            column = model_class&.columns_hash&.dig(foreign_key.to_s)
-            if config.associations_strategy == :database
-              prop.nullable = column.null if column
-            elsif config.associations_strategy == :active_record
-              prop.nullable = association.options[:optional] === true || association.options[:required] === false
-            else
-              raise "Unknown associations strategy: #{config.associations_strategy}"
-            end
-          when :has_one
-            if config.associations_strategy == :database
-              prop.nullable = true
-            elsif config.associations_strategy == :active_record
-              prop.nullable = !association.options[:required]
-            else
-              raise "Unknown associations strategy: #{config.associations_strategy}"
-            end
+        infer_types_for_association(prop) ||
+          infer_types_for_column(prop) ||
+          infer_types_for_attribute(prop)
+
+        prop
+      end
+
+      def comment_for(prop)
+        column = model_class&.columns_hash&.dig(prop.column_name.to_s)
+        return nil unless column
+
+        prop.comment = column.comment
+      end
+
+      def enum_for(prop)
+        return unless model_class&.defined_enums&.key?(prop.column_name.to_s)
+
+        prop.enum = model_class.defined_enums[prop.column_name.to_s].keys
+      end
+
+      private
+
+      def infer_types_for_association(prop)
+        association = model_class&.reflect_on_association(prop.column_name.to_sym)
+        return nil unless association
+
+        case association.macro
+        when :belongs_to
+          foreign_key = association.foreign_key
+          column = model_class&.columns_hash&.dig(foreign_key.to_s)
+          if config.associations_strategy == :database
+            prop.nullable = column.null if column
+          elsif config.associations_strategy == :active_record
+            prop.nullable = association.options[:optional] === true || association.options[:required] === false
+          else
+            raise "Unknown associations strategy: #{config.associations_strategy}"
+          end
+        when :has_one
+          if config.associations_strategy == :database
+            prop.nullable = true
+          elsif config.associations_strategy == :active_record
+            prop.nullable = !association.options[:required]
+          else
+            raise "Unknown associations strategy: #{config.associations_strategy}"
           end
-          return prop
         end
 
+        prop
+      end
+
+      def infer_types_for_column(prop)
         column = model_class&.columns_hash&.dig(prop.column_name.to_s)
-        return prop unless column
+        return nil unless column
 
+        column = model_class&.columns_hash&.dig(prop.column_name.to_s)
         prop.multi = !!column.try(:array)
         case config.null_strategy
         when :nullable
@@ -57,17 +85,20 @@ module Typelizer
         prop
       end
 
-      def comment_for(prop)
-        column = model_class&.columns_hash&.dig(prop.column_name.to_s)
-        return nil unless column
+      def infer_types_for_attribute(prop)
+        return nil unless model_class.respond_to?(:attribute_types)
 
-        prop.comment = column.comment
-      end
+        attribute_type_obj = model_class.attribute_types[prop.column_name.to_s]
+        return nil unless attribute_type_obj
 
-      def enum_for(prop)
-        return unless model_class&.defined_enums&.key?(prop.column_name.to_s)
+        if attribute_type_obj.respond_to?(:subtype)
+          prop.type = @config.type_mapping[attribute_type_obj.subtype.type]
+          prop.multi = true
+        elsif attribute_type_obj.respond_to?(:type)
+          prop.type = @config.type_mapping[attribute_type_obj.type]
+        end
 
-        prop.enum = model_class.defined_enums[prop.column_name.to_s].keys
+        prop
       end
     end
   end

data/lib/typelizer/property.rb

@@ -26,8 +26,9 @@ module Typelizer
     def fingerprint
       props = to_h
       props[:type] = type_name
-      props = props.filter_map { |k, v| "#{k}=#{v.inspect}" unless v.nil? }
-      "<#{self.class.name} #{props.join(" ")}>"
+      props.each_with_object(+"<#{self.class.name}") do |(k, v), fp|
+        fp << " #{k}=#{v.inspect}" unless v.nil?
+      end << ">"
     end
 
     private

data/lib/typelizer/serializer_config_layer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Typelizer
+  # SerializerConfigLayer
+  #
+  # Lightweight, validated container for per-serializer overrides defined via the DSL.
+  #
+  # - Backed by a plain Hash for cheap deep-merge later (see WriterContext).
+  # - Only keys from Config.members are allowed; unknown keys raise NoMethodError.
+  # - Supports flat setters/getters in the DSL (e.g., c.null_strategy = :nullable_and_optional).
+  # - Mutable only via the DSL; #to_h returns a frozen hash to prevent external mutation.
+  #
+  # Rationale: we don't allocate another Config here; this layer is merged on top of
+  # library/global/writer settings when computing the effective config.
+  class SerializerConfigLayer
+    VALID_KEYS = Config.members.to_set
+
+    def initialize(target_hash)
+      @target_hash = target_hash
+    end
+
+    def to_h
+      @target_hash.dup.freeze
+    end
+
+    private
+
+    def method_missing(name, *args)
+      name = name.to_s
+      key = name.chomp("=").to_sym
+
+      raise NoMethodError, "Unknown configuration key: '#{key}'" unless VALID_KEYS.include?(key)
+
+      return @target_hash[key] = args.first if name.end_with?("=") && args.length == 1
+
+      return @target_hash[key] if args.empty?
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      VALID_KEYS.include?(name.to_s.chomp("=").to_sym) || super
+    end
+  end
+end

data/lib/typelizer/serializer_plugins/alba.rb

@@ -92,13 +92,14 @@ module Typelizer
           )
         when ::Alba::Association
           resource = attr.instance_variable_get(:@resource)
+
           Property.new(
             name: name,
-            type: Interface.new(serializer: resource),
+            type: context.interface_for(resource),
             optional: false,
             nullable: false,
             multi: false, # we override this in typelize_method_transform
-            column_name: column_name,
+            column_name: attr.name.is_a?(Symbol) ? attr.name.name : attr.name,
             **options
           )
         when ::Alba::TypedAttribute

data/lib/typelizer/serializer_plugins/ams.rb

@@ -18,7 +18,7 @@ module Typelizer
 
       def properties
         serializer._attributes_data.merge(serializer._reflections).flat_map do |key, association|
-          type = association.options[:serializer] ? Interface.new(serializer: association.options[:serializer]) : nil
+          type = association.options[:serializer] ? context.interface_for(association.options[:serializer]) : nil
           adapter = ActiveModelSerializers::Adapter.configured_adapter
           Property.new(
             name: adapter.transform_key_casing!(key.to_s, association.options),

data/lib/typelizer/serializer_plugins/auto.rb

@@ -2,8 +2,8 @@ module Typelizer
   module SerializerPlugins
     module Auto
       class << self
-        def new(serializer:, config:)
-          plugin(serializer).new(serializer: serializer, config: config)
+        def new(serializer:, config:, context:)
+          plugin(serializer).new(serializer: serializer, config: config, context: context)
         end
 
         def plugin(serializer)

data/lib/typelizer/serializer_plugins/base.rb

@@ -1,9 +1,10 @@
 module Typelizer
   module SerializerPlugins
     class Base
-      def initialize(serializer:, config:)
+      def initialize(serializer:, config:, context:)
         @serializer = serializer
         @config = config
+        @context = context
       end
 
       def root_key
@@ -28,7 +29,7 @@ module Typelizer
 
       private
 
-      attr_reader :serializer, :config
+      attr_reader :serializer, :config, :context
     end
   end
 end

data/lib/typelizer/serializer_plugins/oj_serializers.rb

@@ -18,9 +18,9 @@ module Typelizer
         attributes
           .flat_map do |key, options|
             if options[:association] == :flat
-              Interface.new(serializer: options.fetch(:serializer)).properties
+              context.interface_for(options.fetch(:serializer)).properties
             else
-              type = options[:serializer] ? Interface.new(serializer: options[:serializer]) : options[:type]
+              type = options[:serializer] ? context.interface_for(options[:serializer]) : options[:type]
               Property.new(
                 name: key,
                 type: type,

data/lib/typelizer/serializer_plugins/panko.rb

@@ -48,7 +48,7 @@ module Typelizer
       def association_property(assoc, multi: false)
         key = assoc.name_str
         serializer = assoc.descriptor.type
-        type = serializer ? Interface.new(serializer: serializer) : nil
+        type = serializer ? context.interface_for(serializer) : nil
         Property.new(
           name: key,
           type: type,

data/lib/typelizer/version.rb

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

data/lib/typelizer/writer.rb

@@ -4,27 +4,51 @@ require "fileutils"
 
 module Typelizer
   class Writer
-    def initialize
+    class WriterError < StandardError; end
+
+    def initialize(config)
       @template_cache = {}
-      @config = Config
+      @config = config
     end
 
-    attr_reader :config, :template_cache
-
     def call(interfaces, force:)
       cleanup_output_dir if force
 
-      written_files = interfaces.map { |interface| write_interface(interface) }
-      written_files << write_index(interfaces)
+      valid_interfaces = interfaces.reject(&:empty?)
+      return [] if valid_interfaces.empty?
 
-      existing_files = Dir[File.join(config.output_dir, "**/*.ts")]
-      files_to_delete = existing_files - written_files
+      written_files = []
+
+      begin
+        written_files.concat(valid_interfaces.map { |interface| write_interface(interface) })
 
-      File.delete(*files_to_delete) unless files_to_delete.empty?
+        written_files << write_index(valid_interfaces)
+
+        cleanup_stale_files(written_files) unless force
+
+        Typelizer.logger.debug("Generated #{written_files.size} TypeScript files in #{config.output_dir}")
+
+        written_files
+      rescue => e
+        # if during the file generations an error appears, we remove generated files
+        cleanup_partial_writes(written_files)
+        raise WriterError, "Failed to write TypeScript files (#{e.class}): #{e.message}"
+      end
     end
 
     private
 
+    attr_reader :config, :template_cache
+
+    def cleanup_stale_files(written_files)
+      return unless File.directory?(config.output_dir)
+
+      existing_files = Dir[File.join(config.output_dir, "**/*.ts")]
+      stale_files = existing_files - written_files
+
+      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)
@@ -60,5 +84,9 @@ module Typelizer
     def cleanup_output_dir
       FileUtils.rm_rf(config.output_dir)
     end
+
+    def cleanup_partial_writes(partial_files)
+      File.delete(*partial_files) unless partial_files.empty?
+    end
   end
 end

data/lib/typelizer.rb

@@ -1,16 +1,22 @@
 # frozen_string_literal: true
 
 require_relative "typelizer/version"
-require_relative "typelizer/config"
 require_relative "typelizer/property"
+require_relative "typelizer/model_plugins/auto"
+require_relative "typelizer/serializer_plugins/auto"
+
+require_relative "typelizer/config"
+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/interface"
 require_relative "typelizer/renderer"
 require_relative "typelizer/writer"
 require_relative "typelizer/generator"
-
 require_relative "typelizer/dsl"
 
-require_relative "typelizer/serializer_plugins/auto"
 require_relative "typelizer/serializer_plugins/oj_serializers"
 require_relative "typelizer/serializer_plugins/alba"
 require_relative "typelizer/serializer_plugins/ams"
@@ -18,30 +24,39 @@ require_relative "typelizer/serializer_plugins/panko"
 
 require_relative "typelizer/model_plugins/active_record"
 require_relative "typelizer/model_plugins/poro"
-require_relative "typelizer/model_plugins/auto"
 
 require_relative "typelizer/railtie" if defined?(Rails)
 
 require "logger"
+require "forwardable"
 
 module Typelizer
   class << self
+    extend Forwardable
+
+    # readers
+    def_delegators :configuration, :dirs, :reject_class, :listen, :writer
+
+    # writers
+    def_delegators :configuration, :dirs=, :reject_class=, :listen=
+
     def enabled?
       return false if ENV["DISABLE_TYPELIZER"] == "true" || ENV["DISABLE_TYPELIZER"] == "1"
 
       ENV["RAILS_ENV"] == "development" || ENV["RACK_ENV"] == "development" || ENV["DISABLE_TYPELIZER"] == "false"
     end
 
-    attr_accessor :dirs
-    attr_accessor :reject_class
     attr_accessor :logger
-    attr_accessor :listen
 
     # @private
     attr_reader :base_classes
 
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
     def configure
-      yield Config
+      yield configuration
     end
 
     private
@@ -50,10 +65,7 @@ module Typelizer
   end
 
   # Set in the Railtie
-  self.dirs = []
-  self.reject_class = ->(serializer:) { false }
   self.logger = Logger.new($stdout, level: :info)
-  self.listen = nil
 
   self.base_classes = Set.new
 end