phaedra 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00d5ba6f3bc10860baef3bf63867665db4ef610b7cf14a8281495cf929339bc3
-  data.tar.gz: 5d1c500a8cbe79a89182497e7881fdeba3d129e5e2f2ddcce19012f9ae713171
+  metadata.gz: 65ebfc3c9c8023c4a680704a085d9b4b62505fce1df1a82ca6d57bd9785c5ec2
+  data.tar.gz: d3384f2fa5d94ba594427970aad49cabe47b1d59d6f2a3289ba608c413e8d3db
 SHA512:
-  metadata.gz: 3f3a8145df4a02f5362dfffb66f1de44ccd650425504007f2f49fa666c68bd9d228d0e8ade98daa2d318c57b220013009bd2c9b37d10d375a7cecca2cee0c4ac
-  data.tar.gz: f0effbf926248e56c67da411bd688cc3f6783d7710bdedf141029d523b4e55667df18b1e509cb68aa55795a01b74369ac8e007a91754ac9b3c6046741d166258
+  metadata.gz: c40e0c8017d3bb172a144b365ecaf62bc1d9b602c575740fefff8e0876ab54d853d1c5434aa2da8b8f02cda11d8f43084b5354d86464195374ee76799fd2e9c5
+  data.tar.gz: 763f60081477658fd4cfad3461cc8f9148c3c1c3e4d7f20d4571e1cf4d136c24c55a6aecfbc2c39c4ec3471bfadf7cca101be51dc7f3bcceb72c5e4eb21a2cdd

data/README.md

@@ -1,9 +1,15 @@
 # Phaedra: Serverless Ruby Functions
 
