blest 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6307985d2fcaa8aa558a9d6fa55bd61787de23accd0d762d12843cf1202784c8
-  data.tar.gz: b58fc887beb5b6312f14f7332daab521b37baa037750eb3b1b406191160ae0d1
+  metadata.gz: c4f44d941bb783457e67fa52ada69792f5f645a76bac399165d59c73f4ba7b4b
+  data.tar.gz: 8f7ee45d396ae4cab3c8178f1bef7e6605612efb94e259cbb35bcd3da842e347
 SHA512:
-  metadata.gz: 1f0b5c80b2ae39259d5386c60a7a27deb6b04dc35a5162c30be64056d10581de3b6a6ee47cd800e27f4e4cac1f52a6cb692b47abbda7533ed48dc85c3eafe403
-  data.tar.gz: 964ab1acc3ca2db12a2918bb141efa3f254438c095b47c7e81313c4b5140d7a10b13712b3a4773e6fa1b76158ccc75dffa2af591df45fdb55a767278ea72e470
+  metadata.gz: aecfa3005a9a29bcfd4b4f501710a0f8a49251ff7fc62f4043bfe8e5b0e7f6c8e2ddbb09df2ae14c08bc7617a09ab08d84ed52d9023272bd9bb05dabd1fb8e41
+  data.tar.gz: 2855b895975b23f418e0e084ecd3d15bd8df43764a896aca1f8fa5788d21e74ab7fb5ff5fdc4bbcd79a074dff7ce2f14bb3a10ee4e497d8ef1d63b1a645066c3

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,7 +24,7 @@ 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.
+The `Blest` class of this library has an interface 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'
@@ -33,10 +32,10 @@ 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?
+app.before do |body, context|
+  if context.dig('headers', 'auth') == 'myToken'?
     context['user'] = {
-      name: params['name']
+      # user info for example
     }
     nil
   else
@@ -45,9 +44,9 @@ app.before do |params, context|
 end
 
 # Create a route controller
-app.route('greet') do |params, context|
+app.route('greet') do |body, context|
   {
-    greeting: "Hi, #{context['user']['name']}!"
+    greeting: "Hi, #{body['name']}!"
   }
 end
 
@@ -68,10 +67,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 +79,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,7 +105,7 @@ 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'
 })
 

data/lib/blest.rb

@@ -1,6 +1,5 @@
 require 'socket'
 require 'json'
-require 'date'
 require 'concurrent'
 require 'securerandom'
 require 'net/http'
@@ -50,7 +49,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 +57,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 +73,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 +118,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
@@ -182,24 +175,24 @@ 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 +225,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)
@@ -610,7 +603,7 @@ def create_request_handler(routes)
   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 +646,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 +695,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 +707,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 +718,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 +745,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 +823,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 +848,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 +883,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.0
 platform: ruby
 authors:
 - JHunt
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-01 00:00:00.000000000 Z
+date: 2024-10-28 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: []