api-transformer 0.1.0

data/lib/api_transformer/backend_response.rb

@@ -0,0 +1,62 @@
+require "json"
+require "hashie"
+
+module ApiTransformer
+  # Container for backend response data
+  class BackendResponse
+    # Subclasses Hash so that it can interchangeably use string or symbol access
+    class Data < Hash
+      include Hashie::Extensions::IndifferentAccess
+    end
+
+    attr_reader :body
+
+    def initialize(http)
+      @http = http
+      @body = ""
+
+      @http.stream { |chunk| @body += chunk }
+    end
+
+    def success?
+      status >= 200 && status < 300
+    end
+
+    def status
+      @http.response_header.http_status
+    end
+
+    def json
+      @data ||= Data.try_convert(JSON.parse(@body))
+    rescue JSON::ParserError
+      {}
+    end
+
+    def [](key)
+      json[key]
+    end
+
+    def cookies
+      pairs = @http.response_header["SET_COOKIE"].split("\s*;\s*")
+      data = pairs.reduce({}) do |hash, pair|
+        key, value = pair.split("=")
+        hash.merge(key => value)
+      end
+
+      Data.try_convert(data)
+    end
+
+    def stream(&block)
+      if block
+        block.call(@body)
+
+        @http.stream(&block)
+        EM::Synchrony::Iterator.new([block]).each do |_, iter|
+          @http.callback { iter.next }
+        end
+      else
+        fail "a block is required when streaming"
+      end
+    end
+  end
+end

data/lib/api_transformer/endpoint.rb

@@ -0,0 +1,120 @@
+module ApiTransformer
+  # Processes endpoint blocks
+  class Endpoint
+    def initialize(base_url, env, route)
+      @base_url = base_url
+      @env = env
+      @route = route
+
+      @backend_request_senders = []
+      @backend_responses = {}
+    end
+
+    def run
+      fail "Endpoints must define a response block" unless @builder
+
+      send_requests
+      send_response
+    end
+
+    def complete
+      if @error
+        complete_error
+      else
+        complete_success
+      end
+    end
+
+    def request(name, options = {}, &block)
+      return unless !options.key?(:when) || options[:when]
+
+      @backend_request_senders << BackendRequestSender.new(
+        name,
+        options.merge(base_url: @base_url),
+        block,
+        @env["client-headers"],
+        @route[:helper_blocks]
+      )
+    end
+
+    def response(options = {}, &block)
+      @builder = FrontendResponseBuilder.new(
+        @env,
+        options,
+        block,
+        @route
+      )
+    end
+
+    def stream(value)
+      @stream = value
+    end
+
+    private
+
+    def send_requests
+      @multi = EventMachine::MultiRequest.new
+      iterator = EM::Synchrony::Iterator.new(@backend_request_senders)
+
+      iterator.each do |sender, iter|
+        send_request(sender, iter)
+      end
+    end
+
+    def send_request(sender, iter)
+      http = sender.send(@backend_responses)
+      @backend_responses[sender.request_name] = BackendResponse.new(http)
+      @multi.add sender.request_name, http
+      http.headers { iter.next }
+    rescue ApiTransformer::RequestError => e
+      @error = e
+      iter.next
+    end
+
+    def send_response
+      if @stream
+        status_and_headers
+      else
+        if @backend_request_senders.any? && !@error
+          EM::Synchrony::Iterator.new([@multi]).each do |multi, iter|
+            multi.callback { iter.next }
+          end
+        end
+
+        status_and_headers
+      end
+    end
+
+    def status_and_headers
+      if @error
+        [400, {}]
+      else
+        @builder.status_and_headers(@backend_responses)
+      end
+    end
+
+    def complete_success
+      EM.synchrony do
+        @builder.do_streaming
+
+        if @backend_request_senders.any?
+          @multi.callback do
+            close
+          end
+        else
+          close
+        end
+      end
+    end
+
+    def complete_error
+      @builder.stream_write @error
+      close
+    end
+
+    def close
+      @builder.send_body
+      @builder.stream_close
+    end
+  end
+end

data/lib/api_transformer/errors.rb

@@ -0,0 +1,4 @@
+module ApiTransformer
+  # Error with the frontend request coming in
+  class RequestError < StandardError; end
+end

data/lib/api_transformer/frontend_response.rb

@@ -0,0 +1,52 @@
+require "json"
+
+module ApiTransformer
+  # Container for frontend response data
+  class FrontendResponse
+    attr_accessor :status
+    attr_writer :body, :content_type
+
+    def set(key, value)
+      @hash ||= {}
+      @hash[key] = value
+    end
+
+    def set_cookie(key, value)
+      @cookies ||= {}
+      @cookies[key] = value
+    end
+
+    def body
+      @hash && @hash.to_json || @body
+    end
+
+    def headers
+      cookie_header.merge(content_type_header)
+    end
+
+    private
+
+    def cookie_header
+      if @cookies
+        pairs = @cookies.map { |key, value| "#{key}=#{value}" }
+        { "Set-Cookie" => pairs.join("; ") }
+      else
+        {}
+      end
+    end
+
+    def content_type_header
+      { "Content-Type" => content_type }
+    end
+
+    def content_type
+      if @content_type
+        @content_type
+      elsif @hash
+        "application/json"
+      else
+        "text/plain"
+      end
+    end
+  end
+end

