typelizer 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 505210c62639d70e95336cfb02bb0ab952089ac8433d5816774977853af264a1
-  data.tar.gz: 2878868d86acf4da05caaf5e139e3ccacf58025b8bf5fc2bc56c04b0a91049b4
+  metadata.gz: bc23d62a95119b1ff871bcde1eeb0c3180cc0fe1e38fa1252edad30a454661bc
+  data.tar.gz: 2658b01eebb6f9317ff4905f6c482cbdfa55afcadd4ba6508e1cd9b5469072da
 SHA512:
-  metadata.gz: b1522f196e8372d77e253bba7f9515043f925aa0f4d8ac6c3b1a11b837424743bba3225774b9dbd65232e46befdabbcb440ef6cf3370edc61e9dece9bf204e2e
-  data.tar.gz: 6e8acdb494ec3f5167bbfe9f53422ebd26d4e9d8dab89ec832518b1acda47aae821a002dd954daa7605f273f323092e3622699dffad88805120dbf3d3ad2fa4e
+  metadata.gz: 237f41ebfc6999a73c30e97a89dab3435638c49bac38ff8072493b62833fd7a6c7d5cd7655868bf07c958b879c906c4c38bd809331cad1827b37529183c1aae3
+  data.tar.gz: b882bab4aea8a599b69e39c296a8794cf1fa357ec20f092649d5fa7e7d80bf2fb05ffff69b4362f7e0aa0be9b669724933a4167bfe403f9ce094e37254dfc9e8

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning].
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-03-02
+
+### Changed
+
+- **Breaking:** Arrays of strings in `typelize` now produce string literal unions (`'active' | 'inactive'`) instead of type reference unions. Use symbols for type references: `typelize status: [:string, :number]`. ([@skryukov])
+
+## [0.9.3] - 2026-02-27
+
+### Fixed
+
+- Fix keyless `typelize` DSL without name. ([@skryukov])
+- Support arrays for keyless `typelize` calls. ([@skryukov])
+
 ## [0.9.2] - 2026-02-26
 
 ### Fixed
@@ -426,7 +439,9 @@ 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.9.2...HEAD
+[Unreleased]: https://github.com/skryukov/typelizer/compare/v0.10.0...HEAD
+[0.10.0]: https://github.com/skryukov/typelizer/compare/v0.9.3...v0.10.0
+[0.9.3]: https://github.com/skryukov/typelizer/compare/v0.9.2...v0.9.3
 [0.9.2]: https://github.com/skryukov/typelizer/compare/v0.9.1...v0.9.2
 [0.9.1]: https://github.com/skryukov/typelizer/compare/v0.9.0...v0.9.1
 [0.9.0]: https://github.com/skryukov/typelizer/compare/v0.8.0...v0.9.0

data/README.md

@@ -119,10 +119,10 @@ class PostResource < ApplicationResource
   typelize categories: "string?[]"      # optional array of strings (categories?: Array<string>)
 
   # Shortcuts can be combined with explicit options
-  typelize status: ["string?", nullable: true]  # optional and nullable
+  typelize status: [:string?, nullable: true]  # optional and nullable
 
   # Also works with keyless typelize
-  typelize "string?"
+  typelize :string?
   attribute :nickname do |user|
     user.nickname
   end
@@ -167,8 +167,8 @@ class PostResource < ApplicationResource
   typelize target: "UserResource | CommentResource"
   attribute :target
 
-  # String and class constant can be mixed
-  typelize item: ["Namespace::UserResource", CommentResource]
+  # Pipe-delimited string with namespaced serializer
+  typelize item: "Namespace::UserResource | CommentResource"
   attribute :item
 end
 ```
@@ -183,8 +183,8 @@ class PostResource < ApplicationResource
   typelize content: "TextBlock | ImageBlock"
   attribute :content
 
-  # Works with arrays too
-  typelize sections: ["TextBlock", "ImageBlock"]
+  # Works with arrays of symbols too
+  typelize sections: [:TextBlock, :ImageBlock]
   attribute :sections
 end
 ```
@@ -200,10 +200,39 @@ type Post = {
 }
 ```
 
+String arrays are treated as string literal unions — useful for enums and state machines:
+
+```ruby
+class PostResource < ApplicationResource
+  attributes :id, :title
+
+  # Array of strings — generates string literal union type
+  typelize status: ["draft", "published", "archived"]
+  attribute :status
+
+  # Works with Rails enums and state machines
+  typelize review_state: ReviewStateMachine.states.keys
+  attribute :review_state
+end
+```
+
+This generates:
+
+```typescript
+type Post = {
+  id: number;
+  title: string;
+  status: 'draft' | 'published' | 'archived';
+  review_state: 'pending' | 'approved' | 'rejected';
+}
+```
+
+> **Note:** In arrays, **strings** become string literal types (`'a'`), while **symbols** and **class constants** become type references (`A`). You can mix them: `[:number, "auto"]` produces `number | 'auto'`.
+
 For more complex type definitions, use the full API:
 
 ```ruby
