camille 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cce4fa44ca836262ebc8da14ad045ee0b5ea2ce832fd6852e863280c04b6658
-  data.tar.gz: cfc0c1797ce19035efd81de11b1176154f50575b3d4a90834ef6de517ef1ea4b
+  metadata.gz: a996817e4aeefb69d5eca3c893c5ce8a5fb8edebf63a24c80913c5ea436aeadd
+  data.tar.gz: b7b70010798e0578b8e1ce44bc50610b412b1de49ea7aad53db0313fb4c3b89b
 SHA512:
-  metadata.gz: f502c8340be0ecb804982d811a35072188e7cb1fdc6602cc2c986cea94228caaae2d650d4379c3ba413299186bd8753befc51f6e6943d720384a841b876425f5
-  data.tar.gz: cf6fc100a3e11ade528d88d5fbe89451c37866a218b7ddb2c0b0fc18645b7ceb40dd393b813af80ac22908d545017fa6bfe74927010a67ce1fb4c35b7ff8928d
+  metadata.gz: cf8fc03e76741bc2515a5cc5fdeb869e8faa4bdb2292d4e68eeddaa2e7c597619de36a708aae04575abee1feec7efb07788e293b22ff4cf78e87ca68d3903ad3
+  data.tar.gz: 3bb4f395f92419c56ccd8b21b85d0da2dc1588530a03e0024a4e236053c97440031b06feb6593cce0012e95fc66b54653e3f1ea2894d7e37618c344ab0c282af

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.3.0
+
+### Added
+
+* Added option to check controller params type: `config.check_params`.
+
+## 1.2.0
+
+### Added
+
+* Added `TypeLiteralGenerator` and `SchemaLiteralGenerator` to allow partial endpoint generation with `CodeGenerator`.
+
 ## 1.1.0
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    camille (1.0.0)
+    camille (1.2.0)
       rails (>= 6.1, < 8.1)
 
 GEM

data/lib/camille/basic_type.rb

@@ -41,6 +41,10 @@ module Camille
       raise NotImplementedError
     end
 
+    def check_params value
+      check value
+    end
+
     def self.| other
       Camille::Type.instance(self) | other
     end
@@ -53,6 +57,10 @@ module Camille
       Camille::Type.instance(self)[]
     end
 
+    def self.check_params value
+      Camille::Type.instance(self).check_params value
+    end
+
     def self.directly_instantiable?
       instance_method(:initialize).arity == 0
     end

data/lib/camille/code_generator.rb

@@ -1,21 +1,38 @@
 require 'stringio'
 
 module Camille
-  module CodeGenerator
-    def self.generate_ts
+  class CodeGenerator
+    def initialize types_literal_lines: Camille::Types.literal_lines, schemas_literal_lines: Camille::Schemas.literal_lines
+      @types_literal_lines = types_literal_lines
+      @schemas_literal_lines = schemas_literal_lines
+    end
+
+    def generate_ts
       io = StringIO.new
-      io.puts Camille::Configuration.ts_header
-      io.puts
-      Camille::Types.literal_lines.each do |line|
-        io.puts "export #{line}"
-      end
-      io.puts
-      io.print "export default "
-      Camille::Schemas.literal_lines.each do |line|
-        io.puts line
-      end
+      generate_header io
+      generate_types io
+      generate_schemas io
       io.string
     end
 
+    private
+      def generate_header io
+        io.puts Camille::Configuration.ts_header
+        io.puts
+      end
+
+      def generate_types io
+        @types_literal_lines.each do |line|
+          io.puts "export #{line}"
+        end
+        io.puts
+      end
+
+      def generate_schemas io
+        io.print "export default "
+        @schemas_literal_lines.each do |line|
+          io.puts line
+        end
+      end
   end
 end

data/lib/camille/configuration.rb

@@ -3,7 +3,7 @@ module Camille
   class Configuration
     class << self
       attr_reader :response_key_converter, :params_key_converter
-      attr_accessor :ts_header, :ts_location
+      attr_accessor :ts_header, :ts_location, :check_params
 
       def load_default_configurations
         self.response_key_converter = lambda do |string|
@@ -13,6 +13,8 @@ module Camille
         self.params_key_converter = lambda do |string|
           string.underscore
         end
+
+        self.check_params = false
       end
 
       def response_key_converter= lambda

data/lib/camille/controller.rb

@@ -43,7 +43,26 @@ module Camille
       Camille::Loader.check_and_raise_exception
       if endpoint = camille_endpoint
         begin