data/lib/api_transformer/frontend_response_builder.rb

@@ -0,0 +1,138 @@
+module ApiTransformer
+  # Processes the response block
+  class FrontendResponseBuilder
+    attr_reader :success
+
+    def initialize(env, options, block, route)
+      @env = env
+      @options = options
+      @block = block
+      @route = route
+
+      @frontend_response = FrontendResponse.new
+    end
+
+    def status_and_headers(backend_responses)
+      @route[:helper_blocks].each { |block| instance_eval(&block) }
+      instance_exec(backend_responses, &@block)
+      add_failure_handlers(backend_responses)
+      handle_success_or_failure(backend_responses)
+
+      [@frontend_response.status, @frontend_response.headers]
+    end
+
+    def body(value)
+      @frontend_response.body = value
+    end
+
+    def streaming?
+      options[:streaming]
+    end
+
+    def success(value = nil, &block)
+      @frontend_response.status = value
+      @success = block
+    end
+
+    def failure(run = true, &block)
+      run && !@failure && @failure = block
+    end
+
+    def status(value)
+      @frontend_response.status = value
+    end
+
+    def content_type(value)
+      @frontend_response.content_type = value
+    end
+
+    def cookie(key, value)
+      @frontend_response.set_cookie(key, value)
+    end
+
+    def attribute(key, value)
+      @frontend_response.set key, value
+    end
+
+    def object(key, klass, object_data)
+      @frontend_response.set key, object_hash(klass, object_data)
+    end
+
+    def array(key, klass, array_data)
+      value = array_data.map { |data| object_hash(klass, data) }
+      @frontend_response.set key, value
+    end
+
+    def send_body
+      stream_write @frontend_response.body
+    end
+
+    def stream(&block)
+      if block
+        @streaming_block = block
+      else
+        fail "a block is required when streaming"
+      end
+    end
+
+    def do_streaming
+      @streaming_block.call if @streaming_block
+    end
+
+    def stream_write(data)
+      @env.stream_send data
+    end
+
+    def stream_close
+      @env.stream_close
+    end
+
+    private
+
+    def add_failure_handlers(backend_responses)
+      @route[:failure_handlers].each do |block|
+        backend_responses.values.each do |backend_response|
+          instance_exec(backend_response, &block)
+        end
+      end
+    end
+
+    def handle_success_or_failure(backend_responses)
+      if @failure
+        handle_failure
+      elsif backend_responses.all? { |_, resp| resp.success? }
+        handle_success
+      else
+        unhandled_failure(backend_responses)
+      end
+    end
+
+    def handle_failure
+      set_failure_defaults
+      instance_eval(&@failure) if @failure
+    end
+
+    def handle_success
+      set_success_defaults
+      instance_eval(&@success) if @success
+    end
+
+    def unhandled_failure(backend_responses)
+      first_failure = backend_responses.values.first { |resp| !resp.success }
+      status first_failure.status
+      @frontend_response.body = first_failure.body
+    end
+
+    def object_hash(klass, data)
+      klass.new(data).to_hash
+    end
+
+    def set_success_defaults
+      @frontend_response.status ||= 200
+    end
+
+    def set_failure_defaults
+      @frontend_response.status ||= 400
+    end
+  end
+end

data/lib/api_transformer/params.rb

@@ -0,0 +1,8 @@
+require "hashie"
+
+module ApiTransformer
+  # Request parameters
+  class Params < Hash
+    include Hashie::Extensions::IndifferentAccess
+  end
+end

data/lib/api_transformer/rack/cookie_params.rb

@@ -0,0 +1,38 @@
+module ApiTransformer
+  module Rack
+    # Parses out cookies and make them available as request parameters
+    class CookieParams
+      # Cookie string parser
+      module Parser
+        def cookie_params(env)
+          cookie_string = env["HTTP_COOKIE"]
+
+          if cookie_string
+            cookie_pairs = cookie_string.split(/\s*;\s*/)
+
+            cookie_pairs.reduce({}) do |hash, pair|
+              key, value = pair.split("=")
+              hash.merge(key => value)
+            end
+          else
+            {}
+          end
+        end
+      end
+
+      include Goliath::Rack::Validator
+      include Parser
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Goliath::Rack::Validator.safely(env) do
+          env["params"].merge!(cookie_params(env))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/api_transformer/routes.rb

