typed_attrs 0.1.0

data/lib/typed_attrs/type_processors/nilable_type.rb

@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class NilableType < Base
+      extend T::Sig
+      extend TypeHelpers
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        nilable_type?(type_spec)
+      end
+
+      sig { params(type_spec: T.untyped, registry: Registry).void }
+      def initialize(type_spec, registry:)
+        super
+
+        @inner_type = T.let(self.class.extract_nilable_inner_type(type_spec), T.untyped)
+        @inner_serializer = T.let(@registry.serializer_for(@inner_type), Base)
+      end
+
+      sig { override.params(value: T.untyped).returns(T.untyped) }
+      def serialize(value)
+        return nil if value.nil?
+
+        @inner_serializer.serialize(value)
+      end
+
+      sig { override.params(value: T.untyped).returns(T.untyped) }
+      def deserialize(value)
+        return nil if value.nil?
+
+        @inner_serializer.deserialize(value)
+      end
+
+      sig do
+        override.params(
+          value: T.untyped,
+          path: ::String,
+          blk: T.proc.params(type_spec: T.untyped, node: T.untyped, path: ::String).void
+        ).void
+      end
+      def traverse(value, path: "", &blk)
+        super
+
+        return if value.nil?
+
+        @inner_serializer.traverse(value, path: path, &blk)
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/registry.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class UnknownTypeError < StandardError; end
+
+    class Registry
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        @serializers = T.let([], T::Array[T.class_of(Base)])
+      end
+
+      sig { params(serializer_class: T.class_of(Base)).void }
+      def register(serializer_class)
+        @serializers << serializer_class
+      end
+
+      sig { params(type_spec: T.untyped).returns(T.class_of(Base)) }
+      def find_serializer(type_spec)
+        serializer_class = @serializers.find { |s| s.handles?(type_spec) }
+        raise UnknownTypeError, "No serializer for #{type_spec}" unless serializer_class
+
+        serializer_class
+      end
+
+      sig { params(type_spec: T.untyped).returns(Base) }
+      def serializer_for(type_spec)
+        find_serializer(type_spec).new(type_spec, registry: self)
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/simple_type.rb

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class SimpleType < Base
+      extend T::Sig
+      include TypeHelpers
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec.is_a?(T::Types::Simple)
+      end
+
+      sig { params(type_spec: T.untyped, registry: Registry).void }
+      def initialize(type_spec, registry:)
+        super
+        unless type_spec.is_a?(T::Types::Simple)
+          raise ArgumentError, "Expected T::Types::Simple, got #{type_spec.class}"
+        end
+
+        @raw_type = T.let(type_spec.raw_type, T.untyped)
+      end
+
+      sig { override.params(value: T.untyped).returns(T.untyped) }
+      def serialize(value)
+        serializer = @registry.serializer_for(@raw_type)
+        serializer.serialize(value)
+      end
+
+      sig { override.params(value: T.untyped).returns(T.untyped) }
+      def deserialize(value)
+        serializer = @registry.serializer_for(@raw_type)
+        serializer.deserialize(value)
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/string.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class String < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec == ::String
+      end
+
+      sig { override.params(value: T.untyped).returns(::String) }
+      def serialize(value)
+        unless value.is_a?(::String)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected String, got #{value.class}",
+            value: value
+          )
+        end
+
+        value
+      end
+
+      sig { override.params(value: T.untyped).returns(::String) }
+      def deserialize(value)
+        unless value.is_a?(::String)
+          raise TypedAttrs::DeserializationError.new(
+            "Expected String, got #{value.class}",
+            value: value
+          )
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/struct.rb