-          params.deep_transform_keys!{|key| Camille::Configuration.params_key_converter.call(key.to_s)}
+          if Camille::Configuration.check_params
+            # New way: check params against the endpoint's params_type if it exists
+            if endpoint.params_type
+              params_to_check = params.to_unsafe_h
+              check_result = endpoint.params_type.check_params(params_to_check)
+
+              if check_result.type_error?
+                string_io = StringIO.new
+                Camille::TypeErrorPrinter.new(check_result).print(string_io)
+                raise TypeError.new("\nType check failed for params.\n#{string_io.string}")
+              else
+                # Use the checked value which already has snake_case keys
+                self.params = ActionController::Parameters.new(check_result.value)
+              end
+            end
+          else
+            # Old way: just transform keys
+            params.deep_transform_keys!{|key| Camille::Configuration.params_key_converter.call(key.to_s)}
+          end
+
           result = super
           # When there's no `render` call, Rails will return status 204
           if response.status == 204

data/lib/camille/generators/templates/configuration.rb

@@ -4,4 +4,9 @@ Camille.configure do |config|
     // DO NOT EDIT! This file is automatically generated.
     import request from './request'
   EOF
+
+  # Enable type checking for controller parameters.
+  # When enabled, params will be validated against the schema and automatically
+  # converted from camelCase to snake_case.
+  config.check_params = true
 end

data/lib/camille/main_controller.rb

@@ -4,7 +4,7 @@ module Camille
   class MainController < ActionController::Base
     def endpoints_ts
       Camille::Loader.check_and_raise_exception
-      render plain: Camille::CodeGenerator.generate_ts
+      render plain: Camille::CodeGenerator.new.generate_ts
     end
   end
 end

data/lib/camille/schema_literal_generator.rb

@@ -0,0 +1,51 @@
+module Camille
+  class SchemaLiteralGenerator
+    def initialize schemas
+      @schemas = schemas
+    end
+
+    def literal_lines
+      [
+        Camille::Line.new('{'),
+        tree_literal_lines(namespace_tree).map(&:do_indent),
+        Camille::Line.new('}')
+      ]
+    end
+
+    private
+      def namespace_tree
+        tree = {}
+
+        @schemas.sort_by(&:klass_name).each do |s|
+          path = s.klass_name.split('::')
+          *namespaces, schema_name = path
+
+          level = namespaces.inject(tree) do |level, namespace|
+            level[namespace] ||= {}
+            level[namespace]
+          end
+
+          level[schema_name] = s
+        end
+
+        tree
+      end
+
+      def tree_literal_lines tree
+        tree.map do |key, value|
+          if value.is_a? ::Hash
+            [
+              Camille::Line.new("#{Camille::Configuration.response_key_converter.call(key.to_s)}: {"),
+              tree_literal_lines(value).map(&:do_indent),
+              Camille::Line.new('},')
+            ]
+          else
+            value.literal_lines.tap do |lines|
+              lines.first.prepend("#{Camille::Configuration.response_key_converter.call(key.to_s)}: ")
+              lines.last.append(',')
+            end
+          end
+        end.flatten
+      end
+  end
+end

data/lib/camille/schemas.rb

@@ -1,47 +1,7 @@
 module Camille
   module Schemas
     def self.literal_lines
-      [
-        Camille::Line.new('{'),
-        tree_literal_lines(namespace_tree).map(&:do_indent),
-        Camille::Line.new('}')
-      ]
+      Camille::SchemaLiteralGenerator.new(Camille::Loader.loaded_schemas).literal_lines
     end
-
-    private
-      def self.namespace_tree
-        tree = {}
-
-        Camille::Loader.loaded_schemas.sort_by(&:klass_name).each do |s|
-          path = s.klass_name.split('::')
-          *namespaces, schema_name = path
-
-          level = namespaces.inject(tree) do |level, namespace|
-            level[namespace] ||= {}
-            level[namespace]
-          end
-
-          level[schema_name] = s
-        end
-
-        tree
-      end
-
-      def self.tree_literal_lines tree
-        tree.map do |key, value|
-          if value.is_a? ::Hash
-            [
-              Camille::Line.new("#{Camille::Configuration.response_key_converter.call(key.to_s)}: {"),
-              tree_literal_lines(value).map(&:do_indent),
-              Camille::Line.new('},')
-            ]
-          else
-            value.literal_lines.tap do |lines|
-              lines.first.prepend("#{Camille::Configuration.response_key_converter.call(key.to_s)}: ")
-              lines.last.append(',')
-            end
-          end
-        end.flatten
-      end
   end
 end

data/lib/camille/type.rb

@@ -23,10 +23,18 @@ module Camille
       @underlying.check value
     end
 
+    def check_params value
+      @underlying.check_params value
+    end
+
     def self.check value
       new.check value
     end
 
+    def self.check_params value
+      new.check_params value
+    end
+
     def self.klass_name
       name.gsub(/^Camille::Types::/, '')
     end

data/lib/camille/type_literal_generator.rb

