jsapi 1.1.1 → 1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5106832b9b6b3b6747fc83b4469176532e56a84d2fe1779cdad6e6e34d9da4b
-  data.tar.gz: 1d760c1fbb5556dfac42203ae05c483f2fcf99e3aa0c6bfc34c374d7093fbd0c
+  metadata.gz: 2abec73a53f67bfebe51e0466e662be1dfc393f3fe5946612a12c94fde8b463b
+  data.tar.gz: f9c69c6df40d4f88e5175beb185a528ad76f2c6b4cbf6a8f88ac15915943f706
 SHA512:
-  metadata.gz: 3261a33d232a31b42f334d0ef13e36d5e0dd92c2863948fdcb54dee791e6580a2adf26c7fe1b0685837fb01d69cf3dc1b6f6f25557840c10c6ade65725ee6aaf
-  data.tar.gz: baaf0e9710ac6909ff970534f758a539835807d0e61515440759245960aac83e9477c231e42f48c03822a10e04afaaef19fbf3320972c303821f2e23aa4e4bfb
+  metadata.gz: ca369ab50a38016fa37e9199e5a38f9248d2cbcfa51d80c39461dd206d8b09fb6ae60ea29861d211b9a939e408b6e48f35008da577c9f3a789bb6ebb592fafda
+  data.tar.gz: 8093446b1d7601d9a0e89cae395fa0ced837901b1a9eb0866ebcfd721cebb9e07d611c851735c847a699d71cec4ca474d04e39710ebc244476f6deb635e7fdc7

data/lib/jsapi/configuration.rb

@@ -4,11 +4,11 @@ module Jsapi
   # Holds the \Jsapi configuration.
   class Configuration
     # The path where the API definitions are located relative to +Rails.root+.
-    # The default is <code>"app/api_defs"</code>.
+    # The default is <code>"jsapi/api_defs"</code>.
     attr_accessor :api_defs_path
 
     def initialize # :nodoc:
-      @api_defs_path = 'app/api_defs'
+      @api_defs_path = 'jsapi/api_defs'
     end
 
     # Returns the absolute +Pathname+ for +args+ within +api_defs_path+.

data/lib/jsapi/controller/methods.rb

@@ -15,7 +15,9 @@ module Jsapi
       # Performs an API operation by calling the given block. The request parameters are
       # passed as an instance of the operation's model class to the block. The object
       # returned by the block is implicitly rendered according to the appropriate +response+
-      # specification when the content type is a JSON MIME type.
+      # specification when the content type is a JSON MIME type. When content type is
+      # <code>application/json-seq</code>, the object returned by the block is streamed in
+      # JSON sequence text format.
       #
       #   api_operation('foo') do |api_params|
       #     # ...
@@ -153,18 +155,29 @@ module Jsapi
         end
 
         # Write response
-        return unless response_model.json_type?
+        return unless response_model.json_type? || response_model.json_seq_type?
 
         response = Response.new(result, response_model, definitions, omit: omit)
         self.content_type = response_model.content_type