@@ -0,0 +1,70 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Struct < Base
+      extend T::Sig
+      extend TypeHelpers
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        struct_class?(type_spec)
+      end
+
+      sig { params(type_spec: T.untyped, registry: Registry).void }
+      def initialize(type_spec, registry:)
+        super
+        unless type_spec.is_a?(Class) && type_spec < T::Struct
+          raise ArgumentError, "Expected T::Struct, got #{type_spec}"
+        end
+
+        @struct_class = T.let(type_spec, T.class_of(T::Struct))
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Hash[::String, T.untyped]) }
+      def serialize(value)
+        unless value.is_a?(@struct_class)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected #{@struct_class}, got #{value.class}",
+            value: value
+          )
+        end
+
+        @struct_class.props.each_with_object({}) do |(name, prop_def), hash|
+          prop_value = value.public_send(name)
+
+          prop_type = prop_def[:type_object]
+          serializer = @registry.serializer_for(prop_type)
+          hash[name.to_s] = serializer.serialize(prop_value)
+        end
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Struct) }
+      def deserialize(value)
+        return value if value.is_a?(@struct_class)
+
+        unless value.is_a?(::Hash)
+          raise TypedAttrs::DeserializationError.new(
+            "Expected Hash, got #{value.class}",
+            value: value
+          )
+        end
+
+        symbolized = value.transform_keys(&:to_sym)
+
+        deserialized = @struct_class.props.each_with_object({}) do |(name, prop_def), hash|
+          next unless symbolized.key?(name)
+
+          prop_value = symbolized[name]
+
+          prop_type = prop_def[:type_object]
+          serializer = @registry.serializer_for(prop_type)
+          hash[name] = serializer.deserialize(prop_value)
+        end
+
+        @struct_class.new(**deserialized)
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/symbol.rb

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Symbol < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec == ::Symbol
+      end
+
+      sig { override.params(value: T.untyped).returns(::String) }
+      def serialize(value)
+        unless value.is_a?(::Symbol)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected Symbol, got #{value.class}",
+            value: value
+          )
+        end
+
+        value.to_s
+      end
+
+      sig { override.params(value: T.untyped).returns(::Symbol) }
+      def deserialize(value)
+        return value if value.is_a?(::Symbol)
+
+        unless value.is_a?(::String)
+          raise TypedAttrs::DeserializationError.new(
+            "Expected String or Symbol, got #{value.class}",
+            value: value
+          )
+        end
+
+        value.to_sym
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/time.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Time < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec == ::Time
+      end
+
+      sig { override.params(value: T.untyped).returns(::String) }
+      def serialize(value)
+        unless value.is_a?(::Time)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected Time, got #{value.class}",
+            value: value
+          )
+        end
+
+        value.iso8601
+      end
+
+      sig { override.params(value: T.untyped).returns(::Time) }
+      def deserialize(value)
+        case value
+        when ::Time
+          value
+        when ::String
+          ::Time.iso8601(value)
+        else
+          raise TypedAttrs::DeserializationError.new(
+            "Expected Time or String, got #{value.class}",
+            value: value
+          )
+        end
+      rescue ArgumentError => e
+        raise TypedAttrs::DeserializationError.new(
+          "Failed to deserialize Time: #{e.message}",
+          value: value
+        )
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    extend T::Sig
+
+    sig { returns(Registry) }
+    def self.default_registry
+      @default_registry ||= T.let(build_default_registry, T.nilable(Registry))
+    end
+
+    sig { returns(Registry) }
+    def self.build_default_registry
+      registry = Registry.new
+
+      # Register in search order (more specific types first)
+      registry.register(SimpleType)             # Unwrap T::Types::Simple (first)
+      registry.register(NilableType)            # Handle T.nilable(...)
+      registry.register(Array)                  # Handle T::Array[...]
+      registry.register(Hash)                   # Handle T::Hash[...]
+      registry.register(DiscriminatedUnion)     # Handle DiscriminatedUnion
+      registry.register(Integer)                # Handle Integer
+      registry.register(Float)                  # Handle Float
+      registry.register(Boolean)                # Handle T::Boolean
+      registry.register(BooleanPrimitive)       # Handle TrueClass/FalseClass
+      registry.register(String)                 # Handle String
+      registry.register(Symbol)                 # Handle Symbol
+      registry.register(Date)                   # Handle Date
+      registry.register(Time)                   # Handle Time
+      registry.register(Struct)                 # Handle T::Struct (last)
+
+      registry
+    end
+  end
+end

data/lib/typed_attrs/types/type.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module Types
+    class Type < ActiveModel::Type::Value
+      include TypeHelpers
+      extend T::Sig
+
+      sig { params(type_spec: T.untyped).void }
+      def initialize(type_spec)
+        super()
+        @type_spec = type_spec
+
+        registry = T.let(TypeProcessors.default_registry, TypeProcessors::Registry)
+        @processor = T.let(registry.serializer_for(type_spec), TypeProcessors::Base)
+      end
+
+      sig { returns(TypeProcessors::Base) }
+      attr_reader :processor
+
+      sig { params(value: T.untyped).returns(T.untyped) }
+      def cast(value)
+        return nil if value.nil?
+
+        @processor.deserialize(value)
+      end
+
+      sig { params(value: T.untyped).returns(T.untyped) }
+      def serialize(value)
+        return nil if value.nil?
+
+        serialized = @processor.serialize(value)
+        ActiveSupport::JSON.encode(serialized)
+      end
+
+      sig { params(value: T.untyped).returns(T.untyped) }
+      def deserialize(value)
+        return nil if value.nil?
+
+        data = if value.is_a?(String)
+                 ActiveSupport::JSON.decode(value)
+               else
+                 value
+               end
+
+        @processor.deserialize(data)
+      end
+    end
+  end
+end

data/lib/typed_attrs/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  VERSION = "0.1.0"
+end

data/lib/typed_attrs.rb

