app_rail-airtable 0.1.0 → 0.5.0

data/lib/app_rail/airtable/application_record.rb

@@ -1,49 +1,67 @@
+# frozen_string_literal: true
+
 require 'airrecord'
+require 'app_rail/steps'
+require 'active_support/core_ext/string/inflections'
 
 module AppRail
   module Airtable
     class ApplicationRecord < Airrecord::Table
-    
-      def self.ar_list_item(text:, detail_text:, image: nil, sf_symbol: nil, material_icon: nil)
+      include ActiveSupport::Inflector
+      include AppRail::Steps::Displayable
+
+      def self.base_key
+        ENV.fetch('AIRTABLE_BASE_ID')
+      end
+
+      def self.table_name
+        name.pluralize
+      end
+
+      def self.airtable_attr(*attributes)
+        attributes.each do |attribute|
+          define_method(attribute.to_s.snake_case) { self[attribute] }
+          define_method("#{attribute.to_s.snake_case}=") { |value| self[attribute] = value }
+        end
+      end
+
+      # Step utilities
+      def self.ar_list_item(text:, detail_text: nil, image: nil, sf_symbol: nil, material_icon: nil)
         define_method(:ar_list_item_as_json) do
           {
-            id: self.id, 
-            text: method_value_or_property(text).to_s, 
-            detailText: method_value_or_property(detail_text).to_s, 
-            imageURL: method_value_or_property(image), 
-            sfSymbolName: sf_symbol, 
-            materialIconName: material_icon
+            id: id,
+            text: method_value(text).to_s,
+            detailText: method_value(detail_text).to_s,
+            imageURL: method_value(image),
+            sfSymbolName: method_value(sf_symbol),
+            materialIconName: method_value(material_icon)
           }.compact
         end
       end
-      
+
       def self.ar_stack(text_items:)
         define_method(:ar_stack_as_json) do
-          text_items.map{|ti| {type: :text, label: ti, text: self[ti].to_s} }
+          text_items.map { |ti| { type: :text, label: ti, text: self[ti].to_s } }
         end
       end
-      
+
       # Customisable behaviour
-      
+
       # Override to provide custom sorting or filtering for index
-      def self.index
+      def self.index(user:)
         all
       end
-      
+
       private
-      
-      # TODO: Method call not working?
-      def method_value_or_property(name)
-        return nil unless name
-        
-        respond_to?(name) ? send(name) : self[name]
-      end
-      
+
+      def method_value(name)
+        send(name) if name.present?
+      end
+
       # size is either :small, :large or :full
       def image(name, index: 0, size: :full)
-        self[name][index]["thumbnails"][size.to_s]["url"]
+        self[name][index]['thumbnails'][size.to_s]['url'] if self[name] && self[name].length > index
       end
-      
     end
   end
-end
+end

data/lib/app_rail/airtable/authenticatable.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'bcrypt'
+require 'securerandom'
+
+module AppRail
+  module Airtable
+    module Authenticatable
+      class AlreadyExistsError < StandardError; end
+
+      include BCrypt
+
+      def self.included(klass)
+        klass.extend(ClassMethods)
+        klass.prepend(InstanceMethods)
+      end
+
+      module ClassMethods
+        def create(email:, password:)
+          raise AlreadyExistsError if find_by_email(email)
+
+          user = new('Email' => email, 'Password Hash' => password_hash(password), 'Access Token' => next_access_token)
+          user.create
+          user
+        end
+
+        def find_by_email_and_password(email, password)
+          user = find_by_email(email)
+          user&.valid_password?(password) ? user : nil
+        end
+
+        def find_by_email(email)
+          all(filter: "{Email} = \"#{email}\"").first
+        end
+
+        def find_by_access_token(access_token)
+          all(filter: "{Access Token} = \"#{access_token}\"").first
+        end
+
+        def password_hash(password)
+          BCrypt::Password.create(password)
+        end
+
+        def next_access_token
+          SecureRandom.hex
+        end
+      end
+
+      module InstanceMethods
+        def valid_password?(password)
+          BCrypt::Password.new(password_hash) == password
+        end
+
+        def password_hash
+          self['Password Hash']
+        end
+
+        def oauth_session
+          ensure_access_token!
+
+          {
+            access_token: self['Access Token'],
+            scope: :user,
+            token_type: :bearer,
+            expires_in: 31_536_000 # 1 year
+          }
+        end
+
+        def ensure_access_token!
+          unless self['Access Token']
+            self['Access Token'] = User.next_access_token
+            save
+          end
+        end
+      end
+    end
+  end
+end