-        render(json: response, status: status)
+
+        if response_model.json_seq_type?
+          self.response.status = status
+
+          self.response.stream.tap do |stream|
+            response.write_json_seq_to(stream)
+          ensure
+            stream.close
+          end
+        else
+          render(json: response, status: status)
+        end
       end
 
       def _api_params(operation, definitions, strong:)
         (operation.model || Model::Base).new(
           Parameters.new(
             params.except(:action, :controller, :format).permit!,
-            request.headers,
+            request,
             operation,
             definitions,
             strong: strong

data/lib/jsapi/controller/parameters.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'cgi'
+
 module Jsapi
   module Controller
     # Used to wrap request parameters.
@@ -14,18 +16,32 @@ module Jsapi
       # If +strong+ is true+ parameters that can be mapped are accepted only. That means that
       # the instance created is invalid if +params+ contains any parameters that can't be
       # mapped to a parameter or a request body property of +operation+.
-      def initialize(params, headers, operation, definitions, strong: false)
-        @params = params.to_h
-        @strong = strong == true
+      def initialize(params, request, operation, definitions, strong: false)
+        params = params.to_h
+        unassigned_params = params.dup
+
+        @params_to_be_validated = strong == true ? params.dup : {}
         @raw_attributes = {}
-        @raw_additional_attributes = {}
 
         # Parameters
         operation.parameters.each do |name, parameter_model|
           parameter_model = parameter_model.resolve(definitions)
 
           @raw_attributes[name] = JSON.wrap(
-            parameter_model.in == 'header' ? headers[name] : @params[name],
+            case parameter_model.in
+            when 'header'
+              request.headers[name]
+            when 'querystring'
+              query_params = request.query_parameters
+              keys = query_params.keys
+
+              unassigned_params.except!(*keys)
+              @params_to_be_validated.except!(*keys)
+
+              parameter_model.object? ? params.slice(*keys) : query_params.to_query
+            else
+              unassigned_params.delete(name)
+            end,
             parameter_model.schema.resolve(definitions),
             definitions,
             context: :request
@@ -37,23 +53,24 @@ module Jsapi
                                        &.schema&.resolve(definitions)
         if request_body_schema&.object?
           request_body = JSON.wrap(
-            @params.except(*operation.parameters.keys),
+            unassigned_params,
             request_body_schema,
             definitions,
             context: :request
           )
           @raw_attributes.merge!(request_body.raw_attributes)
           @raw_additional_attributes = request_body.raw_additional_attributes
+          @params_to_be_validated.except!(*@raw_additional_attributes.keys)
+        else
+          @raw_additional_attributes = {}
         end
       end
 
       # Validates the request parameters. Returns true if the parameters are valid, false
       # otherwise. Detected errors are added to +errors+.
       def validate(errors)
-        [
-          validate_attributes(errors),
-          !@strong || validate_parameters(@params, attributes, errors)
-        ].all?
+        validate_attributes(errors) &&
+          validate_parameters(@params_to_be_validated, attributes, errors)
       end
 
       private

data/lib/jsapi/controller/response.rb

@@ -50,11 +50,27 @@ module Jsapi
       # Returns the \JSON representation of the response as a string.
       def to_json(*)
         schema = @response.schema.resolve(@definitions)
-        if @response.locale
-          I18n.with_locale(@response.locale) { jsonify(@object, schema) }
-        else
-          jsonify(@object, schema)
-        end.to_json
+        with_locale { jsonify(@object, schema) }.to_json
+      end
+
+      # Writes the response in \JSON sequence text format to +stream+.
+      def write_json_seq_to(stream)
+        schema = @response.schema.resolve(@definitions)
+        with_locale do
+          items, item_schema =
+            if schema.array? && @object.respond_to?(:each)
+              [@object, schema.items.resolve(@definitions)]
+            else
+              [[@object], schema]
+            end
+
+          items.each do |item|
+            stream.write("\u001E") # Record separator (see RFC 7464)
+            stream.write(jsonify(item, item_schema).to_json)
+            stream.write("\n")
+          end
+        end
+        nil
       end
 
       private
@@ -138,6 +154,14 @@ module Jsapi
 
         properties.presence
       end
+
+      def with_locale(&block)
+        if @response.locale
+          I18n.with_locale(@response.locale, &block)
+        else
+          yield
+        end
+      end
     end
   end
 end

data/lib/jsapi/json/array.rb

@@ -20,6 +20,10 @@ module Jsapi
         "#<#{self.class.name} [#{@json_values.map(&:inspect).join(', ')}]>"
       end
 
+      def serializable_value(**options) # :nodoc:
+        @json_values.map { |element| element.serializable_value(**options) }
+      end
+
       def validate(errors) # :nodoc:
         return false unless super
 

data/lib/jsapi/json/object.rb

@@ -6,6 +6,8 @@ module Jsapi
     class Object < Value
       include Model::Nestable
 
+      alias serializable_value serializable_hash
+
       attr_reader :raw_additional_attributes, :raw_attributes
 
       def initialize(hash, schema, definitions, context: nil)

data/lib/jsapi/json/value.rb

@@ -29,6 +29,11 @@ module Jsapi
         false
       end
 
+      # Returns a serializable representation of +value+.
+      def serializable_value(**options)
+        options[:jsonify_values] == true ? value.as_json : value
+      end
+
       # Validates it against #schema. Returns true if it is valid, false otherwise.
       # Detected errors are added to +errors+.
       def validate(errors)

data/lib/jsapi/meta/callback/base.rb

@@ -23,7 +23,7 @@ module Jsapi
         # Returns a hash representing the \OpenAPI callback object.
         def to_openapi(version, definitions)
           operations.transform_values do |operation|
-            { operation.method => operation.to_openapi(version, definitions) }
+            OpenAPI::PathItem.new([operation]).to_openapi(version, definitions)
           end
         end
       end

data/lib/jsapi/meta/definitions.rb

@@ -231,9 +231,7 @@ module Jsapi
         openapi_paths =
           operations.group_by { |operation| operation.path || default_operation_path }
                     .transform_values do |operations_by_path|
-            operations_by_path.index_by(&:method).transform_values do |operation|
-              operation.to_openapi(version, self)
-            end
+            OpenAPI::PathItem.new(operations_by_path).to_openapi(version, self)
           end.presence
 
         openapi_objects =
@@ -271,10 +269,16 @@ module Jsapi
           else
             {
               # Order according to the OpenAPI specification 3.x
-              openapi: version.minor.zero? ? '3.0.3' : '3.1.1',
+              openapi:
+                case version.minor
+                when 0 then '3.0.3'
+                when 1 then '3.1.1'
+                when 2 then '3.2.0'
+                end,
               info: openapi_objects[:info],
-              servers: openapi_objects[:servers] ||
-                [default_server&.to_openapi].compact.presence,
+              servers:
+                openapi_objects[:servers] ||
+                [default_server&.to_openapi(version)].compact.presence,
               paths: openapi_paths,
               components: {
                 schemas: openapi_objects[:schemas],

data/lib/jsapi/meta/example/base.rb

@@ -29,13 +29,11 @@ module Jsapi
 
         # Returns a hash representing the \OpenAPI example object.
         def to_openapi(*)
-          with_openapi_extensions(summary: summary, description: description).tap do |result|
-            if external?
-              result[:external_value] = value
-            else
-              result[:value] = value
+          with_openapi_extensions(
+            { summary: summary, description: description }.tap do |result|
+              result[external? ? :externalValue : :value] = value
             end
-          end
+          )
         end
       end
     end

data/lib/jsapi/meta/link/base.rb

@@ -33,13 +33,15 @@ module Jsapi
         attribute :server, Server
 
         # Returns a hash representing the \OpenAPI link object.
-        def to_openapi(*)
+        def to_openapi(version, *)
+          version = OpenAPI::Version.from(version)
+
           with_openapi_extensions(
             operationId: operation_id,
             parameters: parameters.presence,
             requestBody: request_body,
             description: description,
-            server: server&.to_openapi
+            server: server&.to_openapi(version)
           )
         end
       end

data/lib/jsapi/meta/oauth_flow.rb

@@ -18,12 +18,20 @@ module Jsapi
       # The authorization URL to be used for the flow.
       attribute :authorization_url, String
 
+      ##
+      # :attr: device_authorization_url
+      # The device authorization URL to be used for the flow.
+      #
+      # Note that the device authorization URL was introduced with \OpenAPI 3.2.
+      # It is omitted when generating an \OpenAPI document with a lower version.
+      attribute :device_authorization_url, String
+
       ##
       # :attr: refresh_url
       # The refresh URL to be used for the flow.
       #
       # Note that the refresh URL was introduced with \OpenAPI 3.0. It is
-      # skipped when generating an \OpenAPI 2.0 document.
+      # omitted when generating an \OpenAPI document with a lower version.
       attribute :refresh_url, String
 
       ##
@@ -42,8 +50,9 @@ module Jsapi
 
         with_openapi_extensions(
           authorizationUrl: authorization_url,
+          deviceAuthorizationUrl: (device_authorization_url if version >= OpenAPI::V3_2),
           tokenUrl: token_url,
-          refreshUrl: (refresh_url if version.major > 2),
+          refreshUrl: (refresh_url if version >= OpenAPI::V3_0),
           scopes: scopes.transform_values(&:description)
         )
       end

data/lib/jsapi/meta/openapi/path_item.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Jsapi
+  module Meta
+    module OpenAPI
+      class PathItem # :nodoc:
+        def initialize(operations)
+          @operations = operations
+        end
+
+        def to_openapi(version, definitions)
+          version = OpenAPI::Version.from(version)
+
+          {}.tap do |fields|
+            @operations.each do |operation|
+              method = operation.method
+              standardized_method = method.downcase
+
+              if standard_method?(standardized_method, version)
+                fields[standardized_method] = operation.to_openapi(version, definitions)
+              elsif version >= OpenAPI::V3_2
+                additional_operations = fields[:additionalOperations] ||= {}
+                additional_operations[method] = operation.to_openapi(version, definitions)
+              end
+            end
+          end
+        end
+
+        private
+
+        def standard_method?(method, version)
+          case method
+          when 'delete', 'get', 'head', 'options', 'patch', 'post', 'put'
+            true
+          when 'trace'
+            version >= OpenAPI::V3_0
+          when 'query'
+            version >= OpenAPI::V3_2
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsapi/meta/openapi/version.rb

@@ -19,6 +19,8 @@ module Jsapi
             new(3, 0)
           when '3.1'
             new(3, 1)
+          when '3.2'
+            new(3, 2)
           else
             raise ArgumentError, "unsupported OpenAPI version: #{version.inspect}"
           end
@@ -46,6 +48,10 @@ module Jsapi
           minor <=> other.minor
         end
 
+        def inspect
+          "<#{self.class.name} #{self}>"
+        end
+
         def to_s # :nodoc:
           "#{major}.#{minor}"
         end

data/lib/jsapi/meta/openapi.rb

@@ -2,6 +2,7 @@
 
 require_relative 'openapi/extensions'
 require_relative 'openapi/version'
+require_relative 'openapi/path_item'
 
 module Jsapi
   module Meta
@@ -9,6 +10,7 @@ module Jsapi
       V2_0 = Version.new(2, 0)
       V3_0 = Version.new(3, 0)
       V3_1 = Version.new(3, 1)
+      V3_2 = Version.new(3, 2)
     end
   end
 end

data/lib/jsapi/meta/operation.rb

@@ -28,18 +28,8 @@ module Jsapi
 
       ##
       # :attr: method
-      # The HTTP verb of the operation. Possible values are:
-      #
-      # - <code>"delete"</code>
-      # - <code>"get"</code>
-      # - <code>"head"</code>
-      # - <code>"options"</code>
-      # - <code>"patch"</code>
-      # - <code>"post"</code>
-      # - <code>"put"</code>
-      #
-      # The default HTTP verb is <code>"get"</code>.
-      attribute :method, values: %w[delete get head options patch post put], default: 'get'
+      # The HTTP method of the operation, <code>"get"</code> by default.
+      attribute :method, String, default: 'get'
 
       ##
       # :attr: model
@@ -97,7 +87,7 @@ module Jsapi
 
       ##
       # :attr: summary
-      # The short summary of the operation.
+      # The short description of the operation.
       attribute :summary, String
 
       ##
@@ -148,7 +138,9 @@ module Jsapi
             end
             result[:schemes] = schemes if schemes.present?
           elsif servers.present?
-            result[:servers] = servers.map(&:to_openapi)
+            result[:servers] = servers.map do |server|
+              server.to_openapi(version)
+            end
           end
           # Parameters (and request body)
           result[:parameters] = parameters.values.flat_map do |parameter|