apicraft-rails 0.5.0.beta1

data/lib/apicraft/middlewares/mocker.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Middlewares
+    # Apicraft Middleware to handle routing
+    # and make mock calls available.
+    class Mocker
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless config.mocks
+
+        request = ActionDispatch::Request.new(env)
+        return @app.call(env) unless mock?(request)
+
+        contract = Apicraft::Openapi::Contract.find_by_operation(
+          request.method, request.path_info
+        )
+        raise Errors::InvalidContract if contract.blank?
+
+        operation = contract.operation(
+          request.method, request.path_info
+        )
+        raise Errors::InvalidOperation if operation.blank?
+
+        code = request.headers[config.headers[:response_code]] || "200"
+        response = operation.response_for(code.to_s)
+        raise Errors::InvalidResponse if response.blank?
+
+        # Determine the format passed in the request.
+        # If passed we use it and the response format.
+        # If not we use the first format from the specs.
+        request.format.to_s
+        # indicates that not format was specified.
+        format = nil
+
+        content, content_type = response.mock(format)
+
+        [
+          code.to_i,
+          {
+            'Content-Type': content_type
+          },
+          [
+            content&.send(convertor(content_type))
+          ].compact
+        ]
+      end
+
+      private
+
+      def config
+        @config ||= Apicraft.config
+      end
+
+      def convertor(format)
+        return if format.blank?
+
+        Apicraft::Constants::MIME_TYPE_CONVERTORS[format]
+      end
+
+      def mock?(request)
+        request.headers[config.headers[:mock]].present?
+      end
+    end
+  end
+end

data/lib/apicraft/middlewares.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "middlewares/mocker"
+require_relative "middlewares/introspector"
+
+module Apicraft
+  # Namespace module for Concerns
+  module Middlewares; end
+end

data/lib/apicraft/mocker/all_of.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Generate mock based on the OneOf schema
+    class AllOf < Base
+      def mock
+        res = schema.all_of.map do |s|
+          Mocker.mock(s)
+        end
+        type = res[0].class
+
+        # TODO: This is not an accurate implementation
+        # especially when it comes to numbers and strings
+        # Ideally, we would want to combine rules from
+        # all the schemas and then generate a value.
+        if type.is_a?(Hash)
+          res.reduce(&:merge)
+        elsif type.is_a?(Array)
+          res.reduce(&:concat)
+        else
+          res.sample
+        end
+      end
+    end
+  end
+end

data/lib/apicraft/mocker/any_of.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Generate mock based on the AnyOf schema
+    class AnyOf < Base
+      def mock
+        num = schema.any_of.size.times.to_a.sample
+
+        # Pick a random number of schemas
+        # to build the response off of
+        res = schema.any_of.sample(num + 1).map do |s|
+          Mocker.mock(s)
+        end
+        type = res[0].class
+
+        # TODO: This is not an accurate implementation
+        # especially when it comes to numbers and strings
+        # Ideally, we would want to combine rules from
+        # all the schemas and then generate a value.
+        if type.is_a?(Hash)
+          res.reduce(&:merge)
+        elsif type.is_a?(Array)
+          res.reduce(&:concat)
+        else
+          res.sample
+        end
+      end
+    end
+  end
+end

data/lib/apicraft/mocker/array.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Generate an array based on the schema
+    # using Mocker types
+    class Array < Base
+      def mock
+        ::Array.new(
+          (min_items..max_items)
+          .to_a
+          .sample
+        ).map do |_i|
+          Mocker.mock(schema.items)
+        end
+      end
+
+      private
+
+      def max_items
+        schema.maxItems || 25
+      end
+
+      def min_items
+        schema.minItems || 1
+      end
+
+      def unique_items
+        schema.uniqueItems.present?
+      end
+    end
+  end
+end

data/lib/apicraft/mocker/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Base class for generating fake
+    # values for different data types.
+    # Check subclasses
+    class Base
+      attr_accessor :schema
+
+      def initialize(schema)
+        @schema = schema
+      end
+    end
+  end
+end

data/lib/apicraft/mocker/boolean.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Generate fake boolean values
+    class Boolean < Base
+      def mock
+        Faker::Boolean.boolean
+      end
+    end
+  end
+end

data/lib/apicraft/mocker/integer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Generate fake values for integers
+    class Integer < Number
+      def mock
+        super.to_i
+      end
+    end
+  end
+end

