blest 0.1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6307985d2fcaa8aa558a9d6fa55bd61787de23accd0d762d12843cf1202784c8
-  data.tar.gz: b58fc887beb5b6312f14f7332daab521b37baa037750eb3b1b406191160ae0d1
+  metadata.gz: dda8d494a672ecd29209b9971076decfaec476253157103dc75a6d74cfc2f327
+  data.tar.gz: dee130556eb32a00cdbb14ae3f5c160133241763061d6558592d1712963cbfc4
 SHA512:
-  metadata.gz: 1f0b5c80b2ae39259d5386c60a7a27deb6b04dc35a5162c30be64056d10581de3b6a6ee47cd800e27f4e4cac1f52a6cb692b47abbda7533ed48dc85c3eafe403
-  data.tar.gz: 964ab1acc3ca2db12a2918bb141efa3f254438c095b47c7e81313c4b5140d7a10b13712b3a4773e6fa1b76158ccc75dffa2af591df45fdb55a767278ea72e470
+  metadata.gz: 4407b468d713463014fa4449efb4e2be40ac59d93fbca2302d1ddc13aa036907b0ba6b4067cd92e1e90a64e37dcca3cd29b0aec605722fd7a5edf4458058245f
+  data.tar.gz: f1c050cdaa44297e90c968ba99be88f3fb440743a959e9ab32286d04ce42a4dc886059bb598c1c29ab0d38d41d7bccc384a86c9d114d5f6398f68da275afb8a3

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 JHunt
+Copyright (c) 2023-2024 JHunt
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,6 +1,6 @@
 # BLEST Ruby
 
-The Ruby reference implementation of BLEST (Batch-able, Lightweight, Encrypted State Transfer), an improved communication protocol for web APIs which leverages JSON, supports request batching and selective returns, and provides a modern alternative to REST.
+The Ruby reference implementation of BLEST (Batch-able, Lightweight, Encrypted State Transfer), an improved communication protocol for web APIs which leverages JSON, supports request batching by default, and provides a modern alternative to REST.
 
 To learn more about BLEST, please visit the website: https://blest.jhunt.dev
 
@@ -10,9 +10,8 @@ For a front-end implementation in React, please visit https://github.com/jhuntde
 
 - Built on JSON - Reduce parsing time and overhead
 - Request Batching - Save bandwidth and reduce load times
-- Compact Payloads - Save more bandwidth
-- Selective Returns - Save even more bandwidth
-- Single Endpoint - Reduce complexity and improve data privacy
+- Compact Payloads - Save even more bandwidth
+- Single Endpoint - Reduce complexity and facilitate introspection
 - Fully Encrypted - Improve data privacy
 
 ## Installation
@@ -25,36 +24,6 @@ gem install blest
 
 ## Usage
 
-This core class of this library has an interface somewhat similar to Sinatra. It also provides a `Router` class with a `handle` method for use in an existing Ruby API and an `HttpClient` class with a `request` method for making BLEST HTTP requests.
-
-```ruby
-require 'blest'
-
-app = Blest.new(timeout: 1000, port: 8080, host: 'localhost', cors: 'http://localhost:3000')
-
-# Create some middleware (optional)
-app.before do |params, context|
-  if params['name'].present?
-    context['user'] = {
-      name: params['name']
-    }
-    nil
-  else
-    raise RuntimeError, "Unauthorized"
-  end
-end
-
-# Create a route controller
-app.route('greet') do |params, context|
-  {
-    greeting: "Hi, #{context['user']['name']}!"
-  }
-end
-
-# Start the server
-app.listen
-```
-
 ### Router
 
 The following example uses Sinatra.
@@ -68,10 +37,10 @@ require 'blest'
 router = Router.new(timeout: 1000)
 
 # Create some middleware (optional)
-router.before do |params, context|
-  if params['name'].present?
+router.before do |body, context|
+  if context.dig('headers', 'auth') == 'myToken'?
     context['user'] = {
-      name: params['name']
+      # user info for example
     }
     nil
   else