-Phaedra is a web microframework for writing serverless Ruby functions. They are isolated pieces of logic which respond to HTTP requests (GET, POST, etc.) and typically get mounted at a particular URL path. They can be tested locally and deployed to a supported serverless hosting platform or to any [Rack-compatible web server](https://github.com/rack/rack).
+Phaedra is a web microframework for writing serverless Ruby functions. They are isolated pieces of logic which respond to HTTP requests (GET, POST, etc.) and typically get mounted at a particular URL path. They can be tested locally and deployed to a supported serverless hosting platform, using a container via Docker & Docker Compose, or to any [Rack-compatible web server](https://github.com/rack/rack).
+
+Phaedra is well-suited for building an API layer which you attach to a static site (aka [the Jamstack](https://www.bridgetownrb.com/docs/jamstack)) to provide dynamic functionality accessible any time after the static site loads in the browser.
 
 Serverless compatibility is presently focused on [Vercel](https://vercel.com) and [OpenFaaS](https://openfaas.com), but there are likely additional platforms we'll be adding support for in the future.
 
+For swift deployment via Docker, we recommend [Fly.io](https://fly.io).
+
+(P.S. Wondering how you can deploy a static site on [Netlify](https://www.netlify.com) and still use a Ruby API? Scroll down for a suggested approach!)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -24,18 +30,26 @@ Or install it yourself as:
 $ gem install phaedra
 ```
 
+## Examples
+
+[Here's an example](https://github.com/whitefusionhq/phaedra/tree/master/example) of what the structure of a typical Phaedra app looks like. It includes `config.ru` for booting it up as a Rack app using Puma, as well as a `Dockerfile` and `docker-compose.yml` so you can run the app containerized in virtually any development or production hosting environment.
+
+[Here's a demo](https://phaedra-demo.whitefusion.design/api/env) of one of the functions. [And another one.](https://phaedra-demo.whitefusion.design/api/params?search=Waiting%20for%20Guffman)
+
 ## Usage
 
 Functions are single Ruby files which respond to a URL path (aka `/api/path/to/function`). The path is determined by the location of the file on the filesystem relative to the functions root (aka `api`). So, given a path of `./api/folder/run-me.rb`, the URL path would be `/api/folder/run-me`.
 
 Functions are written as subclasses of `Phaedra::Base` using the name `PhaedraFunction`. The `params` argument is a Hash containing the parsed contents of the incoming query string, form data, or body JSON. The response object returned by your function is typically a Hash which will be transformed into JSON output automatically, but it can also be plain text.
 
+Code to be run once upon function initialization and shared between multiple functions should be placed in the `phaedra/initializers.rb` file (see more on that below).
+
 Some platforms such as Vercel require the function class name to be `Handler`, so you can put that at the bottom of your file for full compatibility.
 
 Here's a basic example:
 
 ```ruby
-require "phaedra"
+require_relative "../phaedra/initializers"
 
 class PhaedraFunction < Phaedra::Base
   def get(params)
@@ -60,17 +74,23 @@ Functions can define `action` callbacks:
 ```ruby
 class PhaedraFunction < Phaedra::Base
   before_action :do_stuff_before
-  after_action :do_stuff_after
+  after_action do
+    # process response object further...
+  end
   around_action :do_it_all_around
 
   def do_stuff_before
-    # code
+    # process request object before action handler...
   end
 
-  # do_stuff_after, etc.
+  def do_it_all_around
+    # run code before
+    yield
+    # run code after
+  end
 
   def get(params)
-    # this will be run within the callback chain
+    # this will be run within the entire callback chain
   end
 end
 ```
@@ -79,34 +99,51 @@ You can modify the `request` object in a `before_action` callback to perform set
 
 ### Shared Code You Only Want to Run Once
 
-You can use `require_relative` to load and execute shared Ruby code from another folder, say `lib`. This is particularly useful when setting up a database connection or performing expensive operations you only want to do once, rather than for every request.
+Phaedra provides a default location to place shared modules and code that should be run once upon first deployment of your functions. This is particularly useful when setting up a database connection or performing expensive operations you only want to do once, rather than for every request.
+
+Here's an example of how that works:
 
 ```ruby
 # api/run-it-once.rb
 
-require "phaedra"
-require_relative "../lib/shared_code"
+require_relative "../phaedra/initializers"
 
 class PhaedraFunction < Phaedra::Base
   def get(params)
-    "Run it once! #{SharedCode.run_once} / #{Time.now}"
+    "Run it once! #{Phaedra::Shared.run_once} / #{Time.now}"
   end
 end
 ```
 
 ```ruby
-# lib/shared_code.rb
+# phaedra/initializers.rb
+
+module Phaedra
+  module Shared
+    Initializers.register self do
+      run_once
+    end
 
-module SharedCode
-  def self.run_once
-    @one_time ||= Time.now
+    def self.run_once
+      @only_once ||= Time.now
+    end
   end
 end
 ```
 
-Now each time you invoke the function at `/api/run-it-once`, the first timestamp will never change until the next redeployment.
+Now each time you invoke the function at `/api/run-it-once`, the timestamp will never change until the next redeployment.
+
+**NOTE:** When running in a Rack-based configuration (see below), Ruby's `load` method is invoked for every request to any Phaedra function. This means Ruby has to parse and compile the code in your function each time. For small functions this happens extremely quickly, but if you find yourself writing a large function and seeing some performance slowdowns, consider extracting most of the function code to additional Ruby files and using the `require_relative` technique as mentioned above. The Ruby code in those required files will only be compiled once and all classes/modules/etc. will be saved in memory until the next redeployment.
 
-**NOTE:** When running in a Rack-based configuration (see below), Ruby's `load` method is invoked for every request to any Phaedra function. This means Ruby has to parse and compile the code in your function each time. For small functions this happens extremely quickly, but if you find yourself writing a large function and seeing some performance slowdowns, consider extracting most of the function code to additional Ruby files and use the `require_relative` technique as mentioned above. The Ruby code in those required files will only be compiled once and all classes/modules/etc. will be saved in memory until the next redeployment.
+## Environment
+
+You can set the environment of your Phaedra app using the `PHAEDRA_ENV` environment variable. That is then available via the `Phaedra.environment` method. By default, the value is `:development`.
+
+```ruby
+# ENV["PHAEDRA_ENV"] == "production"
+
+Phaedra.environment == :production  # true
+```
 
 ## Deployment
 
@@ -252,6 +289,45 @@ server {
 
 Change the `server_name`, `root`, and `passenger_ruby` paths to your particular setup and you'll be good to go. (If you run into any errors, double-check there's a `config.ru` in the parent folder of your site destination folder.)
 
+### Docker
+
+[In the example app provided](https://github.com/whitefusionhq/phaedra/tree/master/example), there is a `config.ru` file for booting it up as a Rack app using Puma. The `Dockerfile` and `docker-compose.yml` files allow you to easily build and deploy the app at port 8080 (but that can easily be changed). Using the Docker Compose commands:
+
+```sh
+# Build (if necessary) and deploy:
+docker-compose up
+
+# Get information on the running container:
+docker-compose ps
+
+# Inspect the output logs:
+docker-compose logs
+
+# Exit the running container:
+docker-compose down
+
+# If you make changes to the code and need to rebuild:
+docker-compose up --build
+```
+
+#### Fly.io
+
+Deploying your Phaedra app's Docker container via [Fly.io](https://fly.io) couldn't be easier. Simply create a new app and deploy using Fly.io's command line utility:
+
+```sh
+# Create the new app using your Fly.io account:
+flyctl apps create
+
+# Deploy using the Dockerfile:
+flyctl deploy
+
+# Print out the URL and other info on your new app:
+flyctl info
+
+# Change the Phaedra app environment:
+flyctl secrets set PHAEDRA_ENV=production
+```
+
 ### WEBrick
 
 Integrating Phaedra into a WEBrick server is pretty straightforward. Given a `server` object, it can be accomplished thusly:
@@ -286,7 +362,21 @@ load File.join(Dir.pwd, "api", "func.rb")
 @server.mount '/path', Handler
 ```
 
-This method precludes any automatic routing by Phaedra, so it's discouraged unless you are using WEBrick within a larger setup that utilizes its own routing method. (Interestingly enough, that's how Vercel works under the hood.)
+This method precludes any automatic routing by Phaedra, so it's discouraged unless you are using WEBrick within a larger setup that utilizes its own routing method. (Interestingly enough, [that's how Vercel works under the hood](https://github.com/vercel/vercel/blob/master/packages/now-ruby/now_init.rb).)
+
+## Connecting a Static Site on Netlify to a Phaedra API
+
+[Netlify](https://www.netlify.com) is a popular hosting solution for Jamstack (static) sites, but its serverless functions feature doesn't support Ruby. However, using proxy rewrites, you can deploy the static site part of your repository to Netlify and set the `/api` endpoint to route requests to your Phaedra app on the fly (hosted elsewhere).
+
+For example, if your Phaedra app is hosted on Fly.io (see above), you'll want Netlify's CDN to proxy all requests to `/api/*` to that app's URL. We can accomplish that by adding a `_redirects` file to the static site's source folder (for Bridgetown sites, that's `src`):
+
+```
+/api/*  https://super-awesome-phaedra-api.fly.dev/api/:splat  200
+```
+
+Once that deploys, you can go to your Netlify site URL, append `/api/whatever`, and under-the-hood that will connect to `https://super-awesome-phaedra-api.fly.dev/api/whatever` in a completely transparent manner.
+
+If you want to change the proxy URL for different contexts (staging vs. production, etc.), you can follow Netlify's "[Separate _redirects files for separate contexts or branches](https://community.netlify.com/t/support-guide-making-redirects-work-for-you-troubleshooting-and-debugging/13433)" instructions here.
 
 ----
 

data/example/Dockerfile

@@ -17,7 +17,7 @@ ARG DOCKER_USER=${DOCKER_USER:-user}
 ARG APP_DIR=${APP_DIR:-/home/user/phaedra-app}
 
 # Change with --build-arg PHAEDRA_ENV=production
-ARG PHAEDRA_ENV=staging
+ARG PHAEDRA_ENV=development
 ENV PHAEDRA_ENV=$PHAEDRA_ENV
 
 # Create a non-root user

data/example/Gemfile

@@ -1,4 +1,4 @@
 source "https://rubygems.org"
 
-gem "phaedra", path: ".."
+gem "phaedra"
 gem "puma"

data/example/README.md

@@ -0,0 +1,19 @@
+# Example Phaedra App
+
+This will spin up a Phaedra demo API running on port 8080 (which can be changed).
+
+## Local Exec
+
+Requires Ruby 2.6 or greater.
+
+```sh
+bundle install
+
+bundle exec rackup -p 8080
+```
+
+## Docker Compose
+
+```sh
+docker-compose up
+```

data/example/api/env.rb

@@ -0,0 +1,15 @@
+require_relative "../phaedra/initializers"
+
+class PhaedraFunction < Phaedra::Base
+  def get(params)
+    response["Content-Type"] = "text/html; charset=utf-8"
+    <<~HTML
+      <p>Hello friend! 😃</p>
+      <p>Startup Time: #{Phaedra::Shared.the_time}</p>
+      <p>Environment: #{Phaedra.environment}</p>
+      <p>Current Time: #{Time.new}</p>
+    HTML
+  end
+end
+
+Handler = PhaedraFunction

data/example/api/{the-time.rb → params.rb}

@@ -4,7 +4,7 @@ class PhaedraFunction < Phaedra::Base
   before_action :earlier_stuff
 
   def get(params)
-    "The ?search param is #{params[:search]}"
+    "The ?search= param is #{params[:search] || "-missing-"}"
   end
 
   def post(params)
@@ -14,10 +14,10 @@ class PhaedraFunction < Phaedra::Base
   private
 
   def earlier_stuff
-    request.query["search"] += " SEARCH!" if request.query["search"]
+    request.query["search"] += " (nice!)" if request.query["search"]
 
     if request.body
-      request.body.sub!("Works", "Lurks")
+      request.body.sub!("Works", "Totally Works")
     end
   end
 end

data/example/phaedra/initializers.rb

@@ -1,11 +1,14 @@
 require "phaedra"
+require "securerandom"
 
 module Phaedra
-  Initializers.register self do
-    the_time("123")
-  end
+  module Shared
+    Initializers.register self do
+      the_time SecureRandom.hex(10)
+    end
 
-  def self.the_time(init = nil)
-    @the_time ||= "#{Time.now} + #{init}"
+    def self.the_time(init = nil)
+      @the_time ||= "#{Time.now} (random seed: #{init})"
+    end
   end
 end

data/lib/phaedra/rack_app.rb

@@ -8,11 +8,18 @@ module Phaedra
     end
 
     def header
-      @env.dup.transform_keys do |key|
+      @transformed_headers ||= @env.dup.transform_keys do |key|
         key.respond_to?(:downcase) ? key.downcase : key
+      end.tap do |headers|
+        # TODO: normalize a few common headers
+        headers["authorization"] = headers["http_authorization"]
       end
     end
 
+    def [](key)
+      header[key]
+    end
+
     def body
       @request_body ||= "" + get_header(Rack::RACK_INPUT).read
     end

data/lib/phaedra/version.rb

@@ -1,3 +1,3 @@
 module Phaedra
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phaedra
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Jared White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-24 00:00:00.000000000 Z
+date: 2020-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -82,8 +82,9 @@ files:
 - Rakefile
 - example/Dockerfile
 - example/Gemfile
-- example/api/simple.rb
-- example/api/the-time.rb
+- example/README.md
+- example/api/env.rb
+- example/api/params.rb
 - example/config.ru
 - example/docker-compose.yml
 - example/phaedra/initializers.rb

data/example/api/simple.rb

@@ -1,10 +0,0 @@
-require_relative "../phaedra/initializers"
-
-class PhaedraFunction < Phaedra::Base
-  def get(params)
-    response["Content-Type"] = "text/html; charset=utf-8"
-    "<p>😁 #{Phaedra.the_time} - #{ENV["PHAEDRA_ENV"]} - #{Time.new}</p>"
-  end
-end
-
-Handler = PhaedraFunction