@@ -0,0 +1,71 @@
+require "ostruct"
+
+module ApiTransformer
+  # Collection of routes
+  class Routes
+    # A route
+    class Route < OpenStruct; end
+
+    def initialize
+      @routes = {}
+    end
+
+    def add(args)
+      pattern, path_params = parse_path_definition(args[:path])
+
+      route = Route.new(
+        path_params: path_params,
+        options: args[:options],
+        block: args[:block],
+        failure_handlers: args[:failure_handlers],
+        helper_blocks: args[:helper_blocks]
+      )
+
+      store_route(args[:method], pattern, route)
+    end
+
+    def find(raw_method, path)
+      method = raw_method.downcase.to_sym
+      return unless @routes[method]
+
+      pattern, route = @routes[method].find do |pattern, _|
+        path.match(pattern)
+      end
+
+      [route, path_params(path, route, pattern)]
+    end
+
+    private
+
+    def parse_path_definition(path)
+      parts = path.split(/\//)
+
+      pattern_string = parts
+        .map { |part| part.match(/^\:/) ? "(.*?)" : part }
+        .join("\/")
+        .tap { |inner| "^#{inner}$" }
+
+      pattern = Regexp.new("^#{pattern_string}$")
+
+      params = parts
+        .select { |part| part.match(/^\:/) }
+        .map { |part| part.gsub(/^\:/, "").to_sym }
+
+      [pattern, params]
+    end
+
+    def path_params(path, route, pattern)
+      if pattern
+        matches = path.match(pattern)[1..-1]
+        Hash[route[:path_params].zip(matches)]
+      else
+        {}
+      end
+    end
+
+    def store_route(method, pattern, route)
+      @routes[method] ||= {}
+      @routes[method][pattern] = route
+    end
+  end
+end

data/lib/api_transformer/version.rb

@@ -0,0 +1,4 @@
+# Top-level namespace
+module ApiTransformer
+  VERSION = "0.1.0"
+end

data/lib/api_transformer.rb

@@ -0,0 +1,147 @@
+require "goliath"
+
+require_relative "./api_transformer/endpoint"
+require_relative "./api_transformer/errors"
+require_relative "./api_transformer/backend_request"
+require_relative "./api_transformer/backend_request_sender"
+require_relative "./api_transformer/backend_response"
+require_relative "./api_transformer/frontend_response"
+require_relative "./api_transformer/frontend_response_builder"
+require_relative "./api_transformer/params"
+require_relative "./api_transformer/routes"
+require_relative "./api_transformer/rack/cookie_params"
+
+module ApiTransformer
+  # Inherit from this class to implement an API transformation server:
+  #
+  #   class ExampleServer < ApiTransformer::Server
+  #     base_url "http://ip.jsontest.com/"
+  #
+  #     get "/ip" do |params|
+  #       request :ip do
+  #         path "/"
+  #         method :get
+  #       end
+  #
+  #       response do |data|
+  #         success do
+  #           status 200
+  #           attribute :your_ip, data[:ip][:ip]
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  class Server < Goliath::API
+    use Goliath::Rack::Params
+    use ApiTransformer::Rack::CookieParams
+
+    def on_headers(env, headers)
+      env["client-headers"] = headers
+    end
+
+    def response(env)
+      path = env[Goliath::Request::REQUEST_PATH]
+      route, path_params = @@routes.find(env["REQUEST_METHOD"], path)
+
+      if route
+        run_route(route, path_params, env)
+      else
+        [404, {}, "nope"]
+      end
+    end
+
+    def run_route(route, path_params, env)
+      indifferent_params = Params.try_convert(params.merge(path_params))
+      endpoint = Endpoint.new(@@base_url, env, route)
+      headers = env["client-headers"]
+
+      route[:helper_blocks].each { |block| endpoint.instance_eval(&block) }
+      endpoint.instance_exec(indifferent_params, headers, &route[:block])
+
+      status, headers = endpoint.run
+
+      EM.next_tick do
+        endpoint.complete
+      end
+
+      streaming_response(status, headers)
+    end
+
+    class << self
+      def inherited(klass)
+        klass.use Goliath::Rack::Params
+      end
+
+      def base_url(url)
+        @@base_url = url
+      end
+
+      def namespace(path)
+        prior = [@namespace, failure_handlers.dup, helper_blocks.dup]
+        @namespace = @namespace.to_s + path
+
+        yield
+
+        @namespace, @failure_handlers, @helper_blocks = prior
+      end
+
+      def unhandled_failures(&block)
+        failure_handlers.unshift(block)
+      end
+
+      def helpers(&block)
+        helper_blocks.unshift(block)
+      end
+
+      def get(path = "", options = {}, &block)
+        add_route(:get, path, options, block)
+      end
+
+      def post(path = "", options = {}, &block)
+        add_route(:post, path, options, block)
+      end
+
+      def put(path = "", options = {}, &block)
+        add_route(:put, path, options, block)
+      end
+
+      def delete(path = "", options = {}, &block)
+        add_route(:delete, path, options, block)
+      end
+
+      def reset_routes
+        @@routes = Routes.new
+      end
+
+      private
+
+      def add_route(method, path, options, block)
+        full_path = "#{@namespace}#{path}"
+
+        @@routes ||= Routes.new
+        @@routes.add(method: method, path: full_path, options: options,
+          block: block, failure_handlers: failure_handlers,
+          helper_blocks: helper_blocks)
+      end
+
+      def failure_handlers
+        @failure_handlers ||= []
+      end
+
+      def helper_blocks
+        @helper_blocks ||= []
+      end
+
+      def server
+        superclass
+      end
+    end
+
+    private
+
+    def server
+      self.class
+    end
+  end
+end