-typelize attribute_name: ["string", "Date", optional: true, nullable: true, multi: true, enum: %w[foo bar], comment: "Attribute description", deprecated: "Use `another_attribute` instead"]
+typelize attribute_name: [:string, :Date, optional: true, nullable: true, multi: true, enum: %w[foo bar], comment: "Attribute description", deprecated: "Use `another_attribute` instead"]
 ```
 
 ### Alba Traits

data/lib/typelizer/dsl/hooks.rb

@@ -29,7 +29,7 @@ module Typelizer
           return unless keyless_type
 
           type, attrs = keyless_type
-          typelize(name => [type, attrs])
+          store_type(:_typelizer_attributes, name, attrs.merge(type: type))
           self.keyless_type = nil
         end
 

data/lib/typelizer/dsl.rb

@@ -73,11 +73,25 @@ module Typelizer
         assign_type_information(:_typelizer_meta_attributes, attributes)
       end
 
+      def store_type(attribute_name, name, options)
+        ensure_type_store(attribute_name)
+        instance_variable_get("@#{attribute_name}")[name.to_sym] ||= {}
+        instance_variable_get("@#{attribute_name}")[name.to_sym].merge!(options)
+      end
+
       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))
+        end
+      end
+
+      def ensure_type_store(attribute_name)
         instance_variable = "@#{attribute_name}"
 
         unless instance_variable_get(instance_variable)
@@ -96,29 +110,6 @@ module Typelizer
             end
           end
         end
-
-        attributes.each do |name, attrs|
-          next unless name
-
-          attrs = [attrs] if attrs && !attrs.is_a?(Array)
-          options = attrs.last.is_a?(Hash) ? attrs.pop : {}
-
-          if attrs.any?
-            parsed_types = attrs.map { |t| TypeParser.parse(t) }
-            all_types = parsed_types.flat_map { |p| Array(p[:type]) }
-            parsed_types.each do |parsed|
-              options[:optional] = true if parsed[:optional]
-              options[:multi] = true if parsed[:multi]
-              options[:nullable] = true if parsed[:nullable]
-            end
-            options[:nullable] = true if all_types.delete(:null)
-            # Unwrap single-element arrays: typelize field: ["string"] behaves like typelize field: "string"
-            options[:type] = (all_types.size == 1) ? all_types.first : all_types
-          end
-
-          instance_variable_get(instance_variable)[name.to_sym] ||= {}
-          instance_variable_get(instance_variable)[name.to_sym].merge!(options)
-        end
       end
     end
   end

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

@@ -111,17 +111,7 @@ module Typelizer
       private
 
       def normalize_typelize(type_def, **options)
-        case type_def
-        when Array
-          # [:string, nullable: true] or ['string?', nullable: true]
-          type, *rest = type_def
-          opts = rest.first || {}
-          TypeParser.parse(type, **opts)
-        when Symbol, String
-          TypeParser.parse(type_def, **options)
-        else
-          options
-        end
+        TypeParser.parse_declaration(type_def, **options)
       end
     end
   end

data/lib/typelizer/type_parser.rb

@@ -10,8 +10,20 @@ module Typelizer
     TYPE_PATTERN = /\A(.+?)(\?)?(\[\])?(\?)?\z/
 
     class << self
+      def parse_declaration(attrs, **options)
+        return options.merge(attrs) if attrs.is_a?(Hash)
+        return parse(attrs, **options) unless attrs.is_a?(Array)
+
+        options = attrs.last.merge(options) if attrs.last.is_a?(Hash)
+        types = attrs.reject { |t| t.is_a?(Hash) }
+        return options if types.empty?
+
+        parse((types.size == 1) ? types.first : types, **options)
+      end
+
       def parse(type_def, **options)
         return options if type_def.nil?
+        return parse_array(type_def, **options) if type_def.is_a?(Array)
 
         type_str = type_def.to_s
         return parse_union(type_str, **options) if type_str.include?("|")
@@ -39,6 +51,31 @@ module Typelizer
 
       private
 
+      def parse_array(type_defs, **options)
+        raise ArgumentError, "Empty array passed to typelize" if type_defs.empty?
+
+        types = []
+        type_defs.each do |t|
+          if t.is_a?(String)
+            types << :"'#{t}'"
+          else
+            parsed = parse(t)
+            types.concat(Array(parsed[:type]))
+            options[:optional] = true if parsed[:optional]
+            options[:multi] = true if parsed[:multi]
+            options[:nullable] = true if parsed[:nullable]
+          end
+        end
+
+        options[:nullable] = true if types.delete(:null)
+        wrap_type(types, **options)
+      end
+
+      def wrap_type(types, **options)
+        type = (types.size == 1) ? types.first : types
+        {type: type}.merge(options)
+      end
+
       def parse_union(type_str, **options)
         parts = UnionTypeSorter.split_union_members(type_str)
 

data/lib/typelizer/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typelizer
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Svyatoslav Kryukov