overture 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4162a0c95318564102aa7e9f969807b3de0db5137f2b3d55147604d478cc330f
-  data.tar.gz: df0d926928a2e898b315ba2193fdedc0480a964efc6722bba2d7dea46f2f3845
+  metadata.gz: 5f0d61e78928fa9a2632f02a2b8585b9b4c72f40e94607c82620d85e88dadf68
+  data.tar.gz: 693f15ca2c7605f91466675b69034a9564705e1da12d193248922805229b9fe8
 SHA512:
-  metadata.gz: 40e2fd8ea32ba37f3bc443af646ce84e820f87db6cf81c38076dcbbf80d48963c03daff2bfe295a34aa5c03e012d9fddc7da8894b2a8bf88b3f1d0e5a5a3de6d
-  data.tar.gz: 9c0155a8f48bbdd4e306456a5393a1736954b45dd960dfd32881a26058e5b9578bdc30a2182c515ec3c24c60e6d62a58a728790206a29b32eca5eabb1b4e9c24
+  metadata.gz: 5ae9931060de12c83439c1bede4abd32a0fabe67b22c87db03a17fb53f65371e301879731d76f18adbe806a4b0f6aa30a26ea40da7751329737d13df08e31f8a
+  data.tar.gz: 75872e72b6668ba506ab89b390b644ebfd308abfbe14716631005edb9d0e02887c3e6062f6d0bea08f9b7697d313da5ed8afbf6d064ee9077ac8d87fae3dc014

data/README.md

@@ -1,15 +1,191 @@
-# Overture
+> overture
+> _noun_
+> 
+> 1. an orchestral piece at the beginning of an opera, suite, play, oratorio, or other extended composition.
+> 2. an introduction to something more substantial
 
-This is a library of tools and configurations based on the Clean Architecture.
+Overture is the _start of something_, an introduction. So this gem provides an introduction to your new application (or service).
+It helps you start developing your application so you can build a full orchestra eventually.
 
-This gem contains the basic configuration options and file organization to create a Ruby application.
+---
 
-Sinatra is used as a delivery layer, but it can be easily replaced. Core business rules live in the Interactors.
+## Install it
+If you're starting from scratch, you can install the gem manually by running:
 
-## Contents
+```bash
+$ gem install overture
+```
 
-- `Overture::Database`
-- `Overture::Interactor`
-- `Overture::Model`
-- `Overture::PasswordDigester`
+If you have an existing app and you want to use Overture, you can add it to your Gemfile:
 