@@ -0,0 +1,14 @@
+module Camille
+  class TypeLiteralGenerator
+    def initialize types
+      @types = types
+    end
+
+    def literal_lines
+      @types.sort_by(&:klass_name).map do |type|
+        instance = type.new
+        Camille::Line.new("type #{instance.literal} = #{instance.underlying.literal}")
+      end
+    end
+  end
+end

data/lib/camille/types/array.rb

@@ -9,32 +9,41 @@ module Camille
       end
 
       def check value
-        if value.is_a? ::Array
-          results = value.map.with_index do |element, index|
-            [index, @content.check(element)]
-          end
-
-          errors = results.map do |index, result|
-            if result.type_error?
-              ["array[#{index}]", result]
-            else
-              nil
-            end
-          end.compact
+        check_with_method(value, :check)
+      end
 
-          if errors.empty?
-            Camille::Checked.new(fingerprint, results.map{|_, checked| checked.value})
-          else
-            Camille::TypeError.new(**errors.to_h)
-          end
-        else
-          Camille::TypeError.new("Expected array, got #{value.inspect}.")
-        end
+      def check_params value
+        check_with_method(value, :check_params)
       end
 
       def literal
         "#{@content.literal}[]"
       end
+
+      private
+        def check_with_method value, method_name
+          if value.is_a? ::Array
+            results = value.map.with_index do |element, index|
+              [index, @content.public_send(method_name, element)]
+            end
+
+            errors = results.map do |index, result|
+              if result.type_error?
+                ["array[#{index}]", result]
+              else
+                nil
+              end
+            end.compact
+
+            if errors.empty?
+              Camille::Checked.new(fingerprint, results.map{|_, checked| checked.value})
+            else
+              Camille::TypeError.new(**errors.to_h)
+            end
+          else
+            Camille::TypeError.new("Expected array, got #{value.inspect}.")
+          end
+        end
     end
   end
 end

data/lib/camille/types/intersection.rb

@@ -12,27 +12,36 @@ module Camille
       end
 
       def check value
-        left_result = @left.check value
-        if left_result.type_error?
-          Camille::TypeError.new(
-            'intersection.left' => left_result
-          )
-        else
-          right_result = @right.check left_result.value
-          if right_result.type_error?
-            Camille::TypeError.new(
-              'intersection.right' => right_result
-            )
-          else
-            Camille::Checked.new(fingerprint, right_result.value)
-          end
-        end
+        check_with_method(value, :check)
+      end
+
+      def check_params value
+        check_with_method(value, :check_params)
       end
 
       def literal
         "(#{@left.literal} & #{@right.literal})"
       end
 
+      private
+        def check_with_method value, method_name
+          left_result = @left.public_send(method_name, value)
+          if left_result.type_error?
+            Camille::TypeError.new(
+              'intersection.left' => left_result
+            )
+          else
+            right_result = @right.public_send(method_name, left_result.value)
+            if right_result.type_error?
+              Camille::TypeError.new(
+                'intersection.right' => right_result
+              )
+            else
+              Camille::Checked.new(fingerprint, right_result.value)
+            end
+          end
+        end
+
     end
   end
 end

data/lib/camille/types/object.rb

@@ -47,6 +47,52 @@ module Camille
         end
       end
 
+      def check_params value
+        if value.is_a? Hash
+          # Convert camelCase keys to snake_case
+          converted_value = value.transform_keys do |key|
+            Camille::KeyConverter.convert_params_key(key.to_s)
+          end
+
+          fields_with_string_keys = @fields.transform_keys(&:to_s)
+          optional_keys_as_strings = @optional_keys.map(&:to_s)
+
+          # Now check using the regular check method which expects snake_case
+          keys = (fields_with_string_keys.keys + converted_value.keys).uniq
+          keys_to_check, keys_to_skip = keys.partition{|key| fields_with_string_keys[key]}
+
+          results = keys_to_check.map do |key|
+            type = fields_with_string_keys[key]
+            if optional_keys_as_strings.include?(key) && converted_value[key].nil?
+              nil
+            else
+              [key, type.check_params(converted_value[key])]
+            end
+          end.compact
+
+          errors = results.map do |key, result|
+            if result.type_error?
+              [key.to_s, result]
+            else
+              nil
+            end
+          end.compact
+
+          skipped_pairs = keys_to_skip.map do |key|
+            [key, converted_value[key]]
+          end
+
+          if errors.empty?
+            object = Hash[results.map{|key, checked| [key, checked.value]}.concat(skipped_pairs).to_h]
+            Camille::Checked.new(fingerprint, object)
+          else
+            Camille::TypeError.new(**errors.to_h)
+          end
+        else
+          Camille::TypeError.new("Expected hash, got #{value.inspect}.")
+        end
+      end
+
       def literal
         "{#{@fields.map{|k,v| "#{literal_key k}: #{v.literal}"}.join(', ')}}"
       end