data/lib/app_rail/airtable/authentication_helpers.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module AppRail
+  module Airtable
+    module AuthenticationHelpers
+      def current_user
+        @current_user ||= find_current_user
+      end
+
+      def find_current_user
+        authorization_header && bearer_token ? find_authenticatable_resource(access_token: bearer_token) : nil
+      end
+
+      def bearer_token
+        authorization_values = authorization_header.split(' ')
+        return nil unless authorization_values.count > 1
+
+        authorization_values[1]
+      end
+
+      def authorization_header
+        request.env['HTTP_AUTHORIZATION']
+      end
+
+      def oauth_client_id
+        ENV.fetch('OAUTH_CLIENT_ID')
+      end
+
+      def oauth_client_secret
+        ENV.fetch('OAUTH_CLIENT_SECRET')
+      end
+
+      def authenticate!
+        halt 401 unless current_user
+      end
+    end
+  end
+end

data/lib/app_rail/airtable/generator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'app_rail/airtable/string_ext'
+require 'thor'
+require 'airrecord'
+
+module AppRail
+  module Airtable
+    class Generator < Thor::Group
+      include Thor::Actions
+
+      argument :output_directory
+      argument :api_key
+      argument :base_id
+      argument :schema, required: false
+
+      def self.source_root
+        File.join(File.dirname(__FILE__), '..', '..', '..')
+      end
+
+      def create_project
+        validate_airtable_schema
+        directory('templates/project', output_directory)
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+
+      private
+
+      def validate_airtable_schema
+        tables.each do |table|
+          table_name = table['name']
+          table_fields = table['fields'].concat(table['associations']).map { |field| field['name'] }.compact
+
+          airtable_table = find_table(table_name)
+          compare_fields(table_fields, airtable_table)
+        end
+      end
+
+      def tables
+        @tables ||= schema ? JSON.parse(schema)['tables'] : []
+      end
+
+      def find_table(table_name)
+        Airrecord.table(api_key, base_id, table_name)
+      end
+
+      def compare_fields(table_fields, airtable_table)
+        airtable_table.records.first.fields.each_key do |key|
+          next if table_fields.include? key
+
+          raise "ERROR! The key \"#{key}\" is not present in the schema definition."
+        end
+      end
+
+      def fields_as_params_examples(fields)
+        fields.each_with_object({}) do |field, hsh|
+          hsh[field['name']] = case field['type']
+                               when 'date'
+                                 '01/01/2022'
+                               when 'string', 'text'
+                                 'MyString'
+                               when 'integer'
+                                 10
+                               else
+                                 'MyString'
+                               end
+        end
+      end
+    end
+  end
+end

data/lib/app_rail/airtable/sinatra.rb

@@ -1,46 +1,134 @@
+# frozen_string_literal: true
+
 require 'sinatra'
 require 'json'
 require 'active_support'
 
-Airrecord.api_key = ENV.fetch("AIRTABLE_API_KEY")
+# TODO: MBS - move to configure block or other
+Airrecord.api_key = ENV.fetch('AIRTABLE_API_KEY')
 
 class Symbol
-  
   def pluralize
     ActiveSupport::Inflector.pluralize(self)
   end
-  
+
+  def singularize
+    ActiveSupport::Inflector.singularize(self)
+  end
+
   def classify
-    ActiveSupport::Inflector.classify(self)  
+    ActiveSupport::Inflector.classify(self)
   end
-  
+
   def classify_constantize
     ActiveSupport::Inflector.constantize(classify)
   end
-  
 end
 
 module AppRail
   module Airtable
     class Sinatra < Sinatra::Base
+      @@authenticated_route = false
+
+      helpers do
+        def request_body_as_json
+          request.body.rewind
+          JSON.parse(request.body.read)
+        end
+
+        def params_and_body_as_json
+          request_body_as_json.merge(params)
+        end
+      end
+
+      def self.authenticatable_resources(name, only: %i[index show create update])
+        # If authentication is used then include the correct helpers
+        # Allowing the routes to use `authenticate!` and `current_user`
+        helpers AppRail::Airtable::AuthenticationHelpers
+
+        sign_in_route(name)
+        sign_out_route(name)
+        resources(name, only: only)
+
+        return unless block_given?
+
+        @@authenticated_route = true
+        yield
+        @@authenticated_route = false
+      end
+
+      def self.resources(name, only: %i[index show create update])
+        only = [only] if only.is_a?(Symbol)
+
+        index_route(name, authenticated_route?) if only.include?(:index)
+        show_route(name, authenticated_route?) if only.include?(:show)
+        create_route(name, authenticated_route?) if only.include?(:create)
+        update_route(name, authenticated_route?) if only.include?(:update)
+      end
 
