typelizer 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0784a5e0472196bc334c145c9f02e6f98898d164670abd55e4215775ed4b0aaa'
-  data.tar.gz: fc4dcaf1daddc6f9d07068e36fdc6ff7d2be2f8fe3163b42460e1fbaa6e5671b
+  metadata.gz: a9a7d9dfc60b5b5b8432575016f4f63697b6c6e356d74044abf6646b7d8e10a6
+  data.tar.gz: 374654bfb99f5bb3363b7a21174bb4c4a52718d2b852d4597e80aa155ce6fa34
 SHA512:
-  metadata.gz: 80275894a434d028d8e89aaaa746476fce065785201374488b92ba967866bad458852cf5c57864027076b44c48225e596435c772fc0a05bcc26bf7c312eb219d
-  data.tar.gz: c3f99f8cb337d3fc3a33c6fda789c23957907440f0162c437b379f8f1f2a1f61416348cc86386bf2c686a9060aee55a8ffc796baf2d42e4296b0cf77d9249468
+  metadata.gz: 3886301d0db29ef0ed101f5edf76e6228501672f5750c0109a854e142f880c1cd24a71fea9ca352caa888697f801302283b679e36ac61ea19c87e8c9b73ecfb4
+  data.tar.gz: bf5b5cdc3748500355aa1bac6d2f0dc035a4776080e06bee523c369cf33177ed24f1e92702e42366e5a7b1e72994696ff32dc52f55295f66bbf48f7961c5e2a5