data/lib/camille/types/tuple.rb

@@ -9,32 +9,41 @@ module Camille
       end
 
       def check value
-        if value.is_a?(::Array) && value.size == @elements.size
-          results = @elements.map.with_index do |type, index|
-            [index, type.check(value[index])]
-          end
-
-          errors = results.map do |index, result|
-            if result.type_error?
-              ["tuple[#{index}]", result]
-            else
-              nil
-            end
-          end.compact
+        check_with_method(value, :check)
+      end
 
-          if errors.empty?
-            Camille::Checked.new(fingerprint, results.map{|_, checked| checked.value})
-          else
-            Camille::TypeError.new(**errors.to_h)
-          end
-        else
-          Camille::TypeError.new("Expected array of size #{@elements.size}, got #{value.inspect}.")
-        end
+      def check_params value
+        check_with_method(value, :check_params)
       end
 
       def literal
         "[#{elements.map(&:literal).join(', ')}]"
       end
+
+      private
+        def check_with_method value, method_name
+          if value.is_a?(::Array) && value.size == @elements.size
+            results = @elements.map.with_index do |type, index|
+              [index, type.public_send(method_name, value[index])]
+            end
+
+            errors = results.map do |index, result|
+              if result.type_error?
+                ["tuple[#{index}]", result]
+              else
+                nil
+              end
+            end.compact
+
+            if errors.empty?
+              Camille::Checked.new(fingerprint, results.map{|_, checked| checked.value})
+            else
+              Camille::TypeError.new(**errors.to_h)
+            end
+          else
+            Camille::TypeError.new("Expected array of size #{@elements.size}, got #{value.inspect}.")
+          end
+        end
     end
   end
 end

data/lib/camille/types/union.rb

@@ -10,25 +10,34 @@ module Camille
       end
 
       def check value
-        left_result = @left.check value
-        if left_result.type_error?
-          right_result = @right.check value
-          if right_result.type_error?
-            Camille::TypeError.new(
-              'union.left' => left_result,
-              'union.right' => right_result
-            )
-          else
-            Camille::Checked.new(fingerprint, right_result.value)
-          end
-        else
-          Camille::Checked.new(fingerprint, left_result.value)
-        end
+        check_with_method(value, :check)
+      end
+
+      def check_params value
+        check_with_method(value, :check_params)
       end
 
       def literal
         "(#{@left.literal} | #{@right.literal})"
       end
+
+      private
+        def check_with_method value, method_name
+          left_result = @left.public_send(method_name, value)
+          if left_result.type_error?
+            right_result = @right.public_send(method_name, value)
+            if right_result.type_error?
+              Camille::TypeError.new(
+                'union.left' => left_result,
+                'union.right' => right_result
+              )
+            else
+              Camille::Checked.new(fingerprint, right_result.value)
+            end
+          else
+            Camille::Checked.new(fingerprint, left_result.value)
+          end
+        end
     end
   end
 end

data/lib/camille/types.rb

@@ -1,10 +1,7 @@
 module Camille
   module Types
     def self.literal_lines
-      Camille::Loader.loaded_types.sort_by(&:klass_name).map do |type|
-        instance = type.new
-        Camille::Line.new("type #{instance.literal} = #{instance.underlying.literal}")
-      end
+      Camille::TypeLiteralGenerator.new(Camille::Loader.loaded_types).literal_lines
     end
   end
 end

data/lib/camille/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Camille
-  VERSION = "1.1.0"
+  VERSION = "1.3.0"
 end

data/lib/camille.rb

@@ -40,6 +40,8 @@ require_relative "camille/railtie"
 require_relative "camille/controller"
 require_relative "camille/loader"
 require_relative "camille/configuration"
+require_relative "camille/type_literal_generator"
+require_relative "camille/schema_literal_generator"
 require_relative "camille/code_generator"
 require_relative "camille/main_controller"
 require_relative "camille/key_converter"
@@ -57,6 +59,6 @@ module Camille
   end
 
   def self.generate_ts
-    Camille::CodeGenerator.generate_ts
+    Camille::CodeGenerator.new.generate_ts
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: camille
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - merely
@@ -76,11 +76,13 @@ files:
 - lib/camille/railtie.rb
 - lib/camille/rendered.rb
 - lib/camille/schema.rb
+- lib/camille/schema_literal_generator.rb
 - lib/camille/schemas.rb
 - lib/camille/syntax.rb
 - lib/camille/type.rb
 - lib/camille/type_error.rb
 - lib/camille/type_error_printer.rb
+- lib/camille/type_literal_generator.rb
 - lib/camille/types.rb
 - lib/camille/types/any.rb
 - lib/camille/types/array.rb