data/lib/apicraft/mocker/number.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Generate fake values for numbers
+    class Number < Base
+      def mock
+        return enum.sample if enum.present?
+
+        Faker::Number.between(
+          from: schema.minimum || 1,
+          to: schema.maximum || 100
+        ) * multiple_of
+      end
+
+      private
+
+      def minimum
+        schema.minimum || 1
+      end
+
+      def maximum
+        schema.maximum || 100
+      end
+
+      def exclusive_minimum
+        schema.exclusiveMinimum
+      end
+
+      def exclusive_maximum
+        schema.exclusiveMaximum
+      end
+
+      def multiple_of
+        schema.multipleOf || 1
+      end
+
+      def enum
+        schema.enum || []
+      end
+    end
+  end
+end

data/lib/apicraft/mocker/object.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Generate an object based on the schema
+    # using Mocker types
+    class Object < Base
+      def mock
+        res = {}
+        properties.each do |k, v|
+          res[k] = Mocker.mock(v)
+        end
+        res
+      end
+
+      private
+
+      def required
+        schema.required || []
+      end
+
+      def min_properties
+        schema.minProperties || 0
+      end
+
+      def max_properties
+        schema.maxProperties || 0
+      end
+
+      def properties
+        schema.properties || {}
+      end
+    end
+  end
+end

data/lib/apicraft/mocker/one_of.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Generate mock based on the OneOf schema
+    class OneOf < Base
+      def mock
+        Mocker.mock(
+          schema.one_of.sample
+        )
+      end
+    end
+  end
+end

data/lib/apicraft/mocker/string.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Mocker
+    # Generate fake values for string data types
+    class String < Base
+      def mock
+        return enum.sample if enum.present?
+
+        return Faker::Internet.email if format == "email"
+
+        return Faker::Internet.url if format == "uri"
+
+        return Faker::Internet.uuid if format == "uuid"
+
+        return Faker::Time.backward.iso8601 if format == "date-time"
+
+        Faker::Lorem.word
+      end
+
+      private
+
+      def format
+        schema.format
+      end
+
+      def min_length
+        schema.minLength
+      end
+
+      def max_length
+        schema.maxLength
+      end
+
+      def pattern
+        schema.pattern
+      end
+
+      def enum
+        schema.enum || []
+      end
+    end
+  end
+end

data/lib/apicraft/mocker.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "mocker/base"
+require_relative "mocker/boolean"
+require_relative "mocker/string"
+require_relative "mocker/number"
+require_relative "mocker/integer"
+require_relative "mocker/object"
+require_relative "mocker/array"
+require_relative "mocker/one_of"
+require_relative "mocker/all_of"
+require_relative "mocker/any_of"
+
+module Apicraft
+  # Namespace module for Mocker types
+  module Mocker
+    def self.handler_for(schema)
+      "Apicraft::Mocker::#{
+        extract_type(schema).camelize
+      }".constantize
+    end
+
+    def self.mock(schema)
+      return if schema.blank?
+
+      handler_for(schema).new(
+        schema
+      ).mock
+    end
+
+    def self.extract_type(schema)
+      return schema.type if schema.type.present?
+
+      return "one_of" if schema.one_of.present?
+
+      return "any_of" if schema.any_of.present?
+
+      "all_of" if schema.all_of.present?
+    end
+  end
+end

data/lib/apicraft/openapi/contract.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Openapi
+    # A single openapi yaml file is represented
+    # by this Contract class.
+    class Contract
+      include Concerns::Cacheable
+      @store = []
+
+      attr_accessor :document
+
+      def initialize(document)
+        @document = document
+      end
+
+      def operation(method, path)
+        with_cache("operation-#{method.downcase}-#{path}") do
+          op = document.request_operation(method.downcase, path)
+          Operation.new(op) if op.present?
+        end
+      end
+
+      class << self
+        def create!(document)
+          c = new(document)
+          @store << c
+          c
+        end
+
+        def all
+          @store
+        end
+
+        def find_by_operation(method, path)
+          found = nil
+
+          all.each do |c|
+            if c.operation(method, path).present?
+              found = c
+              break
+            end
+          end
+
+          found
+        end
+      end
+    end
+  end
+end