-      def self.resource(name)
-        get "/#{name.to_s}" do
-          name.classify_constantize.index.map(&:ar_list_item_as_json).to_json
+      def self.sign_in_route(name)
+        post "/#{name}/session" do
+          halt [401, { error: 'Invalid client_id' }.to_json] unless params['client_id'] == oauth_client_id
+          halt [401, { error: 'Invalid client_secret' }.to_json] unless params['client_secret'] == oauth_client_secret
+
+          resource = name.classify_constantize.authenticate_by_params(params)
+          halt [401, { error: 'Invalid credentials' }.to_json] unless resource
+
+          resource.oauth_session.to_json
+        end
+      end
+
+      def self.sign_out_route(name)
+        delete "/#{name}/session" do
+          authenticate!
+          current_user.access_token = nil
+          current_user.save
+
+          # Assume that the client will reload and trigger a 401
+          [].to_json
+        end
+      end
+
+      def self.index_route(name, authenticated_route)
+        get "/#{name}" do
+          authenticate! if authenticated_route
+          name.classify_constantize.index(user: authenticated_route ? current_user : nil).map(&:ar_list_item_as_json).to_json
         end
-        
-        get "/#{name.to_s}/:id" do
+      end
+
+      def self.show_route(name, authenticated_route)
+        get "/#{name}/:id" do
+          authenticate! if authenticated_route
           name.classify_constantize.find(params['id']).ar_stack_as_json.to_json
         end
-        
-        post "/#{name.to_s}" do
-          request.body.rewind # in case someone already read it
-          data = JSON.parse(request.body.read)
-          new_record = name.classify_constantize.create_from_params(data.merge(params)) 
-          [201, {id: new_record.id}.to_json] 
+      end
+
+      def self.create_route(name, authenticated_route)
+        post "/#{name}" do
+          authenticate! if authenticated_route
+          begin
+            as_json = name.classify_constantize.create_as_json(current_user: authenticated_route ? current_user : nil,
+                                                               params: params_and_body_as_json)
+            [201, as_json.to_json]
+          rescue AppRail::Airtable::Authenticatable::AlreadyExistsError
+            [422, { error: "#{name.singularize} already exists" }.to_json]
+          end
         end
       end
 
+      def self.update_route(name, authenticated_route)
+        put "/#{name}/:id" do
+          authenticate! if authenticated_route
+          record = name.classify_constantize.find(params['id'])
+          as_json = record.update_as_json(current_user: authenticated_route ? current_user : nil,
+                                          params: params_and_body_as_json)
+          [200, as_json.to_json]
+        end
+      end
+
+      def self.authenticated_route?
+        @@authenticated_route
+      end
     end
   end
-end
+end

data/lib/app_rail/airtable/string_ext.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class String
+  def snake_case
+    gsub(' ', '_').underscore
+  end
+end

data/lib/app_rail/airtable/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module AppRail
   module Airtable
-    VERSION = "0.1.0"
+    VERSION = '0.5.0'
   end
 end

data/lib/app_rail/airtable.rb

@@ -1,6 +1,12 @@
-require "app_rail/airtable/version"
-require "app_rail/airtable/application_record"
-require "app_rail/airtable/sinatra"
+# frozen_string_literal: true
+
+require 'app_rail/airtable/version'
+require 'app_rail/airtable/string_ext'
+require 'app_rail/airtable/application_record'
+require 'app_rail/airtable/authenticatable'
+require 'app_rail/airtable/authentication_helpers'
+require 'app_rail/airtable/sinatra'
+require 'app_rail/airtable/generator'
 
 module AppRail
   module Airtable

data/templates/project/.env.tt

@@ -0,0 +1,2 @@
+AIRTABLE_API_KEY=<%= api_key %>
+AIRTABLE_BASE_ID=<%= base_id %>

data/templates/project/.gitignore