+```ruby
+gem 'overture'
+```
+
+## What it can do?
+
+Title says _can_ because you **can** choose what you need from Overture. You don't need to use everything.
+If you only need a database connection adapter, just pull that. Or if you need a basic Sinatra configuration for a JSON API, just use that.
+
+Overture is a set of tools or modules that you can use independently. All modules can interplay together as well, and they'll let you get something working pretty quickly.
+
+> In most cases you only need the hammer to nail a nail.
+
+### Creating an app
+
+After you install the gem, you can run this command to generate an app directory layout:
+
+```bash
+$ overture generate app my-app
+```
+
+The last argument is the name of the folder you want to use for your app. This will generate a directory structure like the following:
+
+```
+├── Gemfile
+├── Gemfile.lock
+├── Procfile
+├── Rakefile
+├── bin
+│   ├── console
+│   └── dev_http_api
+├── config
+│   ├── environment.rb
+│   └── puma.rb
+├── config.ru
+└── lib
+    ├── http_api
+    │   ├── endpoints.rb
+    │   └── server.rb
+    ├── interactors
+    └── models
+```
+
+This command will create all necessary files to create a full application. This means you'll have three layers:
+
+*Application logic*
+
+All logic that is not specific to your domain (business), is handled here. In other words, this is where all your models (entities) live. Specifically in the `lib/models` directory.
+
+*Business logic*
+
+All the logic that is specific to your domain (business) goes here. This layer is handled by _Interactors_, also known as _Use Cases_. These classes are created in the `lib/interactors` directory.
+
+*Presentation layer*
+
+This is basically the output of your application that is used by other applications or services. This layer is managed by a Sinatra app that accepts and responds to JSON HTTP endpoints. The endpoints are defined in the `lib/http_api/endpoints.rb` file. You can also organize your endpoints in different files/classes, preferably subclasses of the `HttpApi::Server` class defined in  the `lib/http_api/server.rb` file.
+
+All other files outside of `lib` are practically configuration files. You can see what they do by opening them.
+
+Once you create your app, you can run `bin/dev_http_api` to start up a Rack server. This will run in the port 3000 by default but you can change it in the `config/puma.rb` file or with the `PORT` env var.
+
+#### Configuring via environment variables
+
+Overture uses [dotenv](https://rubygems.org/gems/dotenv) to load environment variables defined in the `.env` file of your project.
+
+> You should *NOT* version your `.env` file. Instead you can add a `.env.example` file with dummy values.
+
+### Connecting to a database
+
+You can use `Overture::Database` to create a connection to a database using Sequel.
+
+Once you've generated your app structure, in your `config/environment.rb` file uncomment the line that requires the database module, and the one that creates the connection instance:
+
+```ruby
+require 'overture/database'
+
+DB = Overture::Database.connect(ENV.fetch('DATABASE_URL'))
+```
+
+As you can see, it uses the environment variable `DATABASE_URL`. You can define it in your `.env` file (see [Configuring via environment variables](#configuring-via-environment-variables) section).
+
+### Model the datasets
+
+You can map your database tables to Ruby classes that inherit the `Overture::Model` class.
+
+For example if you have a `users` table, you can create a `User` model like this:
+
+```ruby
+class User < Overture::Model
+end
+```
+
+This will automatically map to the `users` table following the Sequel convention for the tables naming as described [here](http://sequel.jeremyevans.net/rdoc/files/README_rdoc.html#label-Sequel+Models).
+
+You now can persist and retrieve records in the `users` table:
+
+```ruby
+User.create(first_name: 'John')
+user = User.first(first_name: 'John')
+user.update(first_name: 'Juan')
+```
+
+Refer to the [Sequel documentation](http://sequel.jeremyevans.net/rdoc/files/doc/dataset_basics_rdoc.html) to see what methods are available.
+
+#### Version your schema with migrations
+
+To create the tables in your database you can do it manually or use migration files that will also help you revert to a specific version if needed.
+
+In order to create a new migration file you run:
+
+```bash
+$ overture generate migration users
+```
+
+This will create a file under the `migrations` folder. Open it and change to your needs. See the [Sequel migration documentation](http://sequel.jeremyevans.net/rdoc/files/doc/migration_rdoc.html) to know what you can do.
+
+### Implement your business logic
+
+As mentioned above, your business logic lis handled by _interactors_. An interactor is a subclass of the [Interactor class.](https://github.com/collectiveidea/interactor) with some methods added for convenience. See the  [`Overture::Interactor`](lib/overture/interactor.rb) class to find what methods are added.
+
+#### Digest and validate passwords
+
+Overture comes with a password digester module that helps you digest and validate passwords.
+
+To use it, include it in your class and call `digest_password(password)` or `valid_password?(password_digest, plain_password)` methods to digest or validate a password respectively.
+
+For example:
+
+```ruby
+require 'overture/password_digester'
+
+class AuthenticateUser < Overture::Interactor
+  include Overture::PasswordDigester
+
+  required :email, :password
+
+  def call
+	  user = User.first(email: context.email)
+    fail!('user does not exist' unless user
+    context.authenticated = valid_password?(user.password_digest, context.password)
+  end
+end
+```
+
+### Communicate with the exterior
+
+The `Overture::HttpApi::Server` class is a Sinatra app configured to accept and respond to JSON.
+It includes the `Overture::HttpApi::Helpers` module too, which provides some common helpers.
+
+When you generate an app with Overture, it creates a subclass of `Overture::HttpApi::Server` that you can configure to your needs.
+
+You can define your endpoints in the `HttpApi::Endpoints` class. Or organize them in subclasses of `HttpApi::Server` that you can mount in the main `HttpApi::Endpoints` class.
+
+#### Serializing your models
+
+When you have a model class (i.e. `User`), and you want to present it as a JSON. You can use the `json()` helper method and it will automatically try to find a corresponding serializer for that class based on its name plus the `Serializer` suffix. In this case it'd be `UserSerializer`.
+
+The `Overture::Serializer` produces [JSON:API](https://jsonapi.org/) object. And it's based in the [Netflix/fast_jsonapi](https://github.com/Netflix/fast_jsonapi) serializer. So as long as you conform with its interface, you can create your own too.
+
+If you have a serializer that does not conforms to the naming convention, you can specify what serializer to use in the `json()` helper method:
+
+```ruby
+get '/admin/users' do
+  users = User.all
+  json users, serializer: AdminUserSerializer
+end
+```
+
+---
+
+As mentioned in the beginning, you don't need to use all these components. You could for example only use the `Overture::Interactor` class, or the `Overture::PasswordDigester` module in your application.

data/bin/overture

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+class Cli
+  attr_reader :command
+
+  def initialize(command)
+    @command = command.downcase
+  end
+
+  def self.usage
+    require_relative '../lib/overture/version'
+
+    puts <<~HELP
+      Overture version: #{Overture::VERSION}
+      Usage: overture <command> <command-args>'
+
+      Commands:
+
+        generate
+        help
+    HELP
+  end
+
+  def usage
+    case command
+    when 'generate'
+      puts <<~HELP
+        Usage: overture generate <template>
+
+        Templates:
+
+          app <app-name>      Creates an app directory structure
+          migration <name>    Creates a migration file
+      HELP
+    else
+      self.class.usage
+    end
+  end
+
+  def run!(*args)
+    case command
+    when 'generate'
+      generate!(*args)
+    else
+      usage
+    end
+  end
+
+  private
+
+  def generate!(*args)
+    return usage if args.empty?
+
+    case args.shift.downcase
+    when 'app'
+      generate_app!(*args)
+    when 'migration'
+      generate_migration!(*args)
+    else
+      usage
+    end
+  end
+
+  def generate_app!(*args)
+    return usage if args.empty?
+
+    require_relative '../generators/app'
+
+    generator = Overture::Generators::App.new
+    generator.call(app_name: args[0])
+  end
+
+  def generate_migration!(*args)
+    return usage if args.empty?
+
+    require_relative '../generators/migration'
+
+    generator = Overture::Generators::Migration.new
+    generator.call(name: args[0])
+  end
+end
+
+return Cli.usage if ARGV.empty?
+
+cli = Cli.new(ARGV[0])
+cli.run!(*ARGV[1..-1])

data/generators/app.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'templates'
+
+module Overture
+  module Generators
+    class App < Base
+      def call(vars = {})
+        @app_dir = vars[:app_name].gsub(' ', '_').downcase
+
+        create_files(vars)
+        run_setup
+      end
+
+      private
+
+      attr_reader :app_dir
+
+      def create_files(vars)
+        bin(vars)
+        config(vars)
+        lib(vars)
+        config_ru
+        gemfile
+        procfile
+        rakefile
+      end
+
+      def run_setup
+        shell "cd #{app_dir} && bundle install"
+      end
+
+      def bin(vars)
+        bin_vars = vars.fetch(:bin) { {} }
+
+        bin_console(bin_vars)
+        bin_dev_http_api(bin_vars)
+      end
+
+      def config(vars)
+        config_vars = vars.fetch(:config) { {} }
+
+        config_environment(config_vars)
+        config_puma(config_vars)
+      end
+
+      def lib(vars)
+        lib_vars = vars.fetch(:lib) { {} }
+
+        mkdir("#{app_dir}/lib/interactors")
+        mkdir("#{app_dir}/lib/models")
+
+        lib_http_api_server(lib_vars)
+        lib_http_api_endpoints(lib_vars)
+      end
+
+      def config_ru(vars = {})
+        content = compile(Templates[:config_ru], vars)
+        write(content, "#{app_dir}/config.ru")
+      end
+
+      def gemfile(vars = {})
+        content = compile(Templates[:gemfile], vars)
+        write(content, "#{app_dir}/Gemfile")
+      end
+
+      def procfile(vars = {})
+        content = compile(Templates[:procfile], vars)
+        write(content, "#{app_dir}/Procfile")
+      end
+
+      def rakefile(vars = {})
+        content = compile(Templates[:rakefile], vars)
+        write(content, "#{app_dir}/Rakefile")
+      end
+
+      def bin_console(vars = {})
+        content = compile(Templates[:bin_console], vars)
+
+        path = write(content, "#{app_dir}/bin/console")
+        chmod('+x', path)
+      end
+
+      def bin_dev_http_api(vars = {})
+        content = compile(Templates[:bin_dev_http_api], vars)
+
+        path = write(content, "#{app_dir}/bin/dev_http_api")
+        chmod('+x', path)
+      end
+
+      def config_environment(vars = {})
+        content = compile(Templates[:config_environment], vars)
+        write(content, "#{app_dir}/config/environment.rb")
+      end
+
+      def config_puma(vars = {})
+        content = compile(Templates[:config_puma], vars)
+        write(content, "#{app_dir}/config/puma.rb")
+      end
+
+      def lib_http_api_server(vars = {})
+        content = compile(Templates[:lib_http_api_server], vars)
+        write(content, "#{app_dir}/lib/http_api/server.rb")
+      end
+
+      def lib_http_api_endpoints(vars = {})
+        content = compile(Templates[:lib_http_api_endpoints], vars)
+        write(content, "#{app_dir}/lib/http_api/endpoints.rb")
+      end
+    end
+  end
+end

data/generators/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'fileutils'
+
+module Overture
+  module Generators
+    class Base
+      def initialize(config = {})
+        @config = config
+      end
+
+      def compile(template, vars = {})
+        ERB.new(template).result_with_hash(vars)
+      end
+
+      # TODO: check existence and ask for overwrite
+      def write(content, filepath)
+        location = File.expand_path(filepath)
+        dirname = File.dirname(location)
+
+        mkdir(dirname)
+
+        File.open(location, 'w') do |f|
+          f.puts content
+        end
+
+        puts "  created file: #{filepath}"
+        filepath
+      end
+
+      def mkdir(path)
+        FileUtils.mkdir_p(path) unless File.directory?(path)
+      end
+
+      def touch(filepath)
+        write('', filepath)
+      end
+
+      def chmod(mod, location)
+        FileUtils.chmod(mod, File.expand_path(location))
+      end
+
+      def shell(command)
+        command = command.join(' && ') if command.is_a?(Array)
+        puts "  running: #{command}"
+        `#{command}`
+      end
+
+      protected
+
+      attr_reader :config
+    end
+  end
+end

data/generators/migration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'templates'
+
+module Overture
+  module Generators
+    class Migration < Base
+      def call(vars = {})
+        name = vars[:name].tr(' ', '_').downcase
+        timestamp = Time.now.strftime('%Y%m%d%H%M%S')
+        location = File.join('migrations', "#{timestamp}_#{name}.rb")
+        content = compile(Templates[:migration], vars)
+
+        write(content, location)
+      end
+    end
+  end
+end

data/generators/templates.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Templates
+  module_function
+
+  def [](name)
+    path = File.expand_path("templates/#{name}.erb", __dir__)
+    File.read(path)
+  end
+end

data/generators/templates/bin_console.erb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+puts 'Loading environment...'
+require_relative '../config/environment'
+
+require 'irb'
+IRB.start

data/generators/templates/bin_dev_http_api.erb

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+bundle exec rerun -- puma -C config/puma.rb

data/generators/templates/config_environment.erb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+ENV['RACK_ENV'] ||= 'development'
+ENV['APP_ENV'] = ENV['RACK_ENV']
+
+require 'bundler'
+Bundler.require(:default, ENV['RACK_ENV'])
+
+## Uncomment the modules you want to use:
+#require 'overture/database'
+#require 'overture/model'
+#require 'overture/interactor'
+#require 'overture/password_digester'
+
+# `./lib` is added to the `$LOAD_PATH` so given a file in `lib/modesl/user.rb` you can do:
+# require 'models/user'
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+## Uncomment if you're using the Database module:
+#DB = Overture::Database.connect(ENV.fetch('DATABASE_URL'))
+
+## This is to stream one row at time instead of all rows
+## https://github.com/jeremyevans/sequel_pg#streaming
+#if Sequel::Postgres.supports_streaming?
+#  DB.extension(:pg_streaming)
+#  DB.stream_all_queries = true
+#end
+
+Dir.glob('{models,interactors}/**/*.rb', base: 'lib').each { |file| require file }

data/generators/templates/config_puma.erb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'dotenv/load'
+
+workers Integer(ENV['WEB_CONCURRENCY'] || 1)
+threads_count = Integer(ENV['APP_MAX_THREADS'] || 1)
+threads threads_count, threads_count
+worker_timeout 20
+
+port ENV['PORT'] || 3001
+environment ENV['RACK_ENV'] || 'development'

data/generators/templates/config_ru.erb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'config/environment'
+require 'http_api/endpoints'
+
+run HttpApi::Endpoints

data/generators/templates/gemfile.erb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gem 'concurrent-ruby', '1.0.5'
+gem 'overture', '~> 0.2'
+gem 'puma', '~> 3.12'
+gem 'rake', '~> 12.3'
+gem 'yajl-ruby', '~> 1.4', require: 'yajl/json_gem'
+
+group :development do
+  gem 'rerun', '~> 0.13'
+  gem 'rubocop', '~> 0.70'
+end
+
+group :test do
+  gem 'database_cleaner', '~> 1.7'
+  gem 'minitest', '~> 5.11', require: 'minitest/autorun'
+  gem 'minitest-reporters', '~> 1.3'
+  gem 'rack-test', '~> 1.1', require: 'rack/test'
+end
+
+group :development, :test do
+  gem 'pry-byebug', '~> 3.7'
+end

data/generators/templates/lib_http_api_endpoints.erb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'server'
+
+module HttpApi
+  # You can define all your endpoints in this class
+  # or you can mount other Sinatra apps:
+  #
+  #   class Admin < Server
+  #     get '/admin/users' do
+  #       # ...
+  #     end
+  #   end
+  #
+  #   class Endpoints < Server
+  #     use Admin
+  #   end
+  class Endpoints < Server
+    get '/' do
+      data = { hello: 'world' }
+      json data
+    end
+  end
+end

data/generators/templates/lib_http_api_server.erb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'overture/http_api/server'
+
+module HttpApi
+  class Server < Overture::HttpApi::Server
+    # You can handle how errors are reported here.
+    # For example with Bugsnag or other.
+    def notify_error(error)
+      puts "[HttpApi::Server Error] #{error.inspect}"
+    end
+
+    configure do
+      ## Uncomment to add authorization middleware to
+      ## certain endpoints:
+      ##
+      ##   get '/admin/zone', auth: [:admin] do
+      ##     # ...
+      ##   end
+      #set :auth do |*roles|
+      #  condition do
+      #    halt_unauthorized! unless current_user && roles.any? do |role|
+      #      current_user.role?(role)
+      #    end
+      #  end
+      #end
+
+      ## Add rack-cors to your Gemfile and uncomment below to configure
+      #use Rack::Cors do
+      #  allow do
+      #    origins ENV['CORS_ALLOW_ORIGINS'].split(/, ?/)
+      #    resource '*',
+      #      methods: :any,
+      #      headers: :any,
+      #      credentials: false
+      #  end
+      #end
+    end
+
+    configure :production, :staging do
+      ## add rack-ssl to your Gemfile and uncomment
+      ## this line to force HTTPS on production
+      ## and staging environments
+      #use Rack::SSL
+    end
+  end
+end

data/generators/templates/migration.erb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  table_name = :<%= name %>
+
+  up do
+    create_table(table_name) do
+      primary_key :id
+      DateTime :created_at, null: false
+      DateTime :updated_at, null: false
+    end
+  end
+
+  down do
+    drop_table(table_name)
+  end
+end

data/generators/templates/procfile.erb

@@ -0,0 +1,3 @@
+web: bundle exec puma -C config/puma.rb
+console: bin/console
+release: bundle exec rake db:migrate

data/generators/templates/rakefile.erb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'rake/testtask'
+require 'dotenv/load'
+
+## Uncomment to load database tasks (i.e. rake db:migrate)
+#overture_spec = Gem::Specification.find_by_name 'overture'
+#load "#{overture_spec.gem_dir}/lib/tasks/db.rake"
+
+Rake::TestTask.new(test: 'db:test:reset') do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.warning = false
+end
+
+desc 'Run tests'
+task default: :test

data/lib/overture/database.rb

@@ -7,6 +7,8 @@ Sequel.application_timezone = :local
 Sequel.extension :datetime_parse_to_time
 
 module Overture
+  # This is a simple class that represents a Database connection
+  # using Sequel.
   module Database
     DEFAULT_OPTIONS = {
       extensions: %i[
@@ -19,6 +21,7 @@ module Overture
 
     module_function
 
+    # Connects Sequel to database with the passed URL and options.
     def connect(url, options = {})
       Sequel.connect(url, DEFAULT_OPTIONS.merge(options))
     end

data/lib/overture/http_api/helpers.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Overture
+  module HttpApi
+    module Helpers
+      def json(data, serializer: nil, options: {})
+        data = data.all if data.respond_to?(:all)
+        return JSON.generate(data, options) unless serializer
+
+        serializer.new(data, options).serialized_json
+      end
+
+      def halt_not_found!
+        halt_error!(404, 'Not Found')
+      end
+
+      def halt_unauthorized!
+        halt_error!(401, 'Unauthorized')
+      end
+
+      def halt_not_acceptable!
+        halt_error!(406, 'Not Acceptable')
+      end
+
+      def halt_unsupported_media_type!
+        halt_error!(415, 'Unsupported Media Type')
+      end
+
+      def halt_unprocessable!(error)
+        halt_error!(422, error)
+      end
+
+      def halt_server_error!(error = 'Server Error')
+        halt_error!(500, error)
+      end
+
+      def halt_error!(status, title)
+        halt status, json(
+          errors: [{
+            status: status.to_s,
+            title: title
+          }]
+        )
+      end
+
+      def require_params!(*names)
+        names.each do |name|
+          halt_unprocessable!("#{name} is required") unless params.key?(name)
+        end
+      end
+
+      def found!(object)
+        object.nil? ? halt_not_found! : object
+      end
+    end
+  end
+end

data/lib/overture/http_api/serializer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'fast_jsonapi'
+
+module Overture
+  module HttpApi
+    class Serializer
+      include FastJsonapi::ObjectSerializer
+
+      set_id :id
+    end
+  end
+end

data/lib/overture/http_api/server.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require 'rack/parser'
+require_relative 'helpers'
+
+module Overture
+  module HttpApi
+    class Server < Sinatra::Base
+      helpers Helpers
+
+      MIME_TYPE = 'application/vnd.api+json'
+
+      def notify_error(error)
+        puts "[ERROR] #{error.inspect}"
+      end
+
+      configure do
+        enable :logging
+        enable :protection
+        disable :raise_errors
+        set :dump_errors, settings.development?
+        disable :show_exceptions
+
+        use Rack::Parser
+      end
+
+      before do
+        content_type MIME_TYPE
+
+        non_charset = request.media_type_params.keys.any? { |k| k != 'charset' }
+        halt_unsupported_media_type! if request.media_type != MIME_TYPE || non_charset
+        halt_not_acceptable! unless request.preferred_type.entry == MIME_TYPE || request.options?
+      end
+
+      not_found do
+        halt_not_found!
+      end
+
+      error do
+        exception = env['sinatra.error']
+
+        notify_error(exception)
+
+        halt_server_error!(exception.message)
+      end
+    end
+  end
+end

data/lib/overture/interactor.rb

@@ -4,10 +4,26 @@ require 'interactor'
 require_relative 'interactor/failure'
 
 module Overture
+  # This is a subclass of [`::Interactor`](https://github.com/collectiveidea/interactor)
+  # with some methods added for comodity.
   class Interactor
     include ::Interactor
 
     class << self
+      # Mark context keys as required.
+      #
+      # If any of the specified keys are sent as `nil`, it will
+      # fail with a message like `'<key> is required'`.
+      #
+      # Possible options are:
+      #
+      # - `allow_empty` Allows empty values such as `[]`, `''`
+      #
+      # Example:
+      #
+      # class MyInteractor < Overture::Interactor
+      #   required :first_name, :last_name, allow_empty: true
+      # end
       def required(*input)
         before do
           opts = input.last.is_a?(Hash) ? input.pop : {}
@@ -24,9 +40,35 @@ module Overture
       end
     end
 
+    # Fails context and sets `context.error` attribute to the passed message.
+    #
+    # An optional hash can be passed that will get merged when failing.
     def fail!(message, meta = {})
       context.fail!(meta.merge(error: message))
     end
+
+    # Checks for presence and non-emptiness
+    def blank?(value)
+      return true if value.nil?
+
+      value = value.strip if value.respond_to?(:strip)
+      value.empty?
+    end
+
+    # Slice the passed keys from context if they're present.
+    #
+    # When `include_nils` is false, `nil` values are ignored.
+    def context_slice(*keys, include_nils: false)
+      keys.each_with_object({}) do |key, memo|
+        next unless context_key?(key)
+
+        memo[key] = context[key] if !context[key].nil? || include_nils
+      end
+    end
+
+    def context_key?(key)
+      context.to_h.key?(key.to_sym)
+    end
   end
 end
 

data/lib/overture/serializer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Overture
+  class Serializer
+  end
+end

data/lib/overture/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Overture
-  VERSION = '0.1.6'
+  VERSION = '0.2.0'
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: overture
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Edgar JS
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-09 00:00:00.000000000 Z
+date: 2019-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcrypt
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: fast_jsonapi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: interactor
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rack-parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: sequel_pg
   requirement: !ruby/object:Gem::Requirement
@@ -67,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: tzinfo
+  name: sinatra
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -81,19 +109,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: tzinfo-data
+  name: tzinfo
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2018'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2018'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -149,18 +177,37 @@ description: |
   is used for the business rules.
 email: edgar.js@gmail.com
 executables:
-- overture-migration
+- overture
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- bin/overture-migration
+- bin/overture
+- generators/app.rb
+- generators/base.rb
+- generators/migration.rb
+- generators/templates.rb
+- generators/templates/bin_console.erb
+- generators/templates/bin_dev_http_api.erb
+- generators/templates/config_environment.erb
+- generators/templates/config_puma.erb
+- generators/templates/config_ru.erb
+- generators/templates/gemfile.erb
+- generators/templates/lib_http_api_endpoints.erb
+- generators/templates/lib_http_api_server.erb
+- generators/templates/migration.erb
+- generators/templates/procfile.erb
+- generators/templates/rakefile.erb
 - lib/overture.rb
 - lib/overture/database.rb
+- lib/overture/http_api/helpers.rb
+- lib/overture/http_api/serializer.rb
+- lib/overture/http_api/server.rb
 - lib/overture/interactor.rb
 - lib/overture/interactor/failure.rb
 - lib/overture/model.rb
 - lib/overture/password_digester.rb
+- lib/overture/serializer.rb
 - lib/overture/version.rb
 - lib/tasks/db.rake
 homepage: https://github.com/edgarjs/overture
@@ -182,8 +229,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Tools and configurations for your web app.

data/bin/overture-migration

@@ -1,65 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'optparse'
-require 'fileutils'
-
-class Parser
-  def self.parse(options = {})
-    opt_parser = OptionParser.new do |opts|
-      opts.banner = 'Usage: overture-migration [options]'
-
-      opts.on '-nNAME', '--name=NAME', 'Migration name' do |n|
-        options[:name] = n
-      end
-
-      opts.on '-h', '--help', 'Prints this message' do
-        puts opts
-        exit
-      end
-    end
-
-    opt_parser.parse!(options)
-    options
-  end
-end
-
-options = Parser.parse
-
-if options[:name].nil?
-  Parser.parse(['--help'])
-  exit
-end
-
-def generate_migration(name)
-  timestamp = Time.now.strftime('%Y%m%d%H%M%S')
-  filename = "migrations/#{timestamp}_#{name.tr(' ', '_').downcase}.rb"
-
-  FileUtils.mkdir_p('migrations')
-  File.open(filename, 'w') do |f|
-    f.puts <<~TEMPLATE
-      # frozen_string_literal: true
-
-      Sequel.migration do
-        table_name = :table_name # change this
-
-        up do
-          create_table(table_name) do
-            primary_key :id
-            DateTime :created_at, null: false
-            DateTime :updated_at, null: false
-          end
-        end
-
-        down do
-          drop_table(table_name)
-        end
-      end
-
-    TEMPLATE
-  end
-  puts "-----------> Created db migration: #{filename}"
-end
-
-generate_migration(options[:name])
-