openapi_first 0.7.0.alpha1 → 3.1.0.beta1

data/benchmarks/apps/committee.ru

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'committee'
-require 'syro'
-require 'multi_json'
-
-app = Syro.new do
-  on 'hello' do
-    on :id do
-      get do
-        res.json MultiJson.dump(hello: 'world', id: inbox[:id])
-      end
-    end
-
-    get do
-      res.json [MultiJson.dump(hello: 'world')]
-    end
-
-    post do
-      res.status = 201
-      res.json MultiJson.dump(hello: 'world')
-    end
-  end
-end
-
-use Committee::Middleware::RequestValidation,
-    schema_path: './apps/openapi.yaml',
-    coerce_date_times: false
-
-run app

data/benchmarks/apps/grape.ru

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'grape'
-
-class GrapeExample < Grape::API
-  format :json
-
-  get :hello do
-    [{ hello: 'world' }]
-  end
-
-  post :hello do
-    { hello: 'world' }
-  end
-
-  get 'hello/:id' do
-    { hello: 'world', id: params[:id] }
-  end
-end
-
-run GrapeExample

data/benchmarks/apps/hanami_router.ru

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'hanami/router'
-require 'multi_json'
-
-app = Hanami::Router.new do
-  get '/hello', to: ->(_env) { [200, {}, [MultiJson.dump(hello: 'world')]] }
-  get '/hello/:id', to: lambda { |env|
-    [200, {}, [MultiJson.dump(hello: 'world', id: env['router.params'][:id])]]
-  }
-  post '/hello', to: ->(_env) { [201, {}, [MultiJson.dump(hello: 'world')]] }
-end
-
-run app

data/benchmarks/apps/openapi.yaml

@@ -1,86 +0,0 @@
-openapi: 3.0.0
-info:
-  title: "API"
-  version: "1.0.0"
-  contact:
-    name: Contact Name
-    email: contact@example.com
-    url: https://example.com/
-tags:
-  - name: Metadata
-    description: Metadata related requests
-paths:
-  /hello/{id}:
-    parameters:
-    - name: id
-      description: ID of the thing to get
-      in: path
-      required: true
-      schema:
-        type: string
-    get:
-      operationId: find_thing
-      description: Get one thing
-      tags: ["Metadata"]
-      responses:
-        "200":
-          description: OK
-          content:
-            application/json:
-              schema:
-                type: array
-                items:
-                  type: object
-                  required: [hello, id]
-                  properties:
-                    hello:
-                      type: string
-                    id:
-                      type: string
-  /hello:
-    get:
-      operationId: find_things
-      description: Get multiple things
-      tags: ["Metadata"]
-      parameters:
-      - name: filter
-        description: filter things
-        in: query
-        required: false
-        schema:
-          type: object
-          required: [id]
-          properties:
-            id:
-              type: string
-              description: Comma separated list of thing-IDs
-
-      responses:
-        "200":
-          description: OK
-          content:
-            application/json:
-              schema:
-                type: object
-                required: [hello]
-                properties:
-                  hello:
-                    type: string
-        default:
-          description: Error response
-
-    post:
-      operationId: create_thing
-      description: Create a thing
-      tags: ["Metadata"]
-      responses:
-        "201":
-          description: OK
-          content:
-            application/json:
-              schema:
-                type: object
-                required: [hello]
-                properties:
-                  hello:
-                    type: string

data/benchmarks/apps/openapi_first.ru

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'multi_json'
-require 'openapi_first'
-
-namespace = Module.new do
-  def self.find_thing(params, _res)
-    { hello: 'world', id: params.fetch('id') }
-  end
-
-  def self.find_things(_params, _res)
-    [{ hello: 'world' }]
-  end
-
-  def self.create_thing(_params, res)
-    res.status = 201
-    { hello: 'world' }
-  end
-end
-
-oas_path = File.absolute_path('./openapi.yaml', __dir__)
-run OpenapiFirst.app(oas_path, namespace: namespace)