data/lib/apicraft/openapi/operation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Openapi
+    # Represents an OpenAPI operation.
+    # like GET /pets
+    class Operation
+      attr_accessor :operation
+
+      def initialize(operation)
+        @operation = operation.operation_object
+      end
+
+      def responses
+        @operation.responses
+      end
+
+      def summary
+        @operation.summary
+      end
+
+      def response_for(code)
+        response = responses.response[code.to_s]
+        return unless response.present?
+
+        Response.new(
+          response
+        )
+      end
+
+      def raw_schema
+        operation.raw_schema
+      end
+    end
+  end
+end

data/lib/apicraft/openapi/response.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Openapi
+    # Represents an OpenAPI response.
+    class Response
+      attr_accessor :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      def description
+        response.description
+      end
+
+      def default_content_type
+        return if content.blank?
+
+        content.keys[0]
+      end
+
+      def content
+        response.content
+      end
+
+      def content_for(content_type = nil)
+        return if content.blank?
+
+        content[content_type || default_content_type]
+      end
+
+      def schema_for(content_type = nil)
+        content_for(content_type || default_content_type)&.schema
+      end
+
+      def mock(content_type = nil)
+        [
+          Mocker.mock(
+            schema_for(content_type || default_content_type)
+          ),
+          content_type || default_content_type
+        ]
+      end
+    end
+  end
+end

data/lib/apicraft/openapi.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "openapi/response"
+require_relative "openapi/operation"
+require_relative "openapi/contract"
+
+module Apicraft
+  # Namespace module for OpenAPI
+  module Openapi; end
+end

data/lib/apicraft/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Apicraft
+  # Hooks into the application boot process
+  # using Rails::Railtie
+  class Railtie < Rails::Railtie
+    initializer "apicraft.load_api_contracts" do
+      Apicraft::Loader.load!
+    end
+  end
+end

data/lib/apicraft/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Current version of Apicraft.
+module Apicraft
+  VERSION = "0.5.0.beta1"
+end

data/lib/apicraft/web/actions.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Web
+    # Web actions to be handled from
+    # the rack app.
+    module Actions
+      def self.index(view_path)
+        [
+          File.read(view_path),
+          "text/html"
+        ]
+      end
+
+      def self.swaggerdoc(view_path)
+        @vars = {
+          urls: Router.contract_urls
+        }
+
+        [
+          ERB.new(
+            File.read(view_path)
+          ).result(binding),
+          "text/html"
+        ]
+      end
+
+      def self.redoc(view_path)
+        @vars = {
+          urls: Router.contract_urls
+        }
+
+        [
+          ERB.new(
+            File.read(view_path)
+          ).result(binding),
+          "text/html"
+        ]
+      end
+
+      def self.contract(view_path)
+        [
+          File.read(view_path),
+          MIME::Types.type_for(view_path)[0].to_s
+        ]
+      end
+
+      def self.introspect(method, view_path)
+        [
+          Apicraft::Openapi::Contract.find_by_operation(
+            method, view_path
+          )&.operation(
+            method, view_path
+          )&.raw_schema&.to_json,
+          "application/json"
+        ]
+      end
+    end
+  end
+end

data/lib/apicraft/web/app.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Apicraft
+  module Web
+    # Apicraft Rack App that is mounted
+    # for all the views to be served
+    class App
+      def self.call(env)
+        return unauthorized_response unless authorized?(env)
+
+        uri = env["REQUEST_URI"]
+        method = env["REQUEST_METHOD"]
+        Router.namespace = env["SCRIPT_NAME"]
+        path = uri.split(
+          Router.namespace
+        )[-1]
+
+        content, content_type = Router.load_response!(
+          method, path || "/"
+        )
+
+        raise Errors::RouteNotFound if content.nil?
+
+        [
+          200,
+          { 'Content-Type': content_type },
+          [content]
+        ]
+      rescue Errors::RouteNotFound
+        [
+          404,
+          { 'Content-Type': "text/plain" },
+          ["Error: not found"]
+        ]
+      rescue StandardError => e
+        [
+          500,
+          { 'Content-Type': "text/plain" },
+          ["Error: #{e.message}"]
+        ]
+      end
+
+      def self.authorized?(env)
+        auth = Rack::Auth::Basic::Request.new(env)
+        username, password = auth.provided? && auth.basic? && auth.credentials
+        @use&.call(username, password).present?
+      end
+
+      def self.use(&block)
+        @use = block
+      end
+
+      def self.unauthorized_response
+        [
+          401,
+          {
+            "Content-Type": "text/plain",
+            "WWW-Authenticate": "Basic realm=\"Restricted Area\""
+          },
+          ["Unauthorized"]
+        ]
+      end
+    end
+  end
+end