typelizer 0.9.3 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e0f1018fd5d37ab4171501db8961c7895e796f1f41bf292c773f6d39fa08832
-  data.tar.gz: 3ab825f73e774cb8d13bb61772c878501e25b42f7e1b3ad35ae2a7a6a31e2d32
+  metadata.gz: bc23d62a95119b1ff871bcde1eeb0c3180cc0fe1e38fa1252edad30a454661bc
+  data.tar.gz: 2658b01eebb6f9317ff4905f6c482cbdfa55afcadd4ba6508e1cd9b5469072da
 SHA512:
-  metadata.gz: 31b6a138ee7ae3c95f173f2df1f2168469b285aeff266c350c27a95b51021fa2deeb43bea1f9b28a0f9a4114a6ff4af9f82e47e64f04dcf314c88dfa9d042936
-  data.tar.gz: ccd0cb33a718fedae63e46e83bc7495d6b3520d7bfe6b190e2021e98f0f986ed36ca970dd25a71acbcc9017fd1b4b7579fb2399cf6727c92c2a13a1f38d84d80
+  metadata.gz: 237f41ebfc6999a73c30e97a89dab3435638c49bac38ff8072493b62833fd7a6c7d5cd7655868bf07c958b879c906c4c38bd809331cad1827b37529183c1aae3
+  data.tar.gz: b882bab4aea8a599b69e39c296a8794cf1fa357ec20f092649d5fa7e7d80bf2fb05ffff69b4362f7e0aa0be9b669724933a4167bfe403f9ce094e37254dfc9e8

data/CHANGELOG.md

@@ -7,6 +7,12 @@ 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
@@ -433,7 +439,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.9.3...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

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.rb

@@ -87,8 +87,7 @@ module Typelizer
         attributes.each do |name, attrs|
           next unless name
 
-          options = parse_type_declaration(attrs)
-          store_type(attribute_name, name, options)
+          store_type(attribute_name, name, TypeParser.parse_declaration(attrs))
         end
       end
 
@@ -112,26 +111,6 @@ module Typelizer
           end
         end
       end
-
-      def parse_type_declaration(attrs)
-        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
-
-        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,6 +10,17 @@ 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)
@@ -41,22 +52,28 @@ module Typelizer
       private
 
       def parse_array(type_defs, **options)
-        parsed = type_defs.map { |t| parse(t) }
-        types = parsed.flat_map { |p| Array(p[:type]) }
-
-        parsed.each do |p|
-          options[:optional] = true if p[:optional]
-          options[:multi] = true if p[:multi]
-          options[:nullable] = true if p[:nullable]
+        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
 
-        if types.size == 1
-          {type: types.first}.merge(options)
-        else
-          {type: types}.merge(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)

data/lib/typelizer/version.rb

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

metadata

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