@@ -0,0 +1,103 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require "active_model"
+
+require_relative "typed_attrs/version"
+require_relative "typed_attrs/type_helpers"
+require_relative "typed_attrs/type_processors/registry"
+require_relative "typed_attrs/type_processors"
+require_relative "typed_attrs/type_processors/base"
+require_relative "typed_attrs/type_processors/simple_type"
+require_relative "typed_attrs/type_processors/nilable_type"
+require_relative "typed_attrs/type_processors/integer"
+require_relative "typed_attrs/type_processors/float"
+require_relative "typed_attrs/type_processors/boolean"
+require_relative "typed_attrs/type_processors/boolean_primitive"
+require_relative "typed_attrs/type_processors/string"
+require_relative "typed_attrs/type_processors/symbol"
+require_relative "typed_attrs/type_processors/date"
+require_relative "typed_attrs/type_processors/time"
+require_relative "typed_attrs/type_processors/struct"
+require_relative "typed_attrs/type_processors/array"
+require_relative "typed_attrs/type_processors/hash"
+require_relative "typed_attrs/type_processors/discriminated_union"
+require_relative "typed_attrs/types/type"
+require_relative "typed_attrs/discriminated_union"
+require_relative "active_model/validations/typed_attrs_validator"
+
+module TypedAttrs
+  extend T::Sig
+
+  # Exception class for type mismatch errors during serialization/deserialization/traversal
+  class TypeMismatchError < StandardError
+    extend T::Sig
+
+    sig { params(message: String, value: T.untyped).void }
+    def initialize(message, value: nil)
+      @value = value
+      super(message)
+    end
+
+    sig { returns(T.untyped) }
+    attr_reader :value
+  end
+
+  # Exception class for deserialization errors
+  class DeserializationError < StandardError
+    extend T::Sig
+
+    sig { params(message: String, value: T.untyped).void }
+    def initialize(message, value: nil)
+      @value = value
+      super(message)
+    end
+
+    sig { returns(T.untyped) }
+    attr_reader :value
+  end
+
+  # Exception class for missing union discriminator value
+  class MissingDiscriminatorValueError < StandardError
+    extend T::Sig
+
+    sig { params(struct_class: T.class_of(T::Struct)).void }
+    def initialize(struct_class)
+      super(
+        "Union discriminator value is not defined for #{struct_class}. " \
+        "Please add 'union_discriminator_value \"value\"' to the class definition."
+      )
+    end
+  end
+
+  class EmptyUnionModuleError < StandardError
+    extend T::Sig
+
+    sig { params(union_module: BasicObject).void }
+    def initialize(union_module)
+      super(
+        "Union module #{union_module} is empty. Please add 'sealed!', 'discriminator_key \"key\"', " \
+        "and at least one T::Struct subclass."
+      )
+    end
+  end
+
+  # Exception class for missing union discriminator key
+  class MissingDiscriminatorKeyError < StandardError
+    extend T::Sig
+
+    sig { params(union_module: T.untyped).void }
+    def initialize(union_module)
+      super(
+        "Union discriminator key is not defined for #{union_module}. " \
+        "Please add 'discriminator_key \"key\"' to the module definition."
+      )
+    end
+  end
+
+  sig { params(type_spec: T.untyped).returns(Types::Type) }
+  def self.to_type(type_spec)
+    Types::Type.new(type_spec)
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: typed_attrs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Speria
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: TypedAttrs integrates Sorbet's T::Struct with ActiveRecord's JSON/JSONB
+  columns, providing type-safe structured data storage with runtime and static type
+  checking. Supports nested structs, arrays, hashes, union types, and automatic validation.
+email:
+- daichi.sakai@speria.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/active_model/validations/typed_attrs_validator.rb
+- lib/tapioca/dsl/compilers/typed_attribute.rb
+- lib/typed_attrs.rb
+- lib/typed_attrs/discriminated_union.rb
+- lib/typed_attrs/type_helpers.rb
+- lib/typed_attrs/type_processors.rb
+- lib/typed_attrs/type_processors/array.rb
+- lib/typed_attrs/type_processors/base.rb
+- lib/typed_attrs/type_processors/boolean.rb
+- lib/typed_attrs/type_processors/boolean_primitive.rb
+- lib/typed_attrs/type_processors/date.rb
+- lib/typed_attrs/type_processors/discriminated_union.rb
+- lib/typed_attrs/type_processors/float.rb
+- lib/typed_attrs/type_processors/hash.rb
+- lib/typed_attrs/type_processors/integer.rb
+- lib/typed_attrs/type_processors/nilable_type.rb
+- lib/typed_attrs/type_processors/registry.rb
+- lib/typed_attrs/type_processors/simple_type.rb
+- lib/typed_attrs/type_processors/string.rb
+- lib/typed_attrs/type_processors/struct.rb
+- lib/typed_attrs/type_processors/symbol.rb
+- lib/typed_attrs/type_processors/time.rb
+- lib/typed_attrs/types/type.rb
+- lib/typed_attrs/version.rb
+homepage: https://github.com/speria-jp/typed_attrs
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/speria-jp/typed_attrs
+  source_code_uri: https://github.com/speria-jp/typed_attrs.git
+  changelog_uri: https://github.com/speria-jp/typed_attrs/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/speria-jp/typed_attrs/issues
+  documentation_uri: https://github.com/speria-jp/typed_attrs/blob/master/README.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Type-safe ActiveRecord attributes using Sorbet T::Struct
+test_files: []