data/benchmarks/apps/openapi_first_resolve_only.ru

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'multi_json'
-require 'openapi_first'
-
-namespace = Module.new do
-  def self.find_thing(params, _res)
-    { hello: 'world', id: params.fetch('id') }
-  end
-
-  def self.find_things(_params, _res)
-    [{ hello: 'world' }]
-  end
-
-  def self.create_thing(_params, res)
-    res.status = 201
-    { hello: 'world' }
-  end
-end
-
-spec = OpenapiFirst.load(File.absolute_path('./openapi.yaml', __dir__))
-use OpenapiFirst::Router, spec: spec, namespace: namespace
-run OpenapiFirst::OperationResolver.new

data/benchmarks/apps/sinatra.ru

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'multi_json'
-require 'sinatra/base'
-
-class SinatraExample < Sinatra::Base
-  set :environment, :production
-
-  get '/hello/:id' do
-    content_type :json
-    MultiJson.dump(hello: 'world', id: params.fetch('id'))
-  end
-
-  get '/hello' do
-    content_type :json
-    [MultiJson.dump(hello: 'world')]
-  end
-
-  post '/hello' do
-    content_type :json
-    status 201
-    MultiJson.dump(hello: 'world')
-  end
-end
-
-run SinatraExample

data/benchmarks/apps/syro.ru

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'syro'
-require 'multi_json'
-
-app = Syro.new do
-  on 'hello' do
-    on :id do
-      get do
-        res.json MultiJson.dump(hello: 'world', id: inbox[:id])
-      end
-    end
-
-    get do
-      res.json [MultiJson.dump(hello: 'world')]
-    end
-
-    post do
-      res.status = 201
-      res.json MultiJson.dump(hello: 'world')
-    end
-  end
-end
-
-run app

data/benchmarks/benchmarks.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'benchmark/ips'
-require 'benchmark/memory'
-require 'rack'
-ENV['RACK_ENV'] = 'production'
-
-examples = [
-  [Rack::MockRequest.env_for('/hello'), 200],
-  [Rack::MockRequest.env_for('/unknown'), 404],
-  [Rack::MockRequest.env_for('/hello', method: 'POST'), 201],
-  [Rack::MockRequest.env_for('/hello/1'), 200],
-  [Rack::MockRequest.env_for('/hello/123'), 200],
-  [Rack::MockRequest.env_for('/hello?filter[id]=1,2'), 200]
-]
-
-apps = Dir['./apps/*.ru'].each_with_object({}) do |config, hash|
-  hash[config] = Rack::Builder.parse_file(config).first
-end
-apps.freeze
-
-Benchmark.ips do |x|
-  apps.each do |config, app|
-    x.report(config) do
-      examples.each do |example|
-        env, expected_status = example
-        response = app.call(env)
-        raise unless response[0] == expected_status
-      end
-    end
-  end
-  x.compare!
-end
-
-Benchmark.memory do |x|
-  apps.each do |config, app|
-    x.report(config) do
-      examples.each do |example|
-        env, expected_status = example
-        response = app.call(env)
-        raise unless response[0] == expected_status
-      end
-    end
-  end
-  x.compare!
-end

data/bin/console

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'openapi_first'
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require 'irb'
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/examples/README.md

@@ -1,13 +0,0 @@
-# Example
-
-How to run the example:
-
-```bash
-cd examples
-bundle install
-bundle exec rackup
-```
-
-open http://localhost:9292/
-
-🎉

data/examples/app.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'openapi_first'
-
-module Example
-  def self.find_thing(_params, _res)
-    { hello: 'world' }
-  end
-end
-
-oas_path = File.absolute_path('./openapi.yaml', __dir__)
-App = OpenapiFirst.app(oas_path, namespace: Example)

