typelizer 0.4.2 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a41914a150239acf4de1b43149a0bfaa81c9511a6a5434aa445cfc9dbf3ee343
-  data.tar.gz: 82d1616845d782c041466d8500453afb8052a3d4fd8ce4e6f63c045c41a19544
+  metadata.gz: fa25b7b1816ce597e18fd9914b7f9434a4f9cbc4e5e7dcb80c783850a0e3d99c
+  data.tar.gz: 882d39a7faffcec6d7911c646a5a82a5164be04943c5f109b3c245f03728bcb8
 SHA512:
-  metadata.gz: 1f51fef6373b00d177faceccebc84c87e22f428f684990aa3faa762a5cabca853cf609c7476f98cc34ce26d1737ace2f258c47099a23018755f3e595873009d1
-  data.tar.gz: fff6bc2ca1844cc45d7d7a2a6bf8ac269078243013acb4e83ead8a902936f62fcfd5e15a96fbcbb1289266c52f53446e4cb3fa74584eeef09ab86882eadcfc43
+  metadata.gz: c99a3bc8dd6bbeaeed50394963d5a7081ebf3d1d837c9fa0b3bff6e4bd822974c8953fa355b22b07539736f18f2f7cf7f998e1bb68bdb01785a18bc1a6e5e0b7
+  data.tar.gz: 7b041dc084316a0ce823150b32c6af5555abacf15aaa99f4a286eec87d4a7f5b7ada172dcf3b45735139574647c91e7e5fe722d5da0a1959305a4e87d093157d

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.5.1] - 2025-09-11
+
+### Fixed
+
+- Fix type inference when using virtual associations. ([@hkamberovic])
+
+## [0.5.0] - 2025-09-01
+
+### Added
+
+- Support for multiple output writers: emit several variants (e.g., snake_case and camelCase) in parallel. ([@prog-supdex])
+- Support for Rails' Attributes API. ([@skryukov])
+
 ## [0.4.2] - 2025-06-23
 
 ### Added
@@ -171,15 +184,20 @@ and this project adheres to [Semantic Versioning].
 
 [@davidrunger]: https://github.com/davidrunger
 [@Envek]: https://github.com/Envek
+[@hkamberovic]: https://github.com/hkamberovic
 [@kristinemcbride]: https://github.com/kristinemcbride
 [@nkriege]: https://github.com/nkriege
 [@NOX73]: https://github.com/NOX73
 [@okuramasafumi]: https://github.com/okuramasafumi
 [@patvice]: https://github.com/patvice
+[@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.4.2...HEAD
+[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.5.1...HEAD
+[0.5.1]: https://github.com/skryukov/typelizer/compare/v0.5.0...v0.5.1
+[0.5.0]: https://github.com/skryukov/typelizer/compare/v0.4.2...v0.5.0
 [0.4.2]: https://github.com/skryukov/typelizer/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/skryukov/typelizer/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/skryukov/typelizer/compare/v0.3.0...v0.4.0

data/README.md

@@ -2,7 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/typelizer.svg)](https://rubygems.org/gems/typelizer)
 
-Typelizer is a Ruby gem that automatically generates TypeScript interfaces from your Ruby serializers, bridging the gap between your Ruby backend and TypeScript frontend. It supports multiple serializer libraries and provides a flexible configuration system, making it easier to maintain type consistency across your full-stack application.
+Typelizer generates TypeScript types from your Ruby serializers. It supports multiple serializer libraries and a flexible, layered configuration model so you can keep your backend and frontend in sync without hand‑maintaining types.
 
 ## Table of Contents
 
@@ -16,8 +16,8 @@ Typelizer is a Ruby gem that automatically generates TypeScript interfaces from
   - [Automatic Generation in Development](#automatic-generation-in-development)
   - [Disabling Typelizer](#disabling-typelizer)
 - [Configuration](#configuration)
-  - [Global Configuration](#global-configuration)
-  - [Config Options](#config-options)
+  - [Global Configuration](#simple-configuration)
+  - [Writers (multiple outputs)](#defining-multiple-writers)
   - [Per-Serializer Configuration](#per-serializer-configuration)
 - [Credits](#credits)
 - [License](#license)
@@ -29,8 +29,10 @@ Typelizer is a Ruby gem that automatically generates TypeScript interfaces from
 ## Features
 
 - Automatic TypeScript interface generation
-- Support for multiple serializer libraries (`Alba`, `ActiveModel::Serializer`, `Oj::Serializer`, `Panko::Serializer`)
-- File watching and automatic regeneration in development
+- Infers types from database columns and associations, with support for the Attributes API
+- Supports multiple serializer libraries (`Alba`, `ActiveModel::Serializer`, `Oj::Serializer`, `Panko::Serializer`)
+- File watching with automatic regeneration in development
+- Multiple output writers: emit several variants (e.g., snake_case and camelCase) in parallel
 
 ## Installation
 
@@ -211,8 +213,6 @@ Sometimes we want to use Typelizer only with manual generation. To disable Typel
 
 ## Configuration
 
-### Global Configuration
-
 Typelizer provides several global configuration options:
 
 ```ruby
@@ -226,13 +226,159 @@ Typelizer.logger = Logger.new($stdout, level: :info)
 Typelizer.listen = nil
 ```
 
-### Config Options
+### Configuration Layers
+
+Typelizer uses a hierarchical system to resolve settings. Settings are applied in the following order of precedence, where higher numbers override lower ones:
+
+1.  **Per-Serializer Overrides**: Settings defined using `typelizer_config` directly within a serializer class. This layer has the highest priority.
+2.  **Writer-Specific Settings**: Settings defined within a `config.writer(:name) { ... }` block.
+3.  **Global Settings**: Application-wide settings defined by direct assignment (e.g., `config.comments = true`) within the `Typelizer.configure` block.
+4.  **Library Defaults**: The gem's built-in default values.
+
+### Simple Configuration (Single Output)
+
+For most apps, a single output is enough. All settings in an initializer apply to the `:default` writer and also act as a global baseline.
+
+- Settings like `dirs` are considered **Global** and establish a baseline for all writers.
+- Settings like `output_dir` or `comments` configure the implicit **`:default` writer**.
+
+```ruby
+# config/initializers/typelizer.rb
+Typelizer.configure do |config|
+  # This is a GLOBAL SETTING. It applies to ALL writers.
+  config.dirs = [Rails.root.join("app/serializers")]
+
+  # This setting configures the :default writer and ALSO acts as a global setting.
+  config.output_dir = "app/javascript/types/generated"
+  config.comments = true
+end
+```
+
+### Defining Multiple Writers
+
+The multi-writer system allows for the generation of multiple, distinct TypeScript outputs. Each output is managed by a named writer with an isolated configuration.
+
+
+#### Writer Inheritance Rules
+
+- By default, a new writer inherits its base settings from the Global Settings.
+- To inherit from another existing writer, use the `from:` option.
+
+
+**A Note on the :default Writer and Inheritance**
+- You usually do not need to declare `writer(:default)`. The implicit default writer automatically uses your global settings. 
+- Declare `writer(:default)` when you want to apply specific overrides to it that should not be inherited by other new writers. This provides a way to separate your application's global baseline from settings that are truly unique to the default output
+
+#### Example of the distinction:
+```ruby
+Typelizer.configure do |config|
+  # === Global Setting ===
+  # `comments: true` applies to :default and will be inherited by :camel_case.
+  config.comments = true
+
+  # === Default-Writer-Only Setting ===
+  # `prefer_double_quotes: true` applies ONLY to the :default writer.
+  # It is NOT a global setting and will NOT be inherited by :camel_case.
+  config.writer(:default) do |c|
+    c.prefer_double_quotes = true
+  end
+
+  # === New Writer Definition ===
+  config.writer(:camel_case) do |c|
+    c.output_dir = "app/javascript/types/camel_case"
+    # This writer inherits `comments: true` from globals.
+    # It does NOT inherit `prefer_double_quotes: true` from the :default writer's block.
+    # Its `prefer_double_quotes` will be `false` (the library default).
+  end
+end
+```
+
+#### Configuring Writers
+You can define writers either inside the configure block or directly on the Typelizer module.
+
+1. **Inside the configure block**
+
+This is the approach for keeping all configuration centralized.
+
+```ruby
+# config/initializers/typelizer.rb
+Typelizer.configure do |config|
+  # ... global settings ...
+
+  config.writer(:camel_case) do |c|
+    c.output_dir = "app/javascript/types/camel_case"
+    c.properties_transformer = ->(properties) { # ... transform ... }
+  end
+
+  config.writer(:admin, from: :camel_case) do |c|
+    c.output_dir = "app/javascript/types/admin"
+    c.null_strategy = :optional
+  end
+end
+```
+
+2. Top-Level Helper
+
+```ruby
+Typelizer.writer(:admin, from: :default) do |c|
+  c.output_dir = Rails.root.join("app/javascript/types/admin")
+  c.prefer_double_quotes = true
+end
+```
+
+#### Comprehensive Example
+This example configures three distinct outputs, demonstrating all inheritance mechanisms.
+
+```ruby
+# config/initializers/typelizer.rb
+Typelizer.configure do |config|
+  # === 1. Global Settings (Baseline for ALL writers) ===
+  config.comments = true
+  config.dirs = [Rails.root.join("app/serializers")]
+
+  # === 2. The :default writer (snake_case output) ===
+  config.writer(:default) do |c|
+    c.output_dir = "app/javascript/types/snake_case"
+  end
+
+  # === 3. A new :camel_case writer ===
+  # Inherits `comments: true` and `dirs` from the Global Settings.
+  config.writer(:camel_case) do |c|
+    c.output_dir = "app/javascript/types/camel_case"
+    c.properties_transformer = lambda do |properties|
+      properties.map { |prop| prop.with_overrides(name: prop.name.to_s.camelize(:lower)) }
+    end
+  end
+
+  # === 4. An "admin" writer that clones :camel_case ===
+  # Use `from:` to explicitly inherit another writer's complete configuration.
+  config.writer(:admin, from: :camel_case) do |c|
+    c.output_dir = "app/javascript/types/admin"
+    # This writer inherits the properties_transformer from :camel_case.
+    c.null_strategy = :optional
+  end
+end
+```
+
+### Per-serializer configuration
+
+Use `typelizer_config` within a serializer class to apply overrides with the highest possible priority. 
+These settings will supersede any conflicting settings from the active writer, global settings, or library defaults.
+
+```ruby
+class PostResource < ApplicationResource
+  typelizer_config do |c|
+    c.null_strategy = :nullable_and_optional
+    c.plugin_configs = { alba: { ts_mapper: { "UUID" => { type: :string } } } }
+  end
+end
+```
 
-`Typelizer::Config` offers fine-grained control over the gem's behavior. Here's a list of available options:
+### Option reference
 
 ```ruby
 Typelizer.configure do |config|
-  # Determines how serializer names are mapped to TypeScript interface names
+  # Name to type mapping for serializer classes
   config.serializer_name_mapper = ->(serializer) { ... }
 
   # Maps serializers to their corresponding model classes
@@ -290,20 +436,6 @@ Typelizer.configure do |config|
 end
 ```
 
-### Per-Serializer Configuration
-
-You can also configure Typelizer on a per-serializer basis:
-
-```ruby
-class PostResource < ApplicationResource
-  typelizer_config do |config|
-    config.type_mapping = config.type_mapping.merge(jsonb: "Record<string, undefined>", ... )
-    config.null_strategy = :nullable
-    # ...
-  end
-end
-```
-
 ## Credits
 
 Typelizer is inspired by [types_from_serializers](https://github.com/ElMassimo/types_from_serializers).

data/lib/typelizer/config.rb

@@ -1,19 +1,25 @@
+# frozen_string_literal: true
+
+require "pathname"
+
 module Typelizer
-  TYPE_MAPPING = {
+  TYPE_MAPPING = Hash.new(:unknown).update(
     boolean: :boolean,
     date: :string,
     datetime: :string,
+    time: :string,
     decimal: :number,
+    float: :number,
     integer: :number,
     string: :string,
     text: :string,
     citext: :string,
     uuid: :string
-  }.tap do |types|
-    types.default = :unknown
-  end
+  ).freeze
 
-  class Config < Struct.new(
+  DEFAULT_TYPES_GLOBAL = %w[Array Date Record File FileList].freeze
+
+  Config = Struct.new(
     :serializer_name_mapper,
     :serializer_model_mapper,
     :properties_transformer,
@@ -31,59 +37,71 @@ module Typelizer
     :comments,
     :prefer_double_quotes,
     keyword_init: true
-  ) do
-    class << self
-      def instance
-        @instance ||= new(
-          serializer_name_mapper: ->(serializer) do
-            return "" if serializer.name.nil?
-
-            serializer.name.ends_with?("Serializer") ? serializer.name&.delete_suffix("Serializer") : serializer.name&.delete_suffix("Resource")
-          end,
-          serializer_model_mapper: ->(serializer) do
-            base_class = serializer_name_mapper.call(serializer)
-            Object.const_get(base_class) if Object.const_defined?(base_class)
-          end,
-
-          model_plugin: ModelPlugins::Auto,
-          serializer_plugin: SerializerPlugins::Auto,
-          plugin_configs: {},
-
-          type_mapping: TYPE_MAPPING,
-          null_strategy: :nullable,
-          inheritance_strategy: :none,
-          associations_strategy: :database,
-          comments: false,
-          prefer_double_quotes: false,
-
-          output_dir: js_root.join("types/serializers"),
-
-          types_import_path: "@/types",
-          types_global: %w[Array Date Record File FileList],
-
-          properties_transformer: nil,
-          verbatim_module_syntax: false
-        )
-      end
-
-      private
-
-      def js_root
-        root_path = defined?(Rails) ? Rails.root : Pathname.pwd
-        js_root = defined?(ViteRuby) ? ViteRuby.config.source_code_dir : "app/javascript"
-        root_path.join(js_root)
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        Typelizer.respond_to?(name) ||
-          instance.respond_to?(name, include_private)
-      end
-
-      def method_missing(method, *args, &block)
-        return Typelizer.send(method, *args, &block) if Typelizer.respond_to?(method)
-        instance.send(method, *args, &block)
-      end
+  )
+
+  # Immutable configuration object for a single writer
+  #
+  # Use .build to construct from defaults, and #with_overrides to copy with overrides.
+  class Config
+    # Returns library defaults (built-in) for building a Config.
+    # This method creates a fresh Hash each time to avoid sharing mutable state
+    # across builds
+    def self.defaults
+      {
+        serializer_name_mapper: lambda do |serializer|
+          name = serializer.name.to_s
+
+          return name if name.empty?
+
+          # remove only the end of the line
+          name.sub(/(Serializer|Resource)\z/, "")
+        end,
+
+        serializer_model_mapper: lambda do |serializer|
+          base_class = serializer_name_mapper.call(serializer)
+          Object.const_get(base_class) if Object.const_defined?(base_class)
+        end,
+
+        model_plugin: ModelPlugins::Auto,
+        serializer_plugin: SerializerPlugins::Auto,
+        plugin_configs: {}.freeze,
+        type_mapping: TYPE_MAPPING,
+        null_strategy: :nullable,
+        inheritance_strategy: :none,
+        associations_strategy: :database,
+        comments: false,
+        prefer_double_quotes: false,
+
+        output_dir: -> { default_output_dir },
+
+        types_import_path: "@/types",
+        types_global: DEFAULT_TYPES_GLOBAL,
+        properties_transformer: nil,
+        verbatim_module_syntax: false
+      }
+    end
+
+    def self.build(**overrides)
+      new(**defaults.merge(overrides))
+    end
+
+    def self.default_output_dir
+      root_path = defined?(Rails) ? Rails.root : Pathname.pwd
+      js_root = defined?(ViteRuby) ? ViteRuby.config.source_code_dir : "app/javascript"
+
+      root_path.join(js_root, "types/serializers")
+    end
+
+    def with_overrides(**overrides)
+      props = to_h
+      props.merge!(overrides) unless overrides.empty?
+
+      self.class.new(**props)
+    end
+
+    def output_dir
+      v = self[:output_dir]
+      v.respond_to?(:call) ? v.call : v
     end
-  end
   end
 end

data/lib/typelizer/configuration.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "set"
+require "pathname"
+
+module Typelizer
+  # Central registry for Typelizer multi-writer configuration
+  #
+  # Responsibilities:
+  # - Holds immutable Config per writer name (always includes :default)
+  # - Maintain flat DSL setters for :default (e.g., config.output_dir = ...)
+  # - Allows defining/updating named writers via writer(:name) { |cfg| ... }
+  # - Check unique output_dir across writers to avoid file conflicts
+  #
+  # Config priorities:
+  # - WriterContext merges in order: library defaults < global_settings < writer < DSL inheritance
+  # - global_settings are only updated by flat setters, not by writer(:default) blocks
+  class Configuration
+    DEFAULT_WRITER_NAME = :default
+
+    attr_accessor :dirs, :reject_class, :listen
+    attr_reader :writers, :global_settings
+
+    def initialize
+      @dirs = []
+      @reject_class = ->(serializer:) { false }
+      @listen = nil
+
+      default = Config.build
+
+      @writers = {DEFAULT_WRITER_NAME => default.freeze}
+      @global_settings = {}
+
+      @writer_output_dirs = {DEFAULT_WRITER_NAME => normalize_path(default.output_dir)}
+      @used_output_dirs = Set.new(@writer_output_dirs.values.compact)
+    end
+
+    # Defines or updates a writer configuration.
+    #
+    # Inherits from the existing writer config (or global_settigns if absent), yields a mutable copy,
+    # then freezes and stores it. output_dir is unique and mandatory
+    # Also accepts "from" argument, which allows us to inherit configuration from any writer
+    def writer(name = DEFAULT_WRITER_NAME, from: nil, &block)
+      writer_name = normalize_writer_name(name)
+
+      # Inherit from existing writer config or from "from" attribute or global (flatt) config
+      base_config =
+        if @writers.key?(writer_name)
+          @writers[writer_name]
+        elsif from && @writers.key?(from.to_sym)
+          @writers[from.to_sym]
+        else
+          Config.build(**@global_settings)
+        end
+
+      mutable_config = base_config.with_overrides
+
+      block&.call(mutable_config)
+
+      # Register output directory for uniqueness checking
+      register_output_dir!(writer_name, mutable_config.output_dir)
+
+      # Store and return frozen configuration
+      @writers[writer_name] = mutable_config.freeze
+    end
+
+    def writer_config(name = DEFAULT_WRITER_NAME)
+      @writers.fetch((name || DEFAULT_WRITER_NAME).to_sym)
+    end
+
+    # Reset writers and keep only `default` writer
+    def reset_writers!
+      @writers.keep_if { |key, _| key == DEFAULT_WRITER_NAME }
+
+      @writer_output_dirs = {
+        DEFAULT_WRITER_NAME => normalize_path(@writers[DEFAULT_WRITER_NAME].output_dir)
+      }
+
+      @used_output_dirs = Set.new(@writer_output_dirs.values.compact)
+    end
+
+    private
+
+    # Setters and readers to Writer(:default) config
+    # Keep the "flat" setters for the :default writer, for example:
+    #   config.output_dir = ...
+    #   config.prefer_double_quotes = true
+    def method_missing(name, *args, &block)
+      name = name.to_s
+      config_key = normalize_method_name(name)
+
+      # Setters
+      if name.end_with?("=") && args.length.positive?
+        return super unless config_attribute?(config_key)
+
+        val = args.first
+        new_default = @writers[DEFAULT_WRITER_NAME].with_overrides(config_key => val)
+
+        register_output_dir!(DEFAULT_WRITER_NAME, new_default.output_dir) if config_key == :output_dir
+
+        @writers[DEFAULT_WRITER_NAME] = new_default.freeze
+
+        return @global_settings[config_key] = val
+      end
+
+      # Readers
+      return @writers[DEFAULT_WRITER_NAME].public_send(config_key) if args.empty? && config_attribute?(config_key)
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      str = name.to_s
+      key = normalize_method_name(str)
+      (config_attribute?(key) && (str.end_with?("=") || true)) || super
+    end
+
+    # Normalizes and validates writer name
+    def normalize_writer_name(name)
+      writer_name = (name || DEFAULT_WRITER_NAME).to_sym
+
+      raise ArgumentError, "Writer name cannot be empty" if writer_name.to_s.strip.empty?
+
+      writer_name
+    end
+
+    # Validates and registers output directory for uniqueness across writers
+    def register_output_dir!(writer_name, dir)
+      raise ArgumentError, "output_dir must be configured for writer :#{writer_name}" if dir.to_s.strip.empty?
+
+      path = normalize_path(dir)
+
+      current = @writer_output_dirs[writer_name]
+      return if current == path
+
+      if @writer_output_dirs.any? { |k, v| k != writer_name && v == path }
+        holder = @writer_output_dirs.key(path)
+
+        raise ArgumentError, "output_dir '#{path}' is already in use by writer :#{holder}"
+      end
+
+      @used_output_dirs.delete(current) if current
+      @writer_output_dirs[writer_name] = path
+      @used_output_dirs << path
+    end
+
+    def normalize_path(dir)
+      Pathname(dir).expand_path.to_s
+    end
+
+    def normalize_method_name(name)
+      name.to_s.chomp("=").to_sym
+    end
+
+    def config_attribute?(name)
+      Config.members.include?(name)
+    end
+  end
+end

data/lib/typelizer/contexts/scan_context.rb

@@ -0,0 +1,20 @@
+# 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

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,32 +9,59 @@ 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
 
         prop.multi = !!column.try(:array)
         case config.null_strategy
@@ -57,17 +84,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.fetch(prop.column_name.to_s, nil)
+        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,9 +92,10 @@ 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

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.2"
+  VERSION = "0.5.1"
 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typelizer
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.1
 platform: ruby
 authors:
 - Svyatoslav Kryukov
@@ -35,6 +35,9 @@ files:
 - lib/tasks/generate.rake
 - 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/generator.rb
 - lib/typelizer/interface.rb
@@ -45,6 +48,7 @@ files:
 - lib/typelizer/property.rb
 - lib/typelizer/railtie.rb
 - lib/typelizer/renderer.rb
+- lib/typelizer/serializer_config_layer.rb
 - lib/typelizer/serializer_plugins/alba.rb
 - lib/typelizer/serializer_plugins/ams.rb
 - lib/typelizer/serializer_plugins/auto.rb
@@ -83,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A TypeScript type generator for Ruby serializers.
 test_files: []