@@ -80,9 +49,9 @@ router.before do |params, context|
 end
 
 # Create a route controller
-router.route('greet') do |params, context|
+router.route('greet') do |body, context|
   {
-    greeting: "Hi, #{context['user']['name']}!"
+    greeting: "Hi, #{body['name']}!"
   }
 end
 
@@ -106,13 +75,13 @@ end
 require 'blest'
 
 # Create a client
-client = HttpClient.new('http://localhost:8080', max_batch_size = 25, buffer_delay = 10, headers = {
+client = HttpClient.new('http://localhost:8080', max_batch_size = 25, buffer_delay = 10, http_headers = {
   'Authorization': 'Bearer token'
 })
 
 # Send a request
 begin
-  result = client.request('greet', { 'name': 'Steve' }, ['greeting']).value
+  result = client.request('greet', { 'name': 'Steve' }, { 'auth': 'myToken' }).value
   # Do something with the result
 rescue => error
   # Do something in case of error

data/lib/blest.rb

@@ -1,6 +1,4 @@
-require 'socket'
 require 'json'
-require 'date'
 require 'concurrent'
 require 'securerandom'
 require 'net/http'
@@ -50,7 +48,7 @@ class Router
   end
 
   def route(route, &handler)
-    route_error = validate_route(route)
+    route_error = validate_route(route, false)
     raise ArgumentError, route_error if route_error
     raise ArgumentError, 'Route already exists' if @routes.key?(route)
     raise ArgumentError, 'Handler should be a function' unless handler.respond_to?(:call)
@@ -58,8 +56,7 @@ class Router
     @routes[route] = {
       handler: [*@middleware, handler, *@afterware],
       description: nil,
-      parameters: nil,
-      result: nil,
+      schema: nil,
       visible: @introspection,
       validate: false,
       timeout: @timeout
@@ -75,14 +72,9 @@ class Router
       @routes[route]['description'] = config['description']
     end
 
-    if config.key?('parameters')
-      raise ArgumentError, 'Parameters should be a dict' if !config['parameters'].nil? && !config['parameters'].is_a?(Hash)
-      @routes[route]['parameters'] = config['parameters']
-    end
-
-    if config.key?('result')
-      raise ArgumentError, 'Result should be a dict' if !config['result'].nil? && !config['result'].is_a?(Hash)
-      @routes[route]['result'] = config['result']
+    if config.key?('schema')
+      raise ArgumentError, 'Schema should be a dict' if !config['schema'].nil? && !config['schema'].is_a?(Hash)
+      @routes[route]['schema'] = config['schema']
     end
 
     if config.key?('visible')
@@ -125,7 +117,7 @@ class Router
   def namespace(prefix, router)
     raise ArgumentError, 'Router is required' unless router.is_a?(Router)
 
-    prefix_error = validate_route(prefix)
+    prefix_error = validate_route(prefix, false)
     raise ArgumentError, prefix_error if prefix_error
 
     new_routes = router.routes.keys
@@ -155,51 +147,28 @@ end
 
 
 
-class Blest < Router
-  @options = nil
-  @errorhandler = nil
-
-  def initialize(options = nil)
-    @options = options
-    super(options)
-  end
-
-  def errorhandler(&errorhandler)
-    @errorhandler = errorhandler
-    puts 'The errorhandler method is not currently used'
-  end
-
-  def listen(*args)
-    request_handler = create_request_handler(@routes)
-    server = create_http_server(request_handler, @options)
-    server.call(*args)
-  end
-end
-
-
-
 class HttpClient
   attr_reader :queue, :futures
   attr_accessor :url, :max_batch_size, :buffer_delay, :headers
 
-  def initialize(url, max_batch_size = 25, buffer_delay = 10, headers = {})
+  def initialize(url, max_batch_size = 25, buffer_delay = 10, http_headers = {})
     @url = url
     @max_batch_size = max_batch_size
     @buffer_delay = buffer_delay
-    @headers = headers
+    @http_headers = http_headers
     @queue = Queue.new
     @futures = {}
     @lock = Mutex.new
   end
 
-  def request(route, parameters=nil, selector=nil)
-    uuid = SecureRandom.uuid
+  def request(route, body=nil, headers=nil)
+    uuid = SecureRandom.uuid()
     future = Concurrent::Promises.resolvable_future
     @lock.synchronize do
       @futures[uuid] = future
     end
 
-    @queue.push({ uuid: uuid, data: [uuid, route, parameters, selector] })
+    @queue.push({ uuid: uuid, data: [uuid, route, body, headers] })
     process_timeout()
     future
   end
@@ -232,7 +201,7 @@ class HttpClient
     http = Net::HTTP.new(uri.host, uri.port)
     http.use_ssl = true if uri.scheme == 'https'
 
-    request = Net::HTTP::Post.new(path, @headers.merge({ 'Accept' => 'application/json', 'Content-Type' => 'application/json' }))
+    request = Net::HTTP::Post.new(path, @http_headers.merge({ 'Accept' => 'application/json', 'Content-Type' => 'application/json' }))
     request.body = JSON.generate(batch.map { |item| item[:data] })
 
     http.request(request)
@@ -286,331 +255,13 @@ end
 
 
 
-class HttpServer
-  attr_reader :url, :host, :port, :cors, :headers
-
-  def initialize(request_handler, options = {})
-    unless request_handler.is_a?(Router)
-      raise ArgumentError, "request_handler must be an instance of Router class"
-    end
-    @request_handler = request_handler
-    if options
-      options_error = validate_server_options(options)
-      raise ArgumentError, options_error if options_error
-    else
-      @options = {}
-    end
-
-    @url = options && get_value(options, :url) || '/'
-    @host = options && get_value(options, :host) || 'localhost'
-    @port = options && get_value(options, :port) || 8080
-    @cors = options && get_value(options, :cors) || false
-    cors_default = cors == true ? '*' : cors || ''
-
-    @headers = {
-      'access-control-allow-origin' => options && get_value(options, :accessControlAllowOrigin) || cors_default,
-      'content-security-policy' => options && get_value(options, :contentSecurityPolicy) || "default-src 'self';base-uri 'self';font-src 'self' https: data:;form-action 'self';frame-ancestors 'self';img-src 'self' data:;object-src 'none';script-src 'self';script-src-attr 'none';style-src 'self' https: 'unsafe-inline';upgrade-insecure-requests",
-      'cross-origin-opener-policy' => options && get_value(options, :crossOriginOpenerPolicy) || 'same-origin',
-      'cross-origin-resource-policy' => options && get_value(options, :crossOriginResourcePolicy) || 'same-origin',
-      'origin-agent-cluster' => options && get_value(options, :originAgentCluster) || '?1',
-      'referrer-policy' => options && get_value(options, :referrerPolicy) || 'no-referrer',
-      'strict-transport-security' => options && get_value(options, :strictTransportSecurity) || 'max-age=1555200 includeSubDomains',
-      'x-content-type-options' => options && get_value(options, :xContentTypeOptions) || 'nosniff',
-      'x-dns-prefetch-control' => options && get_value(options, :xDnsPrefetchOptions) || 'off',
-      'x-download-options' => options && get_value(options, :xDownloadOptions) || 'noopen',
-      'x-frame-options' => options && get_value(options, :xFrameOptions) || 'SAMEORIGIN',
-      'x-permitted-cross-domain-policies' => options && get_value(options, :xPermittedCrossDomainPolicies) || 'none',
-      'x-xss-protection' => options && get_value(options, :xXssProtection) || '0'
-    }
-  end
-
-  def listen()
-    server = TCPServer.new(@host, @port)
-    puts "Server listening on port #{@port}"
-
-    loop do
-      client = server.accept
-      Thread.new { handle_http_request(client, @request_handler, @http_headers) }
-    end
-  end
-
-  private
-
-  def parse_http_request(request_line)
-    method, path, _ = request_line.split(' ')
-    { method: method, path: path }
-  end
-
-  def parse_http_headers(client)
-    headers = {}
-
-    while (line = client.gets.chomp)
-      break if line.empty?
-
-      key, value = line.split(':', 2)
-      headers[key] = value.strip
-    end
-
-    headers
-  end
-
-  def parse_post_body(client, content_length)
-    body = ''
-  
-    while content_length > 0
-      chunk = client.readpartial([content_length, 4096].min)
-      body += chunk
-      content_length -= chunk.length
-    end
-  
-    body
-  end
-
-  def build_http_response(status, headers, body)
-    response = "HTTP/1.1 #{status}\r\n"
-    headers.each { |key, value| response += "#{key}: #{value}\r\n" }
-    response += "\r\n"
-    response += body
-    response
-  end
-
-  def handle_http_request(client, request_handler, http_headers)
-    request_line = client.gets
-    return unless request_line
-  
-    request = parse_http_request(request_line)
-    
-    headers = parse_http_headers(client)
-  
-    if request[:path] != '/'
-      response = build_http_response('404 Not Found', http_headers, '')
-      client.print(response)
-    elsif request[:method] == 'OPTIONS'
-      response = build_http_response('204 No Content', http_headers, '')
-      client.print(response)
-    elsif request[:method] == 'POST'
-
-      content_length = headers['Content-Length'].to_i
-      body = parse_post_body(client, content_length)
-      
-      begin
-        json_data = JSON.parse(body)
-        context = {
-          'headers' => headers
-        }
-
-        response_headers = http_headers.merge({
-          'Content-Type' => 'application/json'
-        })
-
-        result, error = request_handler.(json_data, context)
-
-        if error
-            response_json = error.to_json
-            response = build_http_response('500 Internal Server Error', response_headers, response_json)
-            client.print response
-        elsif result
-            response_json = result.to_json
-            response = build_http_response('200 OK', response_headers, response_json)
-            client.print response
-        else
-          response = build_http_response('500 Internal Server Error', response_headers, { 'message' => 'Request handler failed to return a result' }.to_json)
-          client.print response
-        end
-
-      rescue JSON::ParserError
-        response = build_http_response('400 Bad Request', http_headers, '')
-      end
-
-    else
-      response = build_http_response('405 Method Not Allowed', http_headers, '')
-      client.print(response)
-    end
-    client.close()
-  end
-
-end
-
-
-
-
-
-
-
-def create_http_server(request_handler, options = nil)
-  if options
-    options_error = validate_server_options(options)
-    raise ArgumentError, options_error if options_error
-  end
-
-  url = options && get_value(options, :url) || '/'
-  port = options && get_value(options, :port) || 8080
-  cors = options && get_value(options, :cors) || false
-  cors_default = cors == true ? '*' : cors || ''
-  
-  http_headers = {
-    'access-control-allow-origin' => options && get_value(options, :accessControlAllowOrigin) || cors_default,
-    'content-security-policy' => options && get_value(options, :contentSecurityPolicy) || "default-src 'self';base-uri 'self';font-src 'self' https: data:;form-action 'self';frame-ancestors 'self';img-src 'self' data:;object-src 'none';script-src 'self';script-src-attr 'none';style-src 'self' https: 'unsafe-inline';upgrade-insecure-requests",
-    'cross-origin-opener-policy' => options && get_value(options, :crossOriginOpenerPolicy) || 'same-origin',
-    'cross-origin-resource-policy' => options && get_value(options, :crossOriginResourcePolicy) || 'same-origin',
-    'origin-agent-cluster' => options && get_value(options, :originAgentCluster) || '?1',
-    'referrer-policy' => options && get_value(options, :referrerPolicy) || 'no-referrer',
-    'strict-transport-security' => options && get_value(options, :strictTransportSecurity) || 'max-age=1555200 includeSubDomains',
-    'x-content-type-options' => options && get_value(options, :xContentTypeOptions) || 'nosniff',
-    'x-dns-prefetch-control' => options && get_value(options, :xDnsPrefetchOptions) || 'off',
-    'x-download-options' => options && get_value(options, :xDownloadOptions) || 'noopen',
-    'x-frame-options' => options && get_value(options, :xFrameOptions) || 'SAMEORIGIN',
-    'x-permitted-cross-domain-policies' => options && get_value(options, :xPermittedCrossDomainPolicies) || 'none',
-    'x-xss-protection' => options && get_value(options, :xXssProtection) || '0'
-  }
-
-  def parse_http_request(request_line)
-    method, path, _ = request_line.split(' ')
-    { method: method, path: path }
-  end
-
-  def parse_http_headers(client)
-    headers = {}
-
-    while (line = client.gets.chomp)
-      break if line.empty?
-
-      key, value = line.split(':', 2)
-      headers[key] = value.strip
-    end
-
-    headers
-  end
-
-  def parse_post_body(client, content_length)
-    body = ''
-  
-    while content_length > 0
-      chunk = client.readpartial([content_length, 4096].min)
-      body += chunk
-      content_length -= chunk.length
-    end
-  
-    body
-  end
-
-  def build_http_response(status, headers, body)
-    response = "HTTP/1.1 #{status}\r\n"
-    headers.each { |key, value| response += "#{key}: #{value}\r\n" }
-    response += "\r\n"
-    response += body
-    response
-  end
-
-  def handle_http_request(client, request_handler, http_headers)
-    request_line = client.gets
-    return unless request_line
-  
-    request = parse_http_request(request_line)
-    
-    headers = parse_http_headers(client)
-  
-    if request[:path] != '/'
-      response = build_http_response('404 Not Found', http_headers, '')
-      client.print(response)
-    elsif request[:method] == 'OPTIONS'
-      response = build_http_response('204 No Content', http_headers, '')
-      client.print(response)
-    elsif request[:method] == 'POST'
-
-      content_length = headers['Content-Length'].to_i
-      body = parse_post_body(client, content_length)
-      
-      begin
-        json_data = JSON.parse(body)
-        context = {
-          'headers' => headers
-        }
-
-        response_headers = http_headers.merge({
-          'Content-Type' => 'application/json'
-        })
-
-        result, error = request_handler.(json_data, context)
-
-        if error
-            response_json = error.to_json
-            response = build_http_response('500 Internal Server Error', response_headers, response_json)
-            client.print response
-        elsif result
-            response_json = result.to_json
-            response = build_http_response('200 OK', response_headers, response_json)
-            client.print response
-        else
-          response = build_http_response('500 Internal Server Error', response_headers, { 'message' => 'Request handler failed to return a result' }.to_json)
-          client.print response
-        end
-
-      rescue JSON::ParserError
-        response = build_http_response('400 Bad Request', http_headers, '')
-      end
-
-    else
-      response = build_http_response('405 Method Not Allowed', http_headers, '')
-      client.print(response)
-    end
-    client.close()
-  end
-
-  run = ->() do
-
-    server = TCPServer.new('localhost', port)
-    puts "Server listening on port #{port}"
-
-    begin
-      loop do
-        client = server.accept
-        Thread.new { handle_http_request(client, request_handler, http_headers) }
-      end
-    rescue Interrupt
-      exit 1
-    end
-
-  end
-
-  return run
-end
-
-
-
-def validate_server_options(options)
-  if options.nil? || options.empty?
-    return nil
-  elsif !options.is_a?(Hash)
-    return 'Options should be a hash'
-  else
-    if options.key?(:url)
-      if !options[:url].is_a?(String)
-        return '"url" option should be a string'
-      elsif !options[:url].start_with?('/')
-        return '"url" option should begin with a forward slash'
-      end
-    end
-
-    if options.key?(:cors)
-      if !options[:cors].is_a?(String) && !options[:cors].is_a?(TrueClass) && !options[:cors].is_a?(FalseClass)
-        return '"cors" option should be a string or boolean'
-      end
-    end
-  end
-
-  return nil
-end
-
-
-
 def create_request_handler(routes)
   raise ArgumentError, 'A routes object is required' unless routes.is_a?(Hash)
 
   my_routes = {}
 
   routes.each do |key, route|
-    route_error = validate_route(key)
+    route_error = validate_route(key, false)
     raise ArgumentError, "#{route_error}: #{key}" if route_error
 
     if route.is_a?(Array)
@@ -653,16 +304,26 @@ end
 
 
 
-def validate_route(route)
+def validate_route(route, system)
   route_regex = /^[a-zA-Z][a-zA-Z0-9_\-\/]*[a-zA-Z0-9]$/
+  system_route_regex = /^_[a-zA-Z][a-zA-Z0-9_\-\/]*[a-zA-Z0-9]$/
   if route.nil? || route.empty?
     return 'Route is required'
-  elsif !(route =~ route_regex)
+  elsif system && !(route =~ system_route_regex)
+    route_length = route.length
+    if route_length < 3
+      return 'System route should be at least three characters long'
+    elsif route[0] != '_'
+      return 'System route should start with an underscore'
+    elsif !(route[-1] =~ /^[a-zA-Z0-9]/)
+      return 'System route should end with a letter or a number'
+    else
+      return 'System route should contain only letters, numbers, dashes, underscores, and forward slashes'
+    end
+  elsif !system && !(route =~ route_regex)
     route_length = route.length
     if route_length < 2
       return 'Route should be at least two characters long'
-    elsif route[-1] == '/'
-      return 'Route should not end in a forward slash'
     elsif !(route[0] =~ /^[a-zA-Z]/)
       return 'Route should start with a letter'
     elsif !(route[-1] =~ /^[a-zA-Z0-9]/)
@@ -692,6 +353,7 @@ def handle_request(routes, requests, context = {})
     return handle_error(400, 'Request should be an array')
   end
 
+  batch_id = SecureRandom.uuid()
   unique_ids = []
   promises = []
 
@@ -703,8 +365,8 @@ def handle_request(routes, requests, context = {})
 
     id = request[0] || nil
     route = request[1] || nil
-    parameters = request[2] || nil
-    selector = request[3] || nil
+    body = request[2] || nil
+    headers = request[3] || nil
 
     if id.nil? || !id.is_a?(String)
       return handle_error(400, 'Request item should have an ID')
@@ -714,12 +376,12 @@ def handle_request(routes, requests, context = {})
       return handle_error(400, 'Request items should have a route')
     end
 
-    if parameters && !parameters.is_a?(Hash)
-      return handle_error(400, 'Request item parameters should be an object')
+    if body && !body.is_a?(Hash)
+      return handle_error(400, 'Request item body should be an object')
     end
 
-    if selector && !selector.is_a?(Array)
-      return handle_error(400, 'Request item selector should be an array')
+    if headers && !headers.is_a?(Hash)
+      return handle_error(400, 'Request item headers should be an object')
     end
 
     if unique_ids.include?(id)
@@ -741,21 +403,20 @@ def handle_request(routes, requests, context = {})
     request_object = {
       id: id,
       route: route,
-      parameters: parameters || {},
-      selector: selector
+      body: body || {},
+      headers: headers
     }
 
-    my_context = {
-      'requestId' => id,
-      'routeName' => route,
-      'selector' => selector,
-      'requestTime' => DateTime.now.to_time.to_i
-    }
+    request_context = {}
     if context.is_a?(Hash)
-      my_context = my_context.merge(context)
+      request_context = request_context.merge(context)
     end
+    request_context["batch_id"] = batch_id
+    request_context["request_id"] = id
+    request_context["route"] = route
+    request_context["headers"] = headers
 
-    promises << Thread.new { route_reducer(route_handler, request_object, my_context, timeout) }
+    promises << Thread.new { route_reducer(route_handler, request_object, request_context, timeout) }
   end
 
   results = promises.map(&:value)
@@ -820,7 +481,7 @@ def route_reducer(handler, request, context, timeout = nil)
         if h.respond_to?(:call)
           temp_result = Concurrent::Promises.future do
             begin
-              h.call(request[:parameters], safe_context)
+              h.call(request[:body], safe_context)
             rescue => e
               error = e
             end
@@ -845,7 +506,7 @@ def route_reducer(handler, request, context, timeout = nil)
       if handler.respond_to?(:call)
         my_result = Concurrent::Promises.future do
           begin
-            handler.call(request[:parameters], safe_context)
+            handler.call(request[:body], safe_context)
           rescue => e
             error = e
           end
@@ -880,9 +541,9 @@ def route_reducer(handler, request, context, timeout = nil)
       return [request[:id], request[:route], nil, { 'message' => 'Internal Server Error', 'status' => 500 }]
     end
 
-    if request[:selector]
-      result = filter_object(result, request[:selector])
-    end
+    # if request[:selector]
+    #   result = filter_object(result, request[:selector])
+    # end
 
     [request[:id], request[:route], result, nil]
   rescue => error

data/spec/blest_spec.rb

@@ -36,12 +36,13 @@ RSpec.describe Router do
   error6 = nil
 
   before(:all) do
-    router.route('basicRoute') do |parameters, context|
-      { 'route'=> 'basicRoute', 'parameters' => parameters, 'context' => context }
+    router.route('basicRoute') do |body, context|
+      { 'route'=> 'basicRoute', 'body' => body, 'context' => context }
     end
 
-    router.before do |parameters, context|
-      context['test'] = { 'value' => parameters['testValue'] }
+    router.before do |body, context|
+      context['test'] = { 'value' => body['testValue'] }
+      context['requestTime'] = Time.now
       nil
     end
 
@@ -52,20 +53,20 @@ RSpec.describe Router do
       nil
     end
 
-    router2.route('mergedRoute') do |parameters, context|
-      { 'route' => 'mergedRoute', 'parameters' => parameters, 'context' => context }
+    router2.route('mergedRoute') do |body, context|
+      { 'route' => 'mergedRoute', 'body' => body, 'context' => context }
     end
 
-    router2.route('timeoutRoute') do |parameters|
+    router2.route('timeoutRoute') do |body|
       sleep(0.2)
-      { 'testValue' => parameters['testValue'] }
+      { 'testValue' => body['testValue'] }
     end
 
     router.merge(router2)
 
-    router3.route('errorRoute') do |parameters|
-      error = BlestError.new(parameters['testValue'])
-      error.code = "ERROR_#{(parameters['testValue'].to_f * 10).round}"
+    router3.route('errorRoute') do |body|
+      error = BlestError.new(body['testValue'])
+      error.code = "ERROR_#{(body['testValue'].to_f * 10).round}"
       raise error
     end
 
@@ -140,9 +141,9 @@ RSpec.describe Router do
     expect(result5[0][1]).to eq('timeoutRoute')
   end
 
-  it 'should accept parameters' do
-    expect(result1[0][2]['parameters']['testValue']).to eq(testValue1)
-    expect(result2[0][2]['parameters']['testValue']).to eq(testValue2)
+  it 'should accept body' do
+    expect(result1[0][2]['body']['testValue']).to eq(testValue1)
+    expect(result2[0][2]['body']['testValue']).to eq(testValue2)
   end
 
   it 'should respect context' do

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: blest
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.1
 platform: ruby
 authors:
 - JHunt
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-01 00:00:00.000000000 Z
+date: 2024-10-31 00:00:00.000000000 Z
 dependencies: []
 description: The Ruby reference implementation of BLEST (Batch-able, Lightweight,
   Encrypted State Transfer), an improved communication protocol for web APIs which
-  leverages JSON, supports request batching and selective returns, and provides a
-  modern alternative to REST.
+  leverages JSON, supports request batching by default, and provides a modern alternative
+  to REST.
 email:
-- blest@jhunt.dev
+- hello@jhunt.dev
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -28,7 +28,7 @@ homepage: https://blest.jhunt.dev
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -43,8 +43,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: The Ruby reference implementation of BLEST
 test_files: []