data/examples/config.ru

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path('../lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require_relative 'app'
-run App

data/examples/openapi.yaml

@@ -1,29 +0,0 @@
-openapi: 3.0.0
-info:
-  title: "API"
-  version: "1.0.0"
-  contact:
-    name: Contact Name
-    email: contact@example.com
-    url: https://example.com/
-tags:
-  - name: Metadata
-    description: Metadata related requests
-paths:
-  /:
-    get:
-      operationId: find_thing
-      summary: Get metadata from the root of the API
-      tags: ["Metadata"]
-      responses:
-        "200":
-          description: OK
-          content:
-            application/json:
-              schema:
-                type: object
-                required: [hello]
-                properties:
-                  hello:
-                    type: string
-

data/lib/openapi_first/app.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack'
-
-module OpenapiFirst
-  class App
-    def initialize(
-      parent_app,
-      spec,
-      namespace:
-    )
-      @stack = Rack::Builder.app do
-        freeze_app
-        use OpenapiFirst::Router,
-            spec: spec,
-            namespace: namespace,
-            parent_app: parent_app
-        use OpenapiFirst::RequestValidation
-        run OpenapiFirst::OperationResolver.new
-      end
-    end
-
-    def call(env)
-      @stack.call(env)
-    end
-  end
-end

data/lib/openapi_first/coverage.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module OpenapiFirst
-  class Coverage
-    attr_reader :to_be_called
-
-    def initialize(app, spec)
-      @app = app
-      @spec = spec
-      @to_be_called = spec.operations.map do |operation|
-        endpoint_id(operation)
-      end
-    end
-
-    def call(env)
-      response = @app.call(env)
-      operation = env[OPERATION]
-      @to_be_called.delete(endpoint_id(operation)) if operation
-      response
-    end
-
-    private
-
-    def endpoint_id(operation)
-      "#{operation.path}##{operation.method}"
-    end
-  end
-end

data/lib/openapi_first/operation.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module OpenapiFirst
-  class Operation
-    extend Forwardable
-    def_delegators :@operation,
-                   :parameters,
-                   :method,
-                   :request_body,
-                   :operation_id
-
-    def initialize(parsed)
-      @operation = parsed
-    end
-
-    def path
-      @operation.path.path
-    end
-
-    def parameters_json_schema
-      @parameters_json_schema ||= build_parameters_json_schema
-    end
-
-    def content_type_for(status)
-      content = @operation
-                .response_by_code(status.to_s, use_default: true)
-                .content
-      content.keys[0] if content
-    end
-
-    private
-
-    def build_parameters_json_schema
-      return unless @operation.parameters&.any?
-
-      @operation.parameters.each_with_object(
-        'type' => 'object',
-        'required' => [],
-        'properties' => {}
-      ) do |parameter, schema|
-        schema['required'] << parameter.name if parameter.required
-        schema['properties'][parameter.name] = parameter.schema
-      end
-    end
-  end
-end

data/lib/openapi_first/operation_resolver.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack'
-
-module OpenapiFirst
-  class OperationResolver
-    def call(env)
-      operation = env[OpenapiFirst::OPERATION]
-      res = Rack::Response.new
-      params = build_params(env)
-      handler = env[HANDLER]
-      result = handler.call(params, res)
-      res.write serialize(result) if result && res.body.empty?
-      res[Rack::CONTENT_TYPE] ||= operation.content_type_for(res.status)
-      res.finish
-    end
-
-    private
-
-    def serialize(result)
-      return result if result.is_a?(String)
-
-      MultiJson.dump(result)
-    end
-
-    def build_params(env)
-      sources = [
-        env[PARAMS],
-        env[REQUEST_BODY]
-      ].tap(&:compact!)
-      Params.new(env).merge!(*sources)
-    end
-  end
-
-  class Params < Hash
-    attr_reader :env
-
-    def initialize(env)
-      @env = env
-      super
-    end
-  end
-end

data/lib/openapi_first/request_validation.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack'
-require 'json_schemer'
-require 'multi_json'
-require_relative 'validation_format'
-
-module OpenapiFirst
-  class RequestValidation # rubocop:disable Metrics/ClassLength
-    def initialize(app, _options = {})
-      @app = app
-    end
-
-    def call(env) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      operation = env[OpenapiFirst::OPERATION]
-      return @app.call(env) unless operation
-
-      catch(:halt) do
-        validate_query_parameters!(env, operation, env[PARAMS])
-        req = Rack::Request.new(env)
-        content_type = req.content_type
-        return @app.call(env) unless operation.request_body
-
-        validate_request_content_type!(content_type, operation)
-        body = req.body.read
-        req.body.rewind
-        parse_and_validate_request_body!(env, content_type, body, operation)
-        @app.call(env)
-      end
-    end
-
-    private
-
-    def halt(response)
-      throw :halt, response
-    end
-
-    def parse_and_validate_request_body!(env, content_type, body, operation)
-      validate_request_body_presence!(body, operation)
-      return if body.empty?
-
-      schema = request_body_schema(content_type, operation)
-      return unless schema
-
-      parsed_request_body = MultiJson.load(body)
-      errors = validate_json_schema(schema, parsed_request_body)
-      if errors.any?
-        halt(error_response(400, serialize_request_body_errors(errors)))
-      end
-      env[OpenapiFirst::REQUEST_BODY] = parsed_request_body
-    end
-
-    def validate_request_content_type!(content_type, operation)
-      return if operation.request_body.content[content_type]
-
-      halt(error_response(415))
-    end
-
-    def validate_request_body_presence!(body, operation)
-      return unless operation.request_body.required && body.empty?
-
-      halt(error_response(415, 'Request body is required'))
-    end
-
-    def validate_json_schema(schema, object)
-      JSONSchemer.schema(schema).validate(object)
-    end
-
-    def default_error(status, title = Rack::Utils::HTTP_STATUS_CODES[status])
-      {
-        status: status.to_s,
-        title: title
-      }
-    end
-
-    def error_response(status, errors = [default_error(status)])
-      Rack::Response.new(
-        MultiJson.dump(errors: errors),
-        status,
-        Rack::CONTENT_TYPE => 'application/vnd.api+json'
-      ).finish
-    end
-
-    def request_body_schema(content_type, operation)
-      return unless operation
-
-      operation.request_body.content[content_type]&.fetch('schema')
-    end
-
-    def serialize_request_body_errors(validation_errors)
-      validation_errors.map do |error|
-        {
-          source: {
-            pointer: error['data_pointer']
-          }
-        }.update(ValidationFormat.error_details(error))
-      end
-    end
-
-    def validate_query_parameters!(env, operation, params)
-      json_schema = operation.parameters_json_schema
-      return unless json_schema
-
-      params = filtered_params(json_schema, params)
-      errors = JSONSchemer.schema(json_schema).validate(params)
-      if errors.any?
-        halt error_response(400, serialize_query_parameter_errors(errors))
-      end
-      env[PARAMS] = params
-    end
-
-    def filtered_params(json_schema, params)
-      json_schema['properties']
-        .each_with_object({}) do |key_value, result|
-          parameter_name, schema = key_value
-          next unless params.key?(parameter_name)
-
-          value = params[parameter_name]
-          result[parameter_name] = parse_parameter(value, schema)
-        end
-    end
-
-    def serialize_query_parameter_errors(validation_errors)
-      validation_errors.map do |error|
-        {
-          source: { parameter: File.basename(error['data_pointer']) }
-        }.update(ValidationFormat.error_details(error))
-      end
-    end
-
-    def parse_parameter(value, schema)
-      return filtered_params(schema, value) if schema['properties']
-
-      begin
-        return Integer(value, 10) if schema['type'] == 'integer'
-        return Float(value) if schema['type'] == 'number'
-      rescue ArgumentError
-        value
-      end
-
-      value
-    end
-  end
-end