easy_talk 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af4342f13346bcfb1e54e16fc726f3de5f5630afe889b08a56ff7a5eda62cb18
-  data.tar.gz: 1552e1cf7890f7e51eb0fc05db52d6ba37328115c4c2369ada28f918ddc0848c
+  metadata.gz: 365a704ac1e34ef3ae2796712c0eb13a15030bb9f6184578dc17ac9b2611c2d2
+  data.tar.gz: 94b6ed4d70c16a1ff74b519dfcf6833eb00573a5dc532d6ec7bb3565dc39d208
 SHA512:
-  metadata.gz: ed08994491f42ce37c8fdefd799f03ccf7508ec4812e3f3138b431cfafccfb53138a96068698adc8db062aa1b963010bf2230b9d953622756fa211f94def39dd
-  data.tar.gz: 8154bf2c094dd265a6f9f8579c7ef01f3896190a05ef42476b30e927efc500f8e5aeb5680be2a672b7a9ea7f5a40bd58401136282fa6666355df6513934f186e
+  metadata.gz: 1af20c3dffdc153ac5b251f6170280b46c5ee1d9d068cea2ab74f4a3a585110c820ea4d1b831eee3e0adda974ac0f10f33d7e424df4174b94246c722c0ed9119
+  data.tar.gz: aab1c378d3a1bacbeed497b5613f3e9a45d75a4a7288788ca5b6628aad19b27411895f8c414ff92734920018e87618f70af1a20ac61b6090981764c6c332fec6

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [1.0.4] - 2024-03-12
+### Changed
+- Combined composition builders into a single file (#47)
+  - Improved code organization and maintainability
+  - Refactored internal builder implementation
+
+### Fixed
+- Added support for nilable properties when database column is null (#45)
+  - Better handling of nullable database columns
+  - More accurate schema generation for ActiveRecord models
+
 ## [1.0.3] - 2025-03-11
 ### Added
 - Unified schema generation for both plain Ruby classes and ActiveRecord models (#40)

data/README.md

@@ -860,6 +860,187 @@ property :status, String, enum: ["active", "inactive", "pending"]
 6. Use explicit types instead of relying on inference
 7. Test your schemas with sample data
 
+# Nullable vs Optional Properties in EasyTalk
+
+One of the most important distinctions when defining schemas is understanding the difference between **nullable** properties and **optional** properties. This guide explains these concepts and how to use them effectively in EasyTalk.
+
+## Key Concepts
+
+| Concept | Description | JSON Schema Effect | EasyTalk Syntax |
+|---------|-------------|-------------------|-----------------|
+| **Nullable** | Property can have a `null` value | Adds `"null"` to the type array | `T.nilable(Type)` |
+| **Optional** | Property doesn't have to exist | Omits property from `"required"` array | `optional: true` constraint |
+
+## Nullable Properties
+
+A **nullable** property can contain a `null` value, but the property itself must still be present in the object:
+
+```ruby
+property :age, T.nilable(Integer)
+```
+
+This produces the following JSON Schema:
+
+```json
+{
+  "properties": {
+    "age": { "type": ["integer", "null"] }
+  },
+  "required": ["age"]
+}
+```
+
+In this case, the following data would be valid:
+- `{ "age": 25 }`
+- `{ "age": null }`
+
+But this would be invalid:
+- `{ }` (missing the age property entirely)
+
+## Optional Properties
+
+An **optional** property doesn't have to be present in the object at all:
+
+```ruby
+property :nickname, String, optional: true
+```
+
+This produces:
+
+```json
+{
+  "properties": {
+    "nickname": { "type": "string" }
+  }
+  // Note: "nickname" is not in the "required" array
+}
+```
+
+In this case, the following data would be valid:
+- `{ "nickname": "Joe" }`
+- `{ }` (omitting nickname entirely)
+
+But this would be invalid:
+- `{ "nickname": null }` (null is not allowed because the property isn't nullable)
+
+## Nullable AND Optional Properties
+
+For properties that should be both nullable and optional (can be omitted or null), you need to combine both approaches:
+
+```ruby
+property :bio, T.nilable(String), optional: true
+```
+
+This produces:
+
+```json
+{
+  "properties": {
+    "bio": { "type": ["string", "null"] }
+  }
+  // Note: "bio" is not in the "required" array
+}
+```
+
+For convenience, EasyTalk also provides a helper method:
+
+```ruby
+nullable_optional_property :bio, String
+```
+
+Which is equivalent to the above.
+
+## Configuration Options
+
+By default, nullable properties are still required. You can change this global behavior:
+
+```ruby
+EasyTalk.configure do |config|
+  config.nilable_is_optional = true # Makes all T.nilable properties also optional
+end
+```
+
+With this configuration, any property defined with `T.nilable(Type)` will be treated as both nullable and optional.
+
+## Practical Examples
+
+### User Profile Schema
+
+```ruby
+class UserProfile
+  include EasyTalk::Model
+  
+  define_schema do
+    # Required properties (must exist, cannot be null)
+    property :id, String
+    property :name, String
+    
+    # Required but nullable (must exist, can be null)
+    property :age, T.nilable(Integer)
+    
+    # Optional but not nullable (can be omitted, cannot be null if present)
+    property :email, String, optional: true
+    
+    # Optional and nullable (can be omitted, can be null if present)
+    nullable_optional_property :bio, String
+    
+    # Nested object with mixed property types
+    property :address, Hash do
+      property :street, String # Required
+      property :city, String # Required
+      property :state, String, optional: true # Optional
+      nullable_optional_property :zip, String # Optional and nullable
+    end
+  end
+end
+```
+
+This creates clear expectations for data validation:
+- `id` and `name` must be present and cannot be null
+- `age` must be present but can be null
+- `email` doesn't have to be present, but if it is, it cannot be null
+- `bio` doesn't have to be present, and if it is, it can be null
+
+## Common Gotchas
+
+### Misconception: Nullable Implies Optional
+
+A common mistake is assuming that `T.nilable(Type)` makes a property optional. By default, it only allows the property to have a null value - the property itself is still required to exist in the object.
+
+### Misconception: Optional Properties Accept Null
+
+An optional property (defined with `optional: true`) can be omitted entirely, but if it is present, it must conform to its type constraint. If you want to allow null values, you must also make it nullable with `T.nilable(Type)`.
+
+## Migration from Earlier Versions
+
+If you're upgrading from EasyTalk version 1.0.1 or earlier, be aware that the handling of nullable vs optional properties has been improved for clarity.
+
+To maintain backward compatibility with your existing code, you can use:
+
+```ruby
+EasyTalk.configure do |config|
+  config.nilable_is_optional = true # Makes T.nilable properties behave as they did before
+end
+```
+
+We recommend updating your schema definitions to explicitly declare which properties are optional using the `optional: true` constraint, as this makes your intent clearer.
+
+## Best Practices
+
+1. **Be explicit about intent**: Always clarify whether properties should be nullable, optional, or both
+2. **Use the helper method**: For properties that are both nullable and optional, use `nullable_optional_property`
+3. **Document expectations**: Use comments to clarify validation requirements for complex schemas
+4. **Consider validation implications**: Remember that ActiveModel validations operate independently of the schema definition
+
+## JSON Schema Comparison
+
+| EasyTalk Definition | Required | Nullable | JSON Schema Equivalent |
+|--------------------|----------|----------|------------------------|
+| `property :p, String` | Yes | No | `{ "properties": { "p": { "type": "string" } }, "required": ["p"] }` |
+| `property :p, T.nilable(String)` | Yes | Yes | `{ "properties": { "p": { "type": ["string", "null"] } }, "required": ["p"] }` |
+| `property :p, String, optional: true` | No | No | `{ "properties": { "p": { "type": "string" } } }` |
+| `nullable_optional_property :p, String` | No | Yes | `{ "properties": { "p": { "type": ["string", "null"] } } }` |
+
 ## Development and Contributing
 
 ### Setting Up the Development Environment

data/lib/easy_talk/active_record_schema_builder.rb

@@ -98,6 +98,9 @@ module EasyTalk
         # Map the database type to Ruby type
         ruby_type = COLUMN_TYPE_MAP.fetch(column.type, String)
 
+        # If the column is nullable, wrap the type in a Union with NilClass
+        ruby_type = T::Types::Union.new([ruby_type, NilClass]) if column.null
+
         # Build constraints hash for this column
         constraints = build_column_constraints(column, column_enhancements)
 

data/lib/easy_talk/builders/composition_builder.rb

@@ -60,6 +60,18 @@ module EasyTalk
       def items
         @type.items
       end
+
+      # Builder class for AllOf composition.
+      class AllOfBuilder < CompositionBuilder
+      end
+
+      # Builder class for AnyOf composition.
+      class AnyOfBuilder < CompositionBuilder
+      end
+
+      # Builder class for OneOf composition.
+      class OneOfBuilder < CompositionBuilder
+      end
     end
   end
 end

data/lib/easy_talk/builders/object_builder.rb

@@ -118,6 +118,11 @@ module EasyTalk
         # Check constraints[:optional]
         return true if prop_options.dig(:constraints, :optional)
 
+        # Check for nil_optional config to determine if nilable should also mean optional
+        if prop_options[:type].respond_to?(:nilable?) && prop_options[:type].nilable?
+          return EasyTalk.configuration.nilable_is_optional
+        end
+
         false
       end
 

data/lib/easy_talk/builders/temporal_builder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'string_builder'
+
+module EasyTalk
+  module Builders
+    # Builder class for temporal properties (date, datetime, time).
+    class TemporalBuilder < StringBuilder
+      # Initializes a new instance of the TemporalBuilder class.
+      #
+      # @param property_name [Symbol] The name of the property.
+      # @param options [Hash] The options for the builder.
+      # @param format [String] The format of the temporal property (date, date-time, time).
+      def initialize(property_name, options = {}, format = nil)
+        super(property_name, options)
+        @format = format
+      end
+
+      # Modifies the schema to include the format constraint for a temporal property.
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def schema
+        super.tap do |schema|
+          schema[:format] = @format if @format
+        end
+      end
+
+      # Builder class for date properties.
+      class DateBuilder < TemporalBuilder
+        def initialize(property_name, options = {})
+          super(property_name, options, 'date')
+        end
+      end
+
+      # Builder class for datetime properties.
+      class DatetimeBuilder < TemporalBuilder
+        def initialize(property_name, options = {})
+          super(property_name, options, 'date-time')
+        end
+      end
+
+      # Builder class for time properties.
+      class TimeBuilder < TemporalBuilder
+        def initialize(property_name, options = {})
+          super(property_name, options, 'time')
+        end
+      end
+    end
+  end
+end

data/lib/easy_talk/configuration.rb

@@ -3,7 +3,8 @@
 module EasyTalk
   class Configuration
     attr_accessor :exclude_foreign_keys, :exclude_associations, :excluded_columns,
-                  :exclude_primary_key, :exclude_timestamps, :default_additional_properties
+                  :exclude_primary_key, :exclude_timestamps, :default_additional_properties,
+                  :nilable_is_optional
 
     def initialize
       @exclude_foreign_keys = true
@@ -12,6 +13,7 @@ module EasyTalk
       @exclude_primary_key = true  # New option, defaulting to true
       @exclude_timestamps = true   # New option, defaulting to true
       @default_additional_properties = false
+      @nilable_is_optional = false
     end
   end
 

data/lib/easy_talk/property.rb

@@ -6,12 +6,8 @@ require_relative 'builders/number_builder'
 require_relative 'builders/boolean_builder'
 require_relative 'builders/null_builder'
 require_relative 'builders/string_builder'
-require_relative 'builders/date_builder'
-require_relative 'builders/datetime_builder'
-require_relative 'builders/time_builder'
-require_relative 'builders/any_of_builder'
-require_relative 'builders/all_of_builder'
-require_relative 'builders/one_of_builder'
+require_relative 'builders/temporal_builder'
+require_relative 'builders/composition_builder'
 require_relative 'builders/typed_array_builder'
 require_relative 'builders/union_builder'
 
@@ -40,12 +36,12 @@ module EasyTalk
       'BigDecimal' => Builders::NumberBuilder,
       'T::Boolean' => Builders::BooleanBuilder,
       'NilClass' => Builders::NullBuilder,
-      'Date' => Builders::DateBuilder,
-      'DateTime' => Builders::DatetimeBuilder,
-      'Time' => Builders::TimeBuilder,
-      'anyOf' => Builders::AnyOfBuilder,
-      'allOf' => Builders::AllOfBuilder,
-      'oneOf' => Builders::OneOfBuilder,
+      'Date' => Builders::TemporalBuilder::DateBuilder,
+      'DateTime' => Builders::TemporalBuilder::DatetimeBuilder,
+      'Time' => Builders::TemporalBuilder::TimeBuilder,
+      'anyOf' => Builders::CompositionBuilder::AnyOfBuilder,
+      'allOf' => Builders::CompositionBuilder::AllOfBuilder,
+      'oneOf' => Builders::CompositionBuilder::OneOfBuilder,
       'T::Types::TypedArray' => Builders::TypedArrayBuilder,
       'T::Types::Union' => Builders::UnionBuilder
     }.freeze

data/lib/easy_talk/schema_definition.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'keywords'
+require_relative 'types/composer'
 
 module EasyTalk
   #
@@ -64,5 +65,21 @@ module EasyTalk
     def optional?
       @schema[:optional]
     end
+
+    # Helper method for nullable and optional properties
+    def nullable_optional_property(name, type, constraints = {}, &blk)
+      # Ensure type is nilable
+      nilable_type = if type.respond_to?(:nilable?) && type.nilable?
+                       type
+                     else
+                       T.nilable(type)
+                     end
+
+      # Ensure constraints include optional: true
+      constraints = constraints.merge(optional: true)
+
+      # Call standard property method
+      property(name, nilable_type, constraints, &blk)
+    end
   end
 end

data/lib/easy_talk/types/composer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'base_composer'
+
+module EasyTalk
+  module Types
+    # Base class for composition types
+    class Composer < BaseComposer
+      # Returns the name of the composition type.
+      def self.name
+        raise NotImplementedError, "#{self.class.name} must implement the name method"
+      end
+
+      # Returns the name of the composition type.
+      def name
+        self.class.name
+      end
+
+      # Represents a composition type that allows all of the specified types.
+      class AllOf < Composer
+        def self.name
+          :allOf
+        end
+
+        def name
+          :allOf
+        end
+      end
+
+      # Represents a composition type that allows any of the specified types.
+      class AnyOf < Composer
+        def self.name
+          :anyOf
+        end
+
+        def name
+          :anyOf
+        end
+      end
+
+      # Represents a composition type that allows one of the specified types.
+      class OneOf < Composer
+        def self.name
+          :oneOf
+        end
+
+        def name
+          :oneOf
+        end
+      end
+    end
+  end
+end
+
+# Shorthand module for accessing the AllOf composer
+module T
+  module AllOf
+    # Creates a new instance of `EasyTalk::Types::Composer::AllOf` with the given arguments.
+    #
+    # @param args [Array] the list of arguments to be passed to the constructor
+    # @return [EasyTalk::Types::Composer::AllOf] a new instance
+    def self.[](*args)
+      EasyTalk::Types::Composer::AllOf.new(*args)
+    end
+  end
+
+  # Shorthand module for accessing the AnyOf composer
+  module AnyOf
+    # Creates a new instance of `EasyTalk::Types::Composer::AnyOf` with the given arguments.
+    #
+    # @param args [Array] the list of arguments to be passed to the constructor
+    # @return [EasyTalk::Types::Composer::AnyOf] a new instance
+    def self.[](*args)
+      EasyTalk::Types::Composer::AnyOf.new(*args)
+    end
+  end
+
+  # Shorthand module for accessing the OneOf composer
+  module OneOf
+    # Creates a new instance of `EasyTalk::Types::Composer::OneOf` with the given arguments.
+    #
+    # @param args [Array] the list of arguments to be passed to the constructor
+    # @return [EasyTalk::Types::Composer::OneOf] a new instance
+    def self.[](*args)
+      EasyTalk::Types::Composer::OneOf.new(*args)
+    end
+  end
+end

data/lib/easy_talk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EasyTalk
-  VERSION = '1.0.3'
+  VERSION = '1.0.4'
 end

data/lib/easy_talk.rb

@@ -7,9 +7,7 @@ module EasyTalk
   require 'easy_talk/errors'
   require 'easy_talk/errors_helper'
   require 'easy_talk/configuration'
-  require 'easy_talk/types/any_of'
-  require 'easy_talk/types/all_of'
-  require 'easy_talk/types/one_of'
+  require 'easy_talk/types/composer'
   require 'easy_talk/model'
   require 'easy_talk/property'
   require 'easy_talk/schema_definition'
@@ -24,4 +22,8 @@ module EasyTalk
       ErrorHelper.raise_unknown_option_error(property_name: property_name, option: options, valid_options: valid_keys)
     end
   end
+
+  def self.configure_nilable_behavior(nilable_is_optional = false)
+    configuration.nilable_is_optional = nilable_is_optional
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: easy_talk
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Sergio Bayona
 bindir: bin
 cert_chain: []
-date: 2025-03-11 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -213,21 +213,16 @@ files:
 - docs/index.markdown
 - lib/easy_talk.rb
 - lib/easy_talk/active_record_schema_builder.rb
-- lib/easy_talk/builders/all_of_builder.rb
-- lib/easy_talk/builders/any_of_builder.rb
 - lib/easy_talk/builders/base_builder.rb
 - lib/easy_talk/builders/boolean_builder.rb
 - lib/easy_talk/builders/collection_helpers.rb
 - lib/easy_talk/builders/composition_builder.rb
-- lib/easy_talk/builders/date_builder.rb
-- lib/easy_talk/builders/datetime_builder.rb
 - lib/easy_talk/builders/integer_builder.rb
 - lib/easy_talk/builders/null_builder.rb
 - lib/easy_talk/builders/number_builder.rb
 - lib/easy_talk/builders/object_builder.rb
-- lib/easy_talk/builders/one_of_builder.rb
 - lib/easy_talk/builders/string_builder.rb
-- lib/easy_talk/builders/time_builder.rb
+- lib/easy_talk/builders/temporal_builder.rb
 - lib/easy_talk/builders/typed_array_builder.rb
 - lib/easy_talk/builders/union_builder.rb
 - lib/easy_talk/configuration.rb
@@ -239,10 +234,8 @@ files:
 - lib/easy_talk/schema_definition.rb
 - lib/easy_talk/sorbet_extension.rb
 - lib/easy_talk/tools/function_builder.rb
-- lib/easy_talk/types/all_of.rb
-- lib/easy_talk/types/any_of.rb
 - lib/easy_talk/types/base_composer.rb
-- lib/easy_talk/types/one_of.rb
+- lib/easy_talk/types/composer.rb
 - lib/easy_talk/version.rb
 homepage: https://github.com/sergiobayona/easy_talk
 licenses:

data/lib/easy_talk/builders/all_of_builder.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'composition_builder'
-
-module EasyTalk
-  module Builders
-    # Builder class for integer properties.
-    class AllOfBuilder < CompositionBuilder
-    end
-  end
-end

data/lib/easy_talk/builders/any_of_builder.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'composition_builder'
-
-module EasyTalk
-  module Builders
-    # Builder class for integer properties.
-    class AnyOfBuilder < CompositionBuilder
-    end
-  end
-end

data/lib/easy_talk/builders/date_builder.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_builder'
-
-module EasyTalk
-  module Builders
-    # Builder class for date properties.
-    class DateBuilder < StringBuilder
-      # Modifies the schema to include the format constraint for a date property.
-      sig { returns(T::Hash[Symbol, T.untyped]) }
-      def schema
-        super.tap do |schema|
-          schema[:format] = 'date'
-        end
-      end
-    end
-  end
-end

data/lib/easy_talk/builders/datetime_builder.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_builder'
-
-module EasyTalk
-  module Builders
-    # Builder class for datetime properties.
-    class DatetimeBuilder < StringBuilder
-      # Modifies the schema to include the format constraint for a datetime property.
-      sig { returns(T::Hash[Symbol, T.untyped]) }
-      def schema
-        super.tap do |schema|
-          schema[:format] = 'date-time'
-        end
-      end
-    end
-  end
-end

data/lib/easy_talk/builders/one_of_builder.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'composition_builder'
-
-module EasyTalk
-  module Builders
-    # Builder class for integer properties.
-    class OneOfBuilder < CompositionBuilder
-    end
-  end
-end

data/lib/easy_talk/builders/time_builder.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_builder'
-
-module EasyTalk
-  module Builders
-    # Builder class for time properties.
-    class TimeBuilder < StringBuilder
-      def schema
-        super.tap do |schema|
-          schema[:format] = 'time'
-        end
-      end
-    end
-  end
-end

data/lib/easy_talk/types/all_of.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_composer'
-# The EasyTalk module provides a collection of types for composing schemas.
-module EasyTalk
-  # The `Types` module provides a collection of classes for composing different types.
-  module Types
-    # Represents a composition type that allows all of the specified types.
-    class AllOf < BaseComposer
-      def self.name
-        :allOf
-      end
-
-      def name
-        :allOf
-      end
-    end
-  end
-end
-
-module T
-  # no-doc
-  module AllOf
-    # Creates a new instance of `EasyTalk::Types::AllOf` with the given arguments.
-    #
-    # @param args [Array] the list of arguments to be passed to the `EasyTalk::Types::AllOf` constructor
-    # @return [EasyTalk::Types::AllOf] a new instance of `EasyTalk::Types::AllOf`
-    def self.[](*args)
-      EasyTalk::Types::AllOf.new(*args)
-    end
-  end
-end

data/lib/easy_talk/types/any_of.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_composer'
-module EasyTalk
-  module Types
-    # The `Types` module provides a collection of composers for defining different types.
-    #
-    # This module contains composers for various types such as `AnyOf`, `AllOf`, etc.
-    # Each composer is responsible for defining the behavior and properties of its respective type.
-    class AnyOf < BaseComposer
-      # Returns the name of the AnyOf composer.
-      #
-      # @return [Symbol] The name of the composer.
-      def self.name
-        :anyOf
-      end
-
-      # Returns the name of the AnyOf composer.
-      #
-      # @return [Symbol] The name of the composer.
-      def name
-        :anyOf
-      end
-    end
-  end
-end
-
-module T
-  # no-doc
-  module AnyOf
-    # Creates a new instance of `EasyTalk::Types::AnyOf` with the given arguments.
-    #
-    # @param args [Array] the list of arguments to be passed to the `EasyTalk::Types::AnyOf` constructor
-    # @return [EasyTalk::Types::AnyOf] a new instance of `EasyTalk::Types::AnyOf`
-    def self.[](*args)
-      EasyTalk::Types::AnyOf.new(*args)
-    end
-  end
-end

data/lib/easy_talk/types/one_of.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_composer'
-module EasyTalk
-  module Types
-    # Represents a composition type that allows one of the specified types.
-    class OneOf < BaseComposer
-      # Returns the name of the composition type.
-      def self.name
-        :oneOf
-      end
-
-      # Returns the name of the composition type.
-      def name
-        :oneOf
-      end
-    end
-  end
-end
-
-module T
-  # Creates a new instance of `EasyTalk::Types::OneOf` with the given arguments.
-  #
-  # @param args [Array] the list of arguments to be passed to the `EasyTalk::Types::OneOf` constructor
-  # @return [EasyTalk::Types::OneOf] a new instance of `EasyTalk::Types::OneOf`
-  module OneOf
-    def self.[](*args)
-      EasyTalk::Types::OneOf.new(*args)
-    end
-  end
-end