@@ -0,0 +1,19 @@
+.DS_STORE
+*.swp
+*.rbc
+*.sass-cache
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.byebug_history
+
+# dotenv
+.env

data/templates/project/Gemfile

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+ruby '3.1.2'
+
+gem 'app_rail-airtable'
+gem 'app_rail-steps'
+gem 'puma'
+gem 'sinatra', '~> 3.0', '>= 3.0.2'
+
+group :development do
+  gem 'dotenv'
+end
+
+group :test do
+  gem 'rack-test'
+  gem 'rspec'
+end
+
+group :development, :test do
+  gem 'byebug'
+end

data/templates/project/app.json

@@ -0,0 +1,17 @@
+{
+  "name": "App Rail Airtable Service",
+  "description": "A barebones template to convert Airtable data to App Rail format",
+  "buildpacks": [
+    {
+      "url": "heroku/ruby"
+    }
+  ],
+  "env": {
+    "AIRTABLE_API_KEY": {
+      "description": "Your Airtable API key."
+    },
+    "AIRTABLE_BASE_ID": {
+      "description": "The ID of the Base you'd like to connect to."
+    }
+  }
+}

data/templates/project/boot.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+ENV['RACK_ENV'] ||= 'development'
+
+require 'dotenv/load' if ENV['RACK_ENV'] == 'development'
+
+require 'bundler'
+Bundler.require(:default, ENV['RACK_ENV'].to_sym)

data/templates/project/config.ru

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$stdout.sync = true
+require './boot'
+require './lib/server'
+run Server

data/templates/project/lib/server.rb.tt

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'app_rail/airtable'
+require 'active_support/inflector'
+
+<% @tables.each do |table| -%>
+<% keys = table['fields'].map { |field| field['name'] if field['type'] != 'association' }.compact -%>
+class <%= table['name'].singularize %> < AppRail::Airtable::ApplicationRecord  
+<% if table['authenticatable'] == 'True' -%>
+  include AppRail::Airtable::Authenticatable
+
+<% end -%>
+  airtable_attr <%= keys.map{|f| "\"#{f}\""}.join(", ") %>
+<% table['ar_class_methods']&.each do |method| -%>
+  <%= method['name'] %> <%= method['properties'].map {|prop| "#{prop['type']}: :#{prop['value']}" }.join(', ') %>
+<% end -%>
+
+<% table['associations']&.each do |association| -%>
+<% word_ending_method = association['type'] == 'has_many' ? :pluralize : :singularize -%>
+  <%= association['type'] %> <%= ":#{association['model'].snake_case.send(word_ending_method)}, class: \"#{association['model'].camelize.singularize}\", column: \"#{association['model'].camelize.send(word_ending_method)}\"" %>
+<% end -%>
+<% if table['authenticatable'] == 'True' -%>
+
+  def self.create_as_json(params:, current_user:)
+    record = <%= table['name'].singularize %>.create(email: params["payload"]["email"], password: params["payload"]["password"])
+    { response: { id: record.id }, oauth_session: record.oauth_session}
+  end
+
+  def update_as_json(params:, current_user:)
+    params['payload'].each { |attr, v| public_send("#{attr}=", v) }
+    save
+    { response: { id: id }, oauth_session: oauth_session }
+  end
+<% end -%>
+end
+
+<% end -%>
+
+<% authenticatable_table = @tables.select { |table| table['authenticatable'] == 'True' }&.first -%>
+<% authenticatable_resource = authenticatable_table['name'] if authenticatable_table -%>
+class Server < AppRail::Airtable::Sinatra
+<% if authenticatable_resource -%>
+<% model_name = authenticatable_resource.singularize -%>
+  helpers do
+    def find_authenticatable_resource(access_token:)
+      <%= model_name %>.find_by_access_token(access_token)
+    end
+  end
+
+  authenticatable_resources :<%= authenticatable_resource.snake_case %> do
+<% @tables.each do |table| -%>
+<% next if table['name'] == authenticatable_resource -%>
+    resources :<%= table['name'].snake_case %>
+<% end -%>
+  end
+
+  post "/sessions" do
+    oauth_session = <%= model_name %>.create_session_as_json(email: params["username"], password: params["password"])
+    halt 401 unless oauth_session
+
+    oauth_session.to_json
+  end
+<% else -%>
+<% @tables.each do |table| -%>
+  resources :<%= table['name'].snake_case %>
+<% end -%>
+<% end -%>
+end