data/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.13.0] - 2026-05-01
+
+### Added
+
+- **Runtime enums** (`config.enum_runtime = true`, default `false`): emit an `as const` object alongside each named enum type in `Enums.ts` and re-export it as a value from `index.ts`. Lets consumers compare against enum values at runtime (`if (user.role === UserRole.admin)`) without hand-maintaining a parallel constants file. Existing type-only output is unchanged when the flag is off. ([@skryukov])
+
+- **Inline object types**: pass a positional hash to `typelize` to describe an inline TypeScript object type. Nested hashes nest, and options like `multi:`/`nullable:` compose. Useful for JSON columns and ad-hoc computed shapes that don't warrant a separate resource. ([@skryukov])
+
+  ```ruby
+  typelize({id: :number, label?: :string})
+  attribute :category
+  # → category: { id: number; label?: string }
+  ```
+
+- **`?` suffix on attribute keys** as a shorthand for `optional: true`, mirroring TypeScript's own syntax. Works both in keyed `typelize` calls and inside inline shape hashes. ([@skryukov])
+
+  ```ruby
+  typelize name?: :string
+  # → name?: string
+  ```
+
+### Changed
+
+- [BREAKING] Type generation is now deferred to the first HTTP request via a Rack middleware, instead of running during Rails boot. Boot no longer touches the database, so a missing or pending-migration database no longer crashes server startup. Generation failures raise `Typelizer::TypeGenerationError` (rendered like the standard pending-migrations page) and are retried on the next request. Rake tasks are unaffected. ([@julik])
+- [BREAKING] Bumped `railties` requirement to `>= 6.1.0` to use the `server` Railtie block. ([@julik])
+- [BREAKING] Dropped `DISABLE_TYPELIZER` environment variable support (deprecated since 0.12.0). Use `TYPELIZER=false` instead. ([@skryukov])
+- [BREAKING] Removed the `.form` route variant, `FormDefinition` type, and `formAction` runtime helper. ([@skryukov])
+
+### Fixed
+
+- `typelize` declarations silently dropped during rake tasks, producing `unknown` for every field. ([#114](https://github.com/skryukov/typelizer/issues/114)) ([@skryukov])
+- `properties_transformer` now applied to nested attribute sub-properties, meta nested blocks, and Alba trait properties. Previously only top-level keys were transformed, producing inconsistent output. ([#89](https://github.com/skryukov/typelizer/issues/89)) ([@skryukov])
+- `typelize "Name[]"` paired with `with_traits:` no longer emits a phantom trait intersection with a missing import. Explicit `typelize` overrides are now trusted as-is — the generated type is exactly what you wrote. ([#113](https://github.com/skryukov/typelizer/issues/113)) ([@skryukov])
+- ActiveRecord models whose tables don't exist yet (fresh checkout, pending migration) are now skipped during type inference instead of issuing live DB queries. ([@julik])
+
 ## [0.12.0] - 2026-03-29
 
 ### Added
@@ -455,6 +490,7 @@ and this project adheres to [Semantic Versioning].
 [@Envek]: https://github.com/Envek
 [@hkamberovic]: https://github.com/hkamberovic
 [@jonmarkgo]: https://github.com/jonmarkgo
+[@julik]: https://github.com/julik
 [@kristinemcbride]: https://github.com/kristinemcbride
 [@nkriege]: https://github.com/nkriege
 [@NOX73]: https://github.com/NOX73
@@ -467,7 +503,8 @@ and this project adheres to [Semantic Versioning].
 [@skryukov]: https://github.com/skryukov
 [@ventsislaf]: https://github.com/ventsislaf
 
-[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.12.0...HEAD
+[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.13.0...HEAD
+[0.13.0]: https://github.com/skryukov/typelizer/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/skryukov/typelizer/compare/v0.11.0...v0.12.0
 [0.11.0]: https://github.com/skryukov/typelizer/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/skryukov/typelizer/compare/v0.9.3...v0.10.0

data/README.md

@@ -50,6 +50,24 @@ rails typelizer:generate
 - [Configuration](https://typelizer.dev/reference/configuration)
 - [Type Mapping](https://typelizer.dev/reference/type-mapping)
 
+## Development
+
+You need PostgreSQL running locally. Then:
+
+```bash
+bundle install
+cd spec/app && RAILS_ENV=test bundle exec rails db:create db:migrate && cd ../..
+bundle exec rspec
+```
+
+The test suite uses a dummy Rails app in `spec/app/` with models, migrations, and serializers for all four supported frameworks (Alba, AMS, OjSerializers, Panko). Linting is done with StandardRB:
+
+```bash
+bundle exec standardrb
+```
+
+`bundle exec rake` runs both the tests and the linter.
+
 ## Credits
 
 Typelizer is inspired by [types_from_serializers](https://github.com/ElMassimo/types_from_serializers), [js-routes](https://github.com/railsware/js-routes), and [Wayfinder](https://github.com/nicholasvansanten/wayfinder).

data/lib/typelizer/config.rb

@@ -31,12 +31,17 @@ module Typelizer
     properties_sort_order
   ].freeze
 
-  # Subset of CONFIGS_AFFECTING_OUTPUT that specifically affect index.ts output.
-  CONFIGS_AFFECTING_INDEX_OUTPUT = %i[
+  # Config keys that affect only index.ts and Enums.ts (not per-interface .ts files).
+  CONFIGS_AFFECTING_INDEX_ONLY_OUTPUT = %i[
+    enum_runtime
+  ].freeze
+
+  # Config keys that affect index.ts output (superset: per-interface keys + index-only keys).
+  CONFIGS_AFFECTING_INDEX_OUTPUT = (%i[
     verbatim_module_syntax
     prefer_double_quotes
     imports_sort_order
-  ].freeze
+  ] + CONFIGS_AFFECTING_INDEX_ONLY_OUTPUT).freeze
 
   # Config keys that don't affect file content (runtime behavior, or effects captured via properties).
   CONFIGS_NOT_AFFECTING_OUTPUT = %i[
@@ -76,6 +81,7 @@ module Typelizer
     :reject_class,
     :comments,
     :prefer_double_quotes,
+    :enum_runtime,
     keyword_init: true
   )
 
@@ -114,6 +120,7 @@ module Typelizer
         reject_class: ->(serializer:) { false },
         comments: false,
         prefer_double_quotes: false,
+        enum_runtime: false,
 
         output_dir: -> { default_output_dir },
 

data/lib/typelizer/dsl.rb

@@ -33,8 +33,6 @@ module Typelizer
 
       # save association of serializer to model
       def typelize_from(model)
-        return unless Typelizer.enabled?
-
         define_singleton_method(:_typelizer_model_name) { model }
       end
 
@@ -82,12 +80,13 @@ module Typelizer
       private
 
       def assign_type_information(attribute_name, attributes)
-        return unless Typelizer.enabled?
-
         attributes.each do |name, attrs|
           next unless name
 
-          store_type(attribute_name, name, TypeParser.parse_declaration(attrs))
+          clean_name, optional_from_key = TypeParser.parse_key(name)
+          parsed = TypeParser.apply_optional_key(TypeParser.parse_declaration(attrs), optional_from_key)
+
+          store_type(attribute_name, clean_name, parsed)
         end
       end
 
@@ -112,5 +111,15 @@ module Typelizer
         end
       end
     end
+
+    module Disabled
+      %i[typelize_from typelize typelize_meta].each do |name|
+        define_method(name) { |*, **| }
+      end
+    end
+
+    def self.disable!
+      ClassMethods.prepend(Disabled)
+    end
   end
 end

data/lib/typelizer/interface.rb

@@ -64,7 +64,7 @@ module Typelizer
       @meta_fields ||= begin
         props = serializer_plugin.meta_fields || []
         props = infer_types(props, :_typelizer_meta_attributes)
-        props = config.properties_transformer.call(props) if config.properties_transformer
+        props = transform_properties(props)
         PropertySorter.sort(props, config.properties_sort_order)
       end
     end
@@ -88,7 +88,7 @@ module Typelizer
       @properties ||= begin
         props = serializer_plugin.properties
         props = infer_types(props)
-        props = config.properties_transformer.call(props) if config.properties_transformer
+        props = transform_properties(props)
         PropertySorter.sort(props, config.properties_sort_order)
       end
     end
@@ -125,7 +125,10 @@ module Typelizer
         # recursively including nested sub-properties
         all_properties = collect_all_properties(properties_to_print + trait_interfaces.flat_map(&:properties))
 
-        flat_types = all_properties.filter_map(&:type).flat_map { |t| Array(t) }.uniq
+        flat_types = all_properties.filter_map(&:type)
+          .flat_map { |t| Array(t) }
+          .reject { |t| t.is_a?(Shape) }
+          .uniq
         association_serializers, attribute_types = flat_types.partition { |type| type.is_a?(Interface) }
 
         serializer_types = association_serializers
@@ -136,13 +139,10 @@ module Typelizer
           .uniq
           .reject { |type| global_type?(type) }
 
-        # Collect trait types from properties with with_traits (skip self-references)
         trait_imports = all_properties.flat_map do |prop|
-          next [] unless prop.with_traits&.any? && prop.type.is_a?(Interface)
-          # Skip if the trait types are from the current interface (same file)
-          next [] if prop.type.name == name
+          next [] if prop.type.is_a?(Interface) && prop.type.name == name
 
-          prop.with_traits.map { |t| "#{prop.type.name}#{t.to_s.camelize}Trait" }
+          prop.trait_type_names
         end
 
         # Collect enum type names from properties
@@ -177,13 +177,15 @@ module Typelizer
 
     def collect_all_properties(props)
       props.flat_map do |prop|
-        if prop.nested_properties&.any?
-          [prop] + collect_all_properties(prop.nested_properties)
-        elsif prop.type.is_a?(Interface) && prop.type.inline?
-          [prop] + collect_all_properties(prop.type.properties)
-        else
-          [prop]
-        end
+        children = nested_properties_of(prop.type)
+        children ? [prop] + collect_all_properties(children) : [prop]
+      end
+    end
+
+    def nested_properties_of(type)
+      case type
+      when Shape then type.properties
+      when Interface then type.properties if type.inline?
       end
     end
 
@@ -204,7 +206,7 @@ module Typelizer
       multi_attrs = serializer.respond_to?(:_typelizer_multi_attributes) ? serializer._typelizer_multi_attributes : Set.new
 
       props.map do |prop|
-        has_dsl = dsl_attrs_for(prop, dsl_attrs)&.any?
+        has_dsl = prop.lookup_in(dsl_attrs)&.any?
 
         prop
           .then { |p| apply_dsl_type(p, dsl_attrs) }
@@ -215,12 +217,8 @@ module Typelizer
       end
     end
 
-    def dsl_attrs_for(prop, dsl_attrs)
-      dsl_attrs[prop.column_name.to_sym] || dsl_attrs[prop.name.to_sym]
-    end
-
     def apply_dsl_type(prop, dsl_attrs)
-      dsl_type = dsl_attrs_for(prop, dsl_attrs)
+      dsl_type = prop.lookup_in(dsl_attrs)
       return prop unless dsl_type&.any?
 
       dsl_type = resolve_class_type(dsl_type)
@@ -235,11 +233,20 @@ module Typelizer
         resolve_union_class_types(attrs)
       when String, Symbol
         resolve_single_class_type(attrs)
+      when Shape
+        attrs.merge(type: resolve_shape(type))
       else
         attrs
       end
     end
 
+    def resolve_shape(shape)
+      shape.map_properties do |p|
+        resolved = resolve_class_type(type: p.type)
+        p.with(type: resolved[:type])
+      end
+    end
+
     def resolve_single_class_type(attrs)
       attrs.merge(type: resolve_type_part(attrs[:type]))
     end

data/lib/typelizer/middleware.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Typelizer
+  class TypeGenerationError < StandardError; end
+
+  class Middleware
+    class << self
+      attr_accessor :instance
+    end
+
+    def initialize(app)
+      @app = app
+      @mutex = Mutex.new
+      @pending = true
+      self.class.instance = self
+    end
+
+    def call(env)
+      if @pending
+        @mutex.synchronize do
+          generate! if @pending
+        end
+      end
+      @app.call(env)
+    end
+
+    def mark_pending!
+      @pending = true
+    end
+
+    private
+
+    def generate!
+      Generator.new.call
+      RouteGenerator.call
+      @pending = false
+    rescue *db_error_classes => e
+      raise TypeGenerationError, "Typelizer could not generate types: #{e.message}\n" \
+        "Fix the database issue, then reload the page."
+    end
+
+    def db_error_classes
+      return [] unless defined?(ActiveRecord)
+
+      [
+        ActiveRecord::NoDatabaseError,
+        ActiveRecord::ConnectionNotEstablished,
+        ActiveRecord::StatementInvalid
+      ]
+    end
+  end
+end

data/lib/typelizer/model_plugins/active_record.rb

@@ -38,6 +38,7 @@ module Typelizer
       def columns_hash
         return nil unless model_class
         return nil if model_class.abstract_class?
+        return nil unless model_class.table_exists?
 
         model_class.columns_hash
       end
@@ -45,6 +46,7 @@ module Typelizer
       def attribute_types
         return nil unless model_class&.respond_to?(:attribute_types)
         return nil if model_class.abstract_class?
+        return nil unless model_class.table_exists?
 
         model_class.attribute_types
       end
@@ -126,6 +128,7 @@ module Typelizer
         return nil unless assoc
 
         target = assoc.klass
+        return nil unless target.table_exists?
         col = target.columns_hash[info[:original].to_s]
         return nil unless col
 

data/lib/typelizer/openapi.rb

@@ -32,13 +32,7 @@ module Typelizer
         validate_version!(openapi_version)
 
         type_mapping = interface.respond_to?(:config) ? interface.config.type_mapping : Typelizer.configuration.type_mapping
-        required_props = interface.properties.reject(&:optional).map(&:name)
-        schema = {
-          type: :object,
-          properties: interface.properties.to_h { |prop| [prop.name, property_schema(prop, openapi_version: openapi_version, type_mapping: type_mapping)] }
-        }
-        schema[:required] = required_props if required_props.any?
-        schema
+        object_schema(interface.properties, openapi_version: openapi_version, type_mapping: type_mapping)
       end
 
       def property_schema(property, openapi_version: "3.0", type_mapping: Typelizer.configuration.type_mapping)
@@ -120,11 +114,10 @@ module Typelizer
       end
 
       def wrap_traits(definition, property, openapi_version:)
-        return definition unless property.respond_to?(:with_traits) && property.with_traits&.any? && property.type.respond_to?(:name)
+        trait_names = property.trait_type_names
+        return definition if trait_names.empty?
 
-        trait_refs = property.with_traits.map do |t|
-          {"$ref" => "#/components/schemas/#{property.type.name}#{t.to_s.camelize}Trait"}
-        end
+        trait_refs = trait_names.map { |name| {"$ref" => "#/components/schemas/#{name}"} }
 
         base_ref = definition.delete("$ref")
         if base_ref
@@ -173,14 +166,15 @@ module Typelizer
       end
 
       def base_type(property, openapi_version:, type_mapping:)
-        if property.type.respond_to?(:properties)
+        # Shape check must precede respond_to?(:properties) — Shape also responds to :properties.
+        if property.type.is_a?(Shape)
+          object_schema(property.type.properties, openapi_version: openapi_version, type_mapping: type_mapping)
+        elsif property.type.respond_to?(:properties)
           if property.type.respond_to?(:inline?) && property.type.inline?
             schema_for(property.type, openapi_version: openapi_version)
           else
             {"$ref" => "#/components/schemas/#{property.type.name}"}
           end
-        elsif property.type.nil? && property.respond_to?(:nested_properties) && property.nested_properties&.any?
-          nested_schema(property, openapi_version: openapi_version, type_mapping: type_mapping)
         elsif property.column_type && COLUMN_TYPE_MAP.key?(property.column_type) &&
             !type_mapping_overridden?(property, type_mapping)
           result = COLUMN_TYPE_MAP[property.column_type].dup
@@ -196,11 +190,11 @@ module Typelizer
         end
       end
 
-      def nested_schema(property, openapi_version:, type_mapping:)
-        required = property.nested_properties.reject(&:optional).map(&:name)
+      def object_schema(properties, openapi_version:, type_mapping:)
+        required = properties.reject(&:optional).map(&:name)
         schema = {
           type: :object,
-          properties: property.nested_properties.to_h { |p| [p.name, property_schema(p, openapi_version: openapi_version, type_mapping: type_mapping)] }
+          properties: properties.to_h { |p| [p.name, property_schema(p, openapi_version: openapi_version, type_mapping: type_mapping)] }
         }
         schema[:required] = required if required.any?
         schema

data/lib/typelizer/property.rb

@@ -2,13 +2,17 @@ module Typelizer
   Property = Struct.new(
     :name, :type, :optional, :nullable,
     :multi, :column_name, :column_type, :comment, :enum, :enum_type_name, :deprecated,
-    :with_traits, :nested_properties, :nested_typelizes,
+    :with_traits,
     keyword_init: true
   ) do
     def with(**attrs)
       dup.tap { |p| attrs.each { |k, v| p[k] = v } }
     end
 
+    def lookup_in(hash)
+      hash[column_name.to_sym] || hash[name.to_sym]
+    end
+
     def inspect
       props = to_h.merge(type: type_name).map { |k, v| "#{k}=#{v.inspect}" }.join(" ")
       "<#{self.class.name} #{props}>"
@@ -25,6 +29,12 @@ module Typelizer
       render(sort_order: :none)
     end
 
+    def trait_type_names
+      return [] unless with_traits&.any? && type.is_a?(Interface)
+
+      with_traits.map { |t| "#{type.name}#{t.to_s.camelize}Trait" }
+    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
@@ -32,11 +42,8 @@ module Typelizer
     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)
-        trait_types = with_traits.map { |t| "#{type.name}#{t.to_s.camelize}Trait" }
-        type_str = ([type_str] + trait_types).join(" & ")
-      end
+      trait_types = trait_type_names
+      type_str = ([type_str] + trait_types).join(" & ") if trait_types.any?
 
       type_str = "Array<#{type_str}>" if multi
 
@@ -51,14 +58,10 @@ module Typelizer
 
     def fingerprint
       # Use array format for consistent output across Ruby versions
-      # (Hash#inspect format changed in Ruby 3.4)
-      # Exclude fields that do not affect generated TypeScript output.
-      # Exclude nested_properties/nested_typelizes from to_h to avoid changing
-      # fingerprints for properties that don't use them.
-      # nested_typelizes is excluded entirely as it only affects inference, not output.
-      to_h.except(:column_type, :nested_properties, :nested_typelizes)
+      # (Hash#inspect format changed in Ruby 3.4).
+      # column_type is excluded because it only informs inference, not output.
+      to_h.except(:column_type)
         .merge(type: UnionTypeSorter.sort(type_name(sort_order: :alphabetical), :alphabetical))
-        .then { |h| nested_properties&.any? ? h.merge(nested_properties: nested_properties.map(&:fingerprint)) : h }
         .to_a.inspect
     end
 
@@ -69,17 +72,36 @@ module Typelizer
     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
+      values = sorted_enum_keys(sort_order).map { |k| quote_string(k, prefer_double_quotes) }
       "type #{enum_type_name} = #{values.join(" | ")}"
     end
 
+    # Generates a TypeScript runtime constant for named enums
+    # @param sort_order [Symbol, Proc, nil] Sort order for enum keys (:none, :alphabetical, or Proc)
+    # @param prefer_double_quotes [Boolean] Whether to use double quotes for string values
+    # @return [String, nil] The const like "const UserRole = { admin: 'admin', user: 'user' } as const"
+    def enum_runtime_definition(sort_order: :none, prefer_double_quotes: false)
+      return unless enum && enum_type_name
+
+      entries = sorted_enum_keys(sort_order).map { |k| "#{js_key(k, prefer_double_quotes)}: #{quote_string(k, prefer_double_quotes)}" }
+      "const #{enum_type_name} = { #{entries.join(", ")} } as const"
+    end
+
     private
 
+    def sorted_enum_keys(sort_order)
+      keys = enum.map(&:to_s)
+      (sort_order == :alphabetical) ? keys.sort_by(&:downcase) : keys
+    end
+
     def quote_string(str, prefer_double_quotes)
       prefer_double_quotes ? "\"#{str}\"" : "'#{str}'"
     end
 
+    def js_key(str, prefer_double_quotes)
+      str.match?(/\A[A-Za-z_$][\w$]*\z/) ? str : quote_string(str, prefer_double_quotes)
+    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
@@ -89,21 +111,12 @@ module Typelizer
       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
-
-      if type.nil? && nested_properties&.any?
-        inner = nested_properties.map { |p|
-          rendered = p.render(sort_order: sort_order, prefer_double_quotes: prefer_double_quotes) + ";"
-          rendered.gsub(/^/, "  ")
-        }.join("\n")
-        return "{\n#{inner}\n}"
+        return sorted_enum_keys(sort_order).map { |k| quote_string(k, prefer_double_quotes) }.join(" | ")
       end
 
       case type
+      when Shape
+        type.render(sort_order: sort_order, prefer_double_quotes: prefer_double_quotes)
       when Array
         type.map { |t| t.respond_to?(:name) ? t.name : t.to_s }.join(" | ")
       else

data/lib/typelizer/railtie.rb

@@ -15,23 +15,25 @@ module Typelizer
       end
     end
 
-    initializer "typelizer.generate" do |app|
+    initializer "typelizer.configure_dsl" do
+      Typelizer::DSL.disable! unless Typelizer.enabled?
+    end
+
+    server do
       next unless Typelizer.enabled?
 
-      generator = Typelizer::Generator.new
+      require_relative "middleware"
+      Rails.application.config.app_middleware.use(Typelizer::Middleware)
 
       if Typelizer.listen == true || (Gem.loaded_specs["listen"] && Typelizer.listen != false)
         require_relative "listen"
-        app.config.after_initialize do
-          Typelizer::Listen.call do
-            Rails.application.reloader.reload!
-          end
+        Typelizer::Listen.call(run_on_start: false) do
+          Rails.application.reloader.reload!
         end
       end
 
-      app.config.to_prepare do
-        generator.call
-        RouteGenerator.call
+      Rails.application.config.to_prepare do
+        Typelizer::Middleware.instance&.mark_pending!
       end
     end
   end

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

@@ -29,6 +29,7 @@ module Typelizer
         @properties ||= begin
           props, typelizes = plugin.trait_properties(trait_name)
           props = infer_types(props, typelizes)
+          props = transform_properties(props)
           PropertySorter.sort(props, config.properties_sort_order)
         end
       end
@@ -37,7 +38,7 @@ module Typelizer
 
       def infer_types(props, typelizes)
         props.map do |prop|
-          dsl_type = typelizes[prop.column_name.to_sym] || typelizes[prop.name.to_sym]
+          dsl_type = prop.lookup_in(typelizes)
           prop
             .then { |p| dsl_type&.any? ? p.with(**dsl_type) : apply_model_inference(p) }
             .then { |p| apply_metadata(p) }

data/lib/typelizer/serializer_plugins/alba.rb

@@ -47,7 +47,6 @@ module Typelizer
         trait_block = traits[trait_name]
         return [], {} unless trait_block
 
-        # Create a collector to capture attributes defined in the trait block
         collector = BlockAttributeCollector.new
         collector.instance_exec(&trait_block)
 
@@ -76,16 +75,13 @@ module Typelizer
           )
         when BlockAttributeCollector::BlockNestedAttribute
           prop_name = has_transform_key?(serializer) ? fetch_key(serializer, name) : name
-          nested_props, nested_typelizes = collect_nested_block(attr.block)
           Property.new(
             name: prop_name,
-            type: nil,
+            type: Shape.new(properties: collect_nested_block(attr.block)),
             optional: false,
             nullable: false,
             multi: false,
-            column_name: name,
-            nested_properties: nested_props,
-            nested_typelizes: nested_typelizes
+            column_name: name
           )
         else
           build_property(name, attr)
@@ -179,16 +175,13 @@ module Typelizer
           )
         when ::Alba::NestedAttribute
           block = attr.instance_variable_get(:@block)
-          nested_props, nested_typelizes = collect_nested_block(block)
           Property.new(
             name: name,
-            type: nil,
+            type: Shape.new(properties: collect_nested_block(block)),
             optional: false,
             nullable: false,
             multi: false,
             column_name: column_name,
-            nested_properties: nested_props,
-            nested_typelizes: nested_typelizes,
             **options
           )
         when ::Alba::ConditionalAttribute
@@ -217,13 +210,14 @@ module Typelizer
       def collect_nested_block(block)
         collector = BlockAttributeCollector.new
         collector.instance_exec(&block)
+        typelizes = collector.collected_typelizes
 
-        props = collector.collected_attributes.map do |attr_name, attr|
+        collector.collected_attributes.map do |attr_name, attr|
           attr_name_str = attr_name.is_a?(Symbol) ? attr_name.name : attr_name
-          build_collected_property(attr_name_str, attr)
+          prop = build_collected_property(attr_name_str, attr)
+          override = prop.lookup_in(typelizes)
+          override&.any? ? prop.with(**override) : prop
         end
-
-        [props, collector.collected_typelizes]
       end
     end
   end

data/lib/typelizer/shape.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Typelizer
+  class Shape
+    attr_reader :properties
+
+    def initialize(properties:)
+      @properties = properties.freeze
+      @fingerprint = ["Shape", properties.map(&:fingerprint)].freeze
+      @hash = @fingerprint.hash
+      freeze
+    end
+
+    def map_properties
+      self.class.new(properties: properties.map { |p| yield p })
+    end
+
+    def render(sort_order: :none, prefer_double_quotes: false)
+      inner = properties.map { |p|
+        (p.render(sort_order: sort_order, prefer_double_quotes: prefer_double_quotes) + ";")
+          .gsub(/^/, "  ")
+      }.join("\n")
+      "{\n#{inner}\n}"
+    end
+
+    alias_method :to_s, :render
+
+    attr_reader :fingerprint, :hash
+
+    def ==(other)
+      other.is_a?(Shape) && fingerprint == other.fingerprint
+    end
+    alias_method :eql?, :==
+
+    def inspect
+      "<Typelizer::Shape properties=#{properties.inspect}>"
+    end
+  end
+end

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

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

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

@@ -1,6 +1,7 @@
 <%- 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 %>
+<%- enum_keyword = enum_runtime ? "export" : "export type" -%>
+<%= enum_keyword %> { <%= 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) -%>

data/lib/typelizer/templates/route_controller.erb

@@ -1,8 +1,7 @@
-<%- has_form = routes.any? { |r| !%w[get post].include?(r[:verb]) } -%>
 <%- if ts -%>
-import type { RouteDefinition<%= ", FormDefinition" if has_form %>, RouteOptions } from '<%= runtime_import %>'
+import type { RouteDefinition, RouteOptions } from '<%= runtime_import %>'
 <%- end -%>
-import { buildUrl<%= ", formAction" if has_form %> } from '<%= runtime_import %>'
+import { buildUrl } from '<%= runtime_import %>'
 
 export default {
 <%- routes.each_with_index do |route, idx| -%>
@@ -10,48 +9,8 @@ export default {
 <%- parts = route[:required_params].map { |p| "#{p}#{ts ? ": string | number" : ""}" } -%>
 <%- parts += route[:optional_params].map { |p| "#{p}#{ts ? "?: string | number" : ""}" } -%>
 <%- has_params = parts.any? -%>
-<%- needs_form = !%w[get post].include?(route[:verb]) -%>
   /** <%= route[:verb].upcase %> <%= route[:path] %> */
-<%- if needs_form -%>
 <%- if has_params -%>
-<%- if ts -%>
-  <%= route[:key] %>: Object.assign(
-    (
-      params: { <%= parts.join('; ') %> }<%= " | string | number" if route[:single_required] %>,
-      options?: RouteOptions,
-    ): RouteDefinition<<%= "'#{route[:verb]}'" %>> => ({
-      url: buildUrl('<%= route[:path] %>', params, options),
-      method: '<%= route[:verb] %>',
-    }),
-    { form: (
-      params: { <%= parts.join('; ') %> }<%= " | string | number" if route[:single_required] %>,
-      options?: RouteOptions,
-    ): FormDefinition =>
-      formAction(buildUrl('<%= route[:path] %>', params, options), '<%= route[:verb] %>') },
-  ),
-<%- else -%>
-  <%= route[:key] %>: Object.assign(
-    (params, options) => ({
-      url: buildUrl('<%= route[:path] %>', params, options),
-      method: '<%= route[:verb] %>',
-    }),
-    { form: (params, options) =>
-      formAction(buildUrl('<%= route[:path] %>', params, options), '<%= route[:verb] %>') },
-  ),
-<%- end -%>
-<%- else -%>
-<%- if ts -%>
-  <%= route[:key] %>: Object.assign(
-    (options?: RouteOptions): RouteDefinition<<%= "'#{route[:verb]}'" %>> => ({
-      url: buildUrl('<%= route[:path] %>', {}, options),
-      method: '<%= route[:verb] %>',
-    }),
-    { form: (options?: RouteOptions): FormDefinition =>
-      formAction(buildUrl('<%= route[:path] %>', {}, options), '<%= route[:verb] %>') },
-  ),
-<%- end -%>
-<%- end -%>
-<%- elsif has_params -%>
 <%- if ts -%>
   <%= route[:key] %>: (
     params: { <%= parts.join('; ') %> }<%= " | string | number" if route[:single_required] %>,

data/lib/typelizer/templates/route_runtime.js

@@ -20,14 +20,6 @@ export function addUrlDefault(key, value) {
   }
 }
 
-export function formAction(url, method) {
-  if (method === 'get' || method === 'post') {
-    return { action: url, method }
-  }
-  const sep = url.includes('?') ? '&' : '?'
-  return { action: `${url}${sep}_method=${method.toUpperCase()}`, method: 'post' }
-}
-
 export function buildUrl(
   template,
   params,

data/lib/typelizer/templates/route_runtime.ts

@@ -5,11 +5,6 @@ export type RouteDefinition<M extends Method> = {
   method: M
 }
 
-export type FormDefinition = {
-  action: string
-  method: 'get' | 'post'
-}
-
 export type RouteOptions = {
   query?: Record<string, unknown>
   anchor?: string
@@ -37,14 +32,6 @@ export function addUrlDefault(key: string, value: unknown): void {
   }
 }
 
-export function formAction(url: string, method: Method): FormDefinition {
-  if (method === 'get' || method === 'post') {
-    return { action: url, method }
-  }
-  const sep = url.includes('?') ? '&' : '?'
-  return { action: `${url}${sep}_method=${method.toUpperCase()}`, method: 'post' }
-}
-
 export function buildUrl(
   template: string,
   params: Record<string, unknown> | string | number,

data/lib/typelizer/type_inference.rb

@@ -15,19 +15,27 @@ module Typelizer
       end
     end
 
+    def transform_properties(props)
+      return props unless config.properties_transformer
+
+      props = config.properties_transformer.call(props)
+      props.map do |prop|
+        next prop unless prop.type.is_a?(Shape)
+
+        prop.with(type: Shape.new(properties: transform_properties(prop.type.properties)))
+      end
+    end
+
     def infer_nested_property_types(prop)
-      return prop unless prop.nested_properties&.any?
+      return prop unless prop.type.is_a?(Shape)
 
-      typelizes = prop.nested_typelizes || {}
-      inferred = prop.nested_properties.map do |sub_prop|
-        dsl_type = typelizes[sub_prop.column_name.to_sym] || typelizes[sub_prop.name.to_sym]
+      inferred = prop.type.map_properties do |sub_prop|
         sub_prop
-          .then { |p| dsl_type&.any? ? p.with(**dsl_type) : apply_model_inference(p) }
+          .then { |p| p.type ? p : apply_model_inference(p) }
           .then { |p| apply_metadata(p) }
           .then { |p| infer_nested_property_types(p) }
       end
-
-      prop.with(nested_properties: inferred)
+      prop.with(type: inferred)
     end
 
     def model_class

data/lib/typelizer/type_parser.rb

@@ -23,6 +23,7 @@ module Typelizer
 
       def parse(type_def, **options)
         return options if type_def.nil?
+        return parse_shape(type_def, **options) if type_def.is_a?(Hash)
         return parse_array(type_def, **options) if type_def.is_a?(Array)
 
         type_str = type_def.to_s
@@ -49,8 +50,35 @@ module Typelizer
         type_str.end_with?("?", "[]")
       end
 
+      # Strips a trailing `?` from an attribute key, returning [clean_name, optional?].
+      def parse_key(name)
+        str = name.to_s
+        str.end_with?("?") ? [str.chomp("?").to_sym, true] : [name.to_sym, false]
+      end
+
+      def apply_optional_key(parsed, optional_from_key)
+        parsed[:optional] = true if optional_from_key && !parsed.key?(:optional)
+        parsed
+      end
+
       private
 
+      def parse_shape(hash, **options)
+        properties = hash.map do |name, value|
+          clean_name, optional_from_key = parse_key(name)
+
+          # parse_declaration returns Hash args verbatim (options-bag form); nested
+          # shapes need parse to dispatch back here and build a Shape.
+          parsed = value.is_a?(Hash) ? parse(value) : parse_declaration(value)
+          apply_optional_key(parsed, optional_from_key)
+
+          property_attrs = parsed.slice(*Property.members).tap { |h| h[:name] = clean_name }
+          Property.new(optional: false, nullable: false, multi: false, **property_attrs)
+        end
+
+        {type: Shape.new(properties: properties)}.merge(options)
+      end
+
       def parse_array(type_defs, **options)
         raise ArgumentError, "Empty array passed to typelize" if type_defs.empty?
 

data/lib/typelizer/version.rb

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

data/lib/typelizer/writer.rb

@@ -60,9 +60,9 @@ module Typelizer
     end
 
     def write_enums(enums)
-      fingerprint = [enums.map(&:fingerprint), config.properties_sort_order, config.prefer_double_quotes].inspect
+      fingerprint = [enums.map(&:fingerprint), config.properties_sort_order, config.prefer_double_quotes, config.enum_runtime].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)
+        render_template("enums.ts.erb", enums: enums, sort_order: config.properties_sort_order, prefer_double_quotes: config.prefer_double_quotes, enum_runtime: config.enum_runtime)
       end
     end
 
@@ -74,7 +74,7 @@ module Typelizer
         }
       ].inspect
       write_file("index.ts", fingerprint) do
-        render_template("index.ts.erb", interfaces: interfaces, enums: enums, index_dir: config.output_dir.to_s, imports_sort_order: config.imports_sort_order, prefer_double_quotes: config.prefer_double_quotes)
+        render_template("index.ts.erb", interfaces: interfaces, enums: enums, index_dir: config.output_dir.to_s, imports_sort_order: config.imports_sort_order, prefer_double_quotes: config.prefer_double_quotes, enum_runtime: config.enum_runtime)
       end
     end
 

data/lib/typelizer.rb

@@ -2,6 +2,7 @@
 
 require_relative "typelizer/version"
 require_relative "typelizer/union_type_sorter"
+require_relative "typelizer/shape"
 require_relative "typelizer/property"
 require_relative "typelizer/model_plugins/auto"
 require_relative "typelizer/serializer_plugins/auto"
@@ -50,10 +51,7 @@ module Typelizer
     # Is Typelizer active?
     #
     # Precedence: TYPELIZER env var > development? detection
-    # Legacy DISABLE_TYPELIZER is mapped to TYPELIZER with a deprecation warning.
     def enabled?
-      migrate_legacy_env!
-
       val = ENV["TYPELIZER"]
       return val == "true" || val == "1" if val
 
@@ -95,23 +93,9 @@ module Typelizer
     private
 
     def development?
-      ENV["RAILS_ENV"] == "development" || ENV["RACK_ENV"] == "development"
-    end
+      return Rails.env.development? if defined?(Rails) && Rails.respond_to?(:env)
 
-    # Maps legacy DISABLE_TYPELIZER to TYPELIZER with a deprecation warning.
-    # Only takes effect if TYPELIZER is not already set.
-    def migrate_legacy_env!
-      return if @legacy_env_migrated
-      @legacy_env_migrated = true
-
-      val = ENV["DISABLE_TYPELIZER"]
-      return unless val
-
-      new_val = (val == "true" || val == "1") ? "false" : "true"
-      logger.warn(
-        "[Typelizer] DISABLE_TYPELIZER is deprecated, use TYPELIZER=#{new_val} instead."
-      )
-      ENV["TYPELIZER"] ||= new_val
+      ENV["RAILS_ENV"] == "development" || ENV["RACK_ENV"] == "development"
     end
 
     def load_serializers

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typelizer
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Svyatoslav Kryukov
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: benchmark
   requirement: !ruby/object:Gem::Requirement
@@ -62,6 +62,7 @@ files:
 - lib/typelizer/import_sorter.rb
 - lib/typelizer/interface.rb
 - lib/typelizer/listen.rb
+- lib/typelizer/middleware.rb
 - lib/typelizer/model_plugins/active_record.rb
 - lib/typelizer/model_plugins/auto.rb
 - lib/typelizer/model_plugins/poro.rb
@@ -82,6 +83,7 @@ files:
 - lib/typelizer/serializer_plugins/base.rb
 - lib/typelizer/serializer_plugins/oj_serializers.rb
 - lib/typelizer/serializer_plugins/panko.rb
+- lib/typelizer/shape.rb
 - lib/typelizer/templates/comment.ts.erb
 - lib/typelizer/templates/enums.ts.erb
 - lib/typelizer/templates/fingerprint.erb