alpha_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a7ebf33759d9ccdcffa80c9fcb6692936b0b2f0cd9231b6b2cc0a7b93d0db04
+  data.tar.gz: 5e4265a8e6d4d18037b4a73bd4820760de8af5b4a6d2cdebb204cf209587aaff
+SHA512:
+  metadata.gz: ed39edc56bf7dfe36028147842a4b35e96993fbb68055a839f5718978be44140e16b8bd9b58debe4be4278d52061e26c5a1445498b6fa93999d1350ad35b4077
+  data.tar.gz: ba00720279c4317cb6eb3c0a8b49dddbe52750a84bf5304ab3ad9de9c17f48d144099727c969f03a1c94f45afde3491f35e78d27a33bb51e5a5cfeedc96f8ab8

data/.github/workflows/main.yml

@@ -0,0 +1,18 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 2.5.8
+    - name: Run the default task
+      run: |
+        gem install bundler -v 2.2.3
+        bundle install
+        bundle exec rake

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,10 @@
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in alpha_api.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rubocop", "~> 0.80"
+
+gem "fast_jsonapi"
+
+# For actual pagination
+gem 'kaminari'
+# For rest pagination, using kaminari automatically
+gem 'api-pagination'

data/Gemfile.lock

@@ -0,0 +1,100 @@
+PATH
+  remote: .
+  specs:
+    alpha_api (0.1.0)
+      activesupport
+      api-pagination
+      fast_jsonapi
+      kaminari
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionview (6.1.4.1)
+      activesupport (= 6.1.4.1)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activemodel (6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activerecord (6.1.4.1)
+      activemodel (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activesupport (6.1.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    api-pagination (4.8.2)
+    ast (2.4.2)
+    builder (3.2.4)
+    concurrent-ruby (1.1.9)
+    crass (1.0.6)
+    erubi (1.10.0)
+    fast_jsonapi (1.5)
+      activesupport (>= 4.2)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    kaminari (1.2.1)
+      activesupport (>= 4.1.0)
+      kaminari-actionview (= 1.2.1)
+      kaminari-activerecord (= 1.2.1)
+      kaminari-core (= 1.2.1)
+    kaminari-actionview (1.2.1)
+      actionview
+      kaminari-core (= 1.2.1)
+    kaminari-activerecord (1.2.1)
+      activerecord
+      kaminari-core (= 1.2.1)
+    kaminari-core (1.2.1)
+    loofah (2.12.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    minitest (5.14.4)
+    nokogiri (1.12.4-x86_64-darwin)
+      racc (~> 1.4)
+    parallel (1.20.1)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    racc (1.5.2)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.2)
+      loofah (~> 2.3)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    rubocop (0.93.1)
+      parallel (~> 1.10)
+      parser (>= 2.7.1.5)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8)
+      rexml
+      rubocop-ast (>= 0.6.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (1.11.0)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (1.7.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  x86_64-darwin-19
+
+DEPENDENCIES
+  alpha_api!
+  api-pagination
+  fast_jsonapi
+  kaminari
+  rake (~> 13.0)
+  rubocop (~> 0.80)
+
+BUNDLED WITH
+   2.2.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Alba Hoo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# AlphaApi
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/alpha_api`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'alpha_api'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install alpha_api
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/alpha_api.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/alpha_api.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/alpha_api/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "alpha_api"
+  spec.version       = AlphaApi::VERSION
+  spec.authors       = ["Alba Hoo"]
+  spec.email         = ["alba@tenty.co"]
+
+  spec.summary       = "RESTfulise model with jsonapi"
+  spec.description   = "Expose models with restful api"
+  spec.homepage      = "https://github.com/AlbaHoo/AlphaApi"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/AlbaHoo/AlphaApi"
+  spec.metadata["changelog_uri"] = "https://github.com/AlbaHoo/AlphaApi"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'fast_jsonapi'
+  spec.add_dependency 'kaminari'
+  spec.add_dependency 'api-pagination'
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "alpha_api"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/alpha_api/application.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require "alpha_api/application_settings"
+require "alpha_api/namespace_settings"
+require 'api-pagination'
+
+module AlphaApi
+  class Application
+
+    class << self
+      def setting(name, default)
+        ApplicationSettings.register name, default
+      end
+
+      def inheritable_setting(name, default)
+        NamespaceSettings.register name, default
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      [settings, namespace_settings].any? { |sets| sets.respond_to?(method) } || super
+    end
+
+    def method_missing(method, *args)
+      if settings.respond_to?(method)
+        settings.send(method, *args)
+      elsif namespace_settings.respond_to?(method)
+        namespace_settings.send(method, *args)
+      else
+        super
+      end
+    end
+
+    def settings
+      @settings ||= SettingsNode.build(ApplicationSettings)
+    end
+
+    def namespace_settings
+      @namespace_settings ||= SettingsNode.build(NamespaceSettings)
+    end
+
+    def initialize
+    end
+
+    # Runs before the app's initializer
+    def before_initializer!
+      puts 'before initializer'
+      ApiPagination.configure do |config|
+        config.page_param do |params|
+          if params[:page].is_a?(ActionController::Parameters) && params[:page].include?(:number)
+            params[:page][:number]
+          else
+            1
+          end
+        end
+
+        config.per_page_param do |params|
+          if params[:page].is_a?(ActionController::Parameters) && params[:page].include?(:size)
+            params[:page][:size]
+          else
+            10
+          end
+        end
+      end
+    end
+
+    # Runs after the app's initializer
+    def after_initializer!
+      puts 'after initializer'
+    end
+
+    private
+  end
+end
+

data/lib/alpha_api/application_settings.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require "alpha_api/settings_node"
+
+module AlphaApi
+  class ApplicationSettings < SettingsNode
+
+    register :app_path, Rails.root
+
+    register :api_prefix, 'api/v1'
+
+    # Load paths for admin configurations. Add folders to this load path
+    # to load up other resources for administration. External gems can
+    # include their paths in this load path to provide active_admin UIs
+    register :load_paths, []
+
+    # Set default localize format for Date/Time values
+    register :localize_format, :long
+
+    # Alpha Api makes educated guesses when displaying objects, this is
+    # the list of methods it tries calling in order
+    # Note that Formtastic also has 'collection_label_methods' similar to this
+    # used by auto generated dropdowns in filter or belongs_to field of Alpha Api
+    register :display_name_methods, [ :display_name,
+                                      :full_name,
+                                      :name,
+                                      :username,
+                                      :login,
+                                      :title,
+                                      :email,
+                                      :to_s ]
+
+    # Remove sensitive attributes from being displayed, made editable, or exported by default
+    register :filter_attributes, [:encrypted_password, :password, :password_confirmation]
+  end
+end

data/lib/alpha_api/concerns/actionable.rb

@@ -0,0 +1,363 @@
+require "active_support/concern"
+
+module AlphaApi
+  module Concerns
+    module Actionable
+      extend ActiveSupport::Concern
+
+      def create
+        authorize! :create, resource_class
+        new_resource = build_resource(permitted_create_params)
+        if new_resource.valid?
+          authorize! :create, new_resource
+          new_resource.save
+          render status: :created, json: resource_serializer.new(new_resource).serializable_hash
+        else
+          errors = reformat_validation_error(new_resource)
+          raise Exceptions::ValidationErrors.new(errors), 'Validation Errors'
+        end
+      end
+
+      def index
+        authorize! :read, resource_class
+        query = apply_filter_and_sort(collection)
+        apply_pagination
+        if params[:page].present?
+          records = paginate(query)
+          records = records.padding(params[:page][:offset]) if params[:page][:offset]
+        else
+          records = query
+        end
+
+        options = options(nested_resources, params[:page], query.count)
+        render json: resource_serializer.new(records, options).serializable_hash
+      end
+
+      def show
+        resource = resource_class.find(params[:id])
+        authorize! :read, resource
+        options = options(nested_resources)
+        render json: resource_serializer.new(resource, options).serializable_hash
+      end
+
+      def update
+        cached_resource_class = resource_class
+        resource = cached_resource_class.find(params[:id])
+        authorize! :update, resource
+        options = options(nested_resources)
+        if resource.update(permitted_update_params(resource))
+          updated_resource = cached_resource_class.find(params[:id])
+          render json: resource_serializer.new(updated_resource, options).serializable_hash
+        else
+          errors = reformat_validation_error(resource)
+          raise Exceptions::ValidationErrors.new(errors), 'Validation Errors'
+        end
+      end
+
+      def destroy
+        if destroyable
+          resource = resource_class.find(params[:id])
+          authorize! :destroy, resource
+          if resource.destroy
+            head :no_content
+          else
+            raise Exceptions::ValidationErrors.new(resource.errors), 'Validation Errors'
+          end
+        else
+          raise Exceptions::MethodNotAllowed, 'Method Not Allowed'
+        end
+      end
+
+      protected
+
+      def destroyable
+        false
+      end
+
+      def allowed_associations
+        []
+      end
+
+      def allowed_sortings
+        []
+      end
+
+      def apply_filter_and_sort(query)
+        query = apply_standard_filter(query) if fields_filter_required?
+        # custom filters
+        query = apply_filter(query) if params[:filter]
+        query = apply_sorting(query)
+      end
+
+      # @override customised filters
+      def apply_filter(query)
+        if filterable_fields.empty?
+          raise Exceptions::InvalidFilter, 'Filters are not supported for this resource type'
+        else
+          query
+        end
+      end
+
+      def filterable_fields
+        []
+      end
+
+      def fields_filter_required?
+        (params[:search_term] || params[:filter]) && filterable_fields.present?
+      end
+
+      # only override this method when filterable_fields is not empty
+      def apply_search_term(query, search_term)
+        # exclude all _id fields for OR query
+        conditions = filterable_fields.select { |field| field_type(field) == :string }.map do |field|
+          %("#{resource_class.table_name}"."#{field}" ILIKE #{sanitise(search_term)})
+        end
+        query = query.where(conditions.join(' OR '))
+      end
+
+      def apply_combined_filters(query)
+        conditions = []
+        filterable_fields.each do |field|
+          value = params.dig(:filter, field)
+          type = field_type(field)
+          next unless value.present? && type.present?
+          if type == :uuid || valid_enum?(field, value)
+            query = query.where(field => value)
+          elsif type == :string
+            query = query.where(%("#{resource_class.table_name}"."#{field}" ILIKE #{sanitise(value)}))
+          elsif valid_boolean?(field, value)
+            query = query.where(field => value == 'true')
+          else
+            raise Exceptions::InvalidFilter, 'Only type of string and uuid fields are supported'
+          end
+        end
+        query
+      end
+
+      def apply_standard_filter(query)
+        return query if filterable_fields.empty?
+        # generate where clauses of _contains
+        search_term = params[:search_term]
+        query = if search_term.present?
+                  apply_search_term(query, search_term)
+                else
+                  apply_combined_filters(query)
+                end
+      end
+
+      def apply_pagination
+        page_number = (params.dig(:page, :number) || 1).to_i
+        page_offset = (params.dig(:page, :offset) || 0).to_i
+        page_size = (params.dig(:page, :size) || 20).to_i
+
+        if allow_all && page_size == -1
+          params[:page] = nil
+        else
+          raise Exceptions::InvalidRequest, 'Page number must be positive' unless page_number.positive?
+          raise Exceptions::InvalidRequest, 'Page offset must be non-negative' if page_offset.negative?
+          raise Exceptions::InvalidRequest, 'Page size must be positive' unless page_size.positive?
+          raise Exceptions::InvalidRequest, 'Page size cannot be greater than 100' if page_size > 100
+
+          params[:page] = {
+            number: page_number,
+            offset: page_offset,
+            size: page_size
+          }
+        end
+      end
+
+      def allow_all
+        false
+      end
+
+      def apply_sorting(query)
+        sort_params = params['sort']
+        return query.order(default_sorting) unless sort_params.present?
+        raise Exceptions::InvalidRequest, 'Sort parameter must be a string' unless sort_params.is_a? String
+        sorting = []
+
+        sorts = sort_params.split(',').map(&:strip).map do |sort|
+          is_desc = sort.start_with?('-')
+          sort = is_desc ? sort[1..-1] : sort
+          raise Exceptions::InvalidRequest, "Sorting by #{sort} is not allowed" unless allowed_sortings.include?(sort.to_sym)
+          sort = association_mapper(sort)
+
+          # have to includes the association to be able to sort on
+          association = sort.split('.')[-2]
+          query = query.includes(association.to_sym) if association
+
+          sorting << sort_clause(sort, is_desc ? 'DESC NULLS LAST' : 'ASC NULLS FIRST')
+        end
+
+        query.order(sorting.join(','))
+      end
+
+      def association_mapper(sort)
+        components = sort.split('.')
+        return sort if components.length == 1
+        mapper = { 'reseller' => 'organisation' }
+        table_name = components[-2]
+        "#{mapper[table_name] || table_name}.#{components[-1]}"
+      end
+
+
+
+      def build_resource(resource_params)
+        resource_class.new(resource_params)
+      end
+
+      def collection
+        resource_class.accessible_by(current_ability)
+      end
+
+      def reconcile_nested_attributes(existing_items, items_in_update)
+        item_ids_in_update = items_in_update.map { |item| item['id'] }.compact
+        if item_ids_in_update.uniq.length != item_ids_in_update.length
+          raise(Exceptions::InvalidRequest, 'Nested attribute IDs must be unique')
+        end
+
+        nested_attributes = []
+
+        items_in_update.each do |item|
+          nested_attributes << reconcile_item(existing_items, item)
+        end
+
+        # Existing item was not found in updated items, so should be deleted
+        existing_items.reject { |existing| item_ids_in_update.include?(existing.id) }.each do |deleting_item|
+          nested_attributes << {
+            'id': deleting_item.id,
+            '_destroy': true
+          }
+        end
+
+        nested_attributes
+      end
+
+      def resource
+         resource_class.find(params[:id])
+      end
+
+      def default_sorting
+        { created_at: :desc }
+      end
+
+      def nested_resources
+        nested_resources = params[:include].to_s.split(',')
+        invalid_resources = []
+        nested_resources.each { |res| invalid_resources.push(res) unless allowed_associations.include?(res.to_sym) }
+        unless invalid_resources.empty?
+          raise Exceptions::InvalidArgument, "Invalid value for include: #{invalid_resources.join(', ')}"
+        end
+
+        nested_resources
+      end
+
+      def options(included, page = nil, count = nil)
+        options = {
+          include: included,
+          params: {
+            included: included
+          }
+        }
+        options[:meta] = {}
+        options[:meta][:total_count] = count if count
+        options[:meta][:page_number] = page[:number] if page
+        options[:meta][:page_size] = page[:size] if page
+        options
+      end
+
+      def permitted_create_params
+        data = params.require(:data)
+        data.require(:attributes) unless data.include?(:attributes)
+        data[:attributes]
+      end
+
+      def permitted_update_params(_resource)
+        data = params.require(:data)
+        data.require(:attributes) unless data.include?(:attributes)
+        data[:attributes]
+      end
+
+      def reconcile_item(existing_items, item)
+        item_id = item['id']
+        if item_id && !existing_items.find { |i| i.id == item_id }
+          # Any unreconciled items in the update need to be re-created
+          item.except(:id)
+        else
+          item
+        end
+      end
+
+      def reconcile_nested_attributes(existing_items, items_in_update)
+        item_ids_in_update = items_in_update.map { |item| item['id'] }.compact
+        if item_ids_in_update.uniq.length != item_ids_in_update.length
+          raise(Exceptions::InvalidRequest, 'Nested attribute IDs must be unique')
+        end
+
+        nested_attributes = []
+
+        items_in_update.each do |item|
+          nested_attributes << reconcile_item(existing_items, item)
+        end
+
+        # Existing item was not found in updated items, so should be deleted
+        existing_items.reject { |existing| item_ids_in_update.include?(existing.id) }.each do |deleting_item|
+          nested_attributes << {
+            'id': deleting_item.id,
+            '_destroy': true
+          }
+        end
+
+        nested_attributes
+      end
+
+      def reformat_validation_error(resource)
+        resource.errors
+      end
+
+      def resource_class
+        controller_name.classify.constantize
+      end
+
+      def resource_serializer
+        "Api::V1::#{controller_name.classify}Serializer".constantize
+      end
+
+      # e.g. sort: 'user.organisation', order: 'desc'
+      def sort_clause(sort, order)
+        components = sort.split('.')
+        attr_name = components[-1]
+        if components.length == 1
+          # direct attributes
+          "#{resource_class.table_name}.#{attr_name} #{order}"
+        elsif components.length == 2
+          # direct association attributes
+          association = resource_class.reflect_on_association(components[-2])
+          "#{association.table_name}.#{attr_name} #{order}"
+        else
+          # could potencially support that as well by includes deeply nested associations
+          raise Exceptions::InvalidRequest, 'Sorting on deeply nested association is not supported'
+        end
+      end
+
+      private
+
+      def field_type(field)
+        resource_class.attribute_types[field.to_s].type
+      end
+
+      def sanitise(str)
+        ActiveRecord::Base.connection.quote("%#{str}%")
+      end
+
+      def valid_boolean?(field, value)
+        field_type(field) == :boolean && ['true', 'false'].include?(value)
+      end
+
+      def valid_enum?(field, value)
+        enum = resource_class.defined_enums[field.to_s]
+        enum ? enum.keys.include?(value) : false
+      end
+    end
+  end
+end

data/lib/alpha_api/dynamic_setting.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module AlphaApi
+
+  class DynamicSetting
+    def self.build(setting, type)
+      (type ? klass(type) : self).new(setting)
+    end
+
+    def self.klass(type)
+      klass = "#{type.to_s.camelcase}Setting"
+      raise ArgumentError, "Unknown type: #{type}" unless AlphaApi.const_defined?(klass)
+      AlphaApi.const_get(klass)
+    end
+
+    def initialize(setting)
+      @setting = setting
+    end
+
+    def value(*_args)
+      @setting
+    end
+  end
+
+  # Many configuration options (Ex: site_title, title_image) could either be
+  # static (String), methods (Symbol) or procs (Proc). This wrapper takes care of
+  # returning the content when String or using instance_eval when Symbol or Proc.
+  #
+  class StringSymbolOrProcSetting < DynamicSetting
+    def value(context = self)
+      case @setting
+      when Symbol, Proc
+        context.instance_eval(&@setting)
+      else
+        @setting
+      end
+    end
+  end
+
+end

data/lib/alpha_api/dynamic_settings_node.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "alpha_api/dynamic_setting"
+require "alpha_api/settings_node"
+
+module AlphaApi
+
+  class DynamicSettingsNode < SettingsNode
+    class << self
+      def register(name, value, type = nil)
+        class_attribute "#{name}_setting"
+        add_reader(name)
+        add_writer(name, type)
+        send "#{name}=", value
+      end
+
+      def add_reader(name)
+        define_singleton_method(name) do |*args|
+          send("#{name}_setting").value(*args)
+        end
+      end
+
+      def add_writer(name, type)
+        define_singleton_method("#{name}=") do |value|
+          send("#{name}_setting=", DynamicSetting.build(value, type))
+        end
+      end
+    end
+  end
+end

data/lib/alpha_api/namespace_settings.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require "alpha_api/dynamic_settings_node"
+
+module AlphaApi
+  class NamespaceSettings < DynamicSettingsNode
+    # The default number of resources to display on index pages
+    register :default_per_page, 30
+
+    # The max number of resources to display on index pages and batch exports
+    register :max_per_page, 10_000
+
+    # The title which gets displayed in the main layout
+    register :site_title, "", :string_symbol_or_proc
+
+    # The method to call in controllers to get the current user
+    register :current_user_method, false
+
+    # The method to call in the controllers to ensure that there
+    # is a currently authenticated admin user
+    register :authentication_method, false
+
+    # Whether filters are enabled
+    register :filters, true
+
+    # Request parameters that are permitted by default
+    register :permitted_params, [
+      :utf8, :_method, :authenticity_token, :commit, :id
+    ]
+
+    # Include association filters by default
+    register :include_default_association_filters, true
+
+    register :maximum_association_filter_arity, :unlimited
+  end
+end

data/lib/alpha_api/resource_collection.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+module AlphaApi
+  # This is a container for resources, which acts much like a Hash.
+  # It's assumed that an added resource responds to `resource_name`.
+  class ResourceCollection
+    include Enumerable
+    extend Forwardable
+    def_delegators :@collection, :empty?, :has_key?, :keys, :values, :size
+
+    def initialize
+      @collection = {}
+    end
+
+    def add(resource)
+      if match = @collection[resource.resource_name]
+        raise_if_mismatched! match, resource
+        match
+      else
+        @collection[resource.resource_name] = resource
+      end
+    end
+
+    # Changes `each` to pass in the value, instead of both the key and value.
+    def each(&block)
+      values.each &block
+    end
+
+    def [](obj)
+      @collection[obj] || find_resource(obj)
+    end
+
+    private
+
+    # Finds a resource based on the resource name, resource class, or base class.
+    def find_resource(obj)
+      resources.detect do |r|
+        r.resource_name.to_s == obj.to_s
+      end || resources.detect do |r|
+        r.resource_class.to_s == obj.to_s
+      end ||
+      if obj.respond_to? :base_class
+        resources.detect { |r| r.resource_class.to_s == obj.base_class.to_s }
+      end
+    end
+
+    def resources
+      select { |r| r.class <= Resource } # can otherwise be a Page
+    end
+
+    def raise_if_mismatched!(existing, given)
+      if existing.class != given.class
+        raise IncorrectClass.new existing, given
+      elsif given.class <= Resource && existing.resource_class != given.resource_class
+        raise ConfigMismatch.new existing, given
+      end
+    end
+
+    class IncorrectClass < StandardError
+      def initialize(existing, given)
+        super "You're trying to register #{given.resource_name} which is a #{given.class}, " +
+              "but #{existing.resource_name}, a #{existing.class} has already claimed that name."
+      end
+    end
+
+    class ConfigMismatch < StandardError
+      def initialize(existing, given)
+        super "You're trying to register #{given.resource_class} as #{given.resource_name}, " +
+              "but the existing #{existing.class} config was built for #{existing.resource_class}!"
+      end
+    end
+
+  end
+end

data/lib/alpha_api/serializers/application_record_serializer.rb

@@ -0,0 +1,13 @@
+require 'fast_jsonapi'
+
+module AlphaApi
+  class ApplicationRecordSerializer
+    include FastJsonapi::ObjectSerializer
+
+    class << self
+      def requested?(name)
+        ->(_record, params) { params && params[:included]&.include?(name.to_s) }
+      end
+    end
+  end
+end

data/lib/alpha_api/settings_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+#
+module AlphaApi
+
+  class SettingsNode
+    class << self
+      # Never instantiated.  Variables are stored in the singleton_class.
+      private_class_method :new
+
+      # @return anonymous class with same accessors as the superclass.
+      def build(superclass = self)
+        Class.new(superclass)
+      end
+
+      def register(name, value)
+        class_attribute name
+        send "#{name}=", value
+      end
+    end
+  end
+end

data/lib/alpha_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AlphaApi
+  VERSION = "0.1.0"
+end

data/lib/alpha_api.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "alpha_api/version"
+require_relative "alpha_api/application"
+require_relative "generators/resource/resource_generator"
+require_relative "generators/install/install_generator"
+require_relative 'alpha_api/application_settings'
+require_relative 'alpha_api/concerns/actionable'
+require_relative 'alpha_api/serializers/application_record_serializer'
+
+module AlphaApi
+  class Error < StandardError; end
+  # Your code goes here...
+
+  class << self
+
+    attr_accessor :application
+
+    def application
+      @application ||= ::AlphaApi::Application.new
+    end
+
+    delegate :register, to: :application
+
+    # Gets called within the initializer
+    def setup
+      application.before_initializer!
+      yield(application)
+      application.after_initializer!
+    end
+  end
+end

data/lib/generators/install/install_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+#
+module AlphaApi
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Installs AlphaApi"
+
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_initializer
+        template "alpha_api.rb.erb", "config/initializers/alpha_api.rb"
+      end
+
+      def something
+        puts 'h1'
+      end
+    end
+  end
+end

data/lib/generators/install/templates/alpha_api.rb.erb

@@ -0,0 +1,20 @@
+AlphaApi.setup do |config|
+  # == Site Title
+  #
+  # Set the title that is displayed on the main layout
+  # for each of the active admin pages.
+  #
+  config.site_title = "<%= Rails.application.class.name.split("::").first.titlecase %>"
+
+  # Set the link url for the title. For example, to take
+  # users to your main site. Defaults to no link.
+  #
+  # config.site_title_link = "/"
+
+  # Set an optional image to be displayed for the header
+  # instead of a string (overrides :site_title)
+  #
+  # Note: Aim for an image that's 21px high so it fits in the header.
+  #
+  # config.site_title_image = "logo.png"
+end

data/lib/generators/resource/resource_generator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module AlphaApi
+  module Generators
+    class ResourceGenerator < Rails::Generators::NamedBase
+      desc "Registers resources with AlphaApi"
+
+      class_option :include_boilerplate, type: :boolean, default: false,
+                                         desc: "Generate boilerplate code for your resource."
+
+      source_root File.expand_path("templates", __dir__)
+
+      def generate_controller_file
+        prefix = AlphaApi.application.settings.api_prefix
+        @boilerplate = Boilerplate.new(class_name, prefix)
+        template "controller.rb.erb", "app/controllers/#{prefix}/#{file_path.tr('/', '_').pluralize}_controller.rb"
+      end
+
+      def generate_serializer_file
+        prefix = AlphaApi.application.settings.api_prefix
+        @boilerplate = Boilerplate.new(class_name, prefix)
+        template "serializer.rb.erb", "app/serializers/#{prefix}/#{file_path.tr('/', '_')}_serializer.rb"
+      end
+    end
+
+    class Boilerplate
+      def initialize(class_name, module_path)
+        @module_path = module_path
+        @class_name = class_name
+      end
+
+      def module_name
+        @module_path.split('/').map(&:capitalize).join('::')
+      end
+
+      def attributes
+        @class_name.constantize.new.attributes.keys
+      end
+
+      def assignable_attributes
+        attributes - %w(id created_at updated_at)
+      end
+
+      def permit_params
+        assignable_attributes.map { |a| a.to_sym.inspect }.join(", ")
+      end
+
+      def rows
+        attributes.map { |a| row(a) }.join("\n  ")
+      end
+
+      def row(name)
+        "#   row :#{name.gsub(/_id$/, '')}"
+      end
+
+      def columns
+        attributes.map { |a| column(a) }.join("\n  ")
+      end
+
+      def column(name)
+        "#   column :#{name.gsub(/_id$/, '')}"
+      end
+
+      def filters
+        attributes.map { |a| filter(a) }.join("\n  ")
+      end
+
+      def filter(name)
+        "# filter :#{name.gsub(/_id$/, '')}"
+      end
+
+      def form_inputs
+        assignable_attributes.map { |a| form_input(a) }.join("\n  ")
+      end
+
+      def form_input(name)
+        "#     f.input :#{name.gsub(/_id$/, '')}"
+      end
+    end#
+  end
+end

data/lib/generators/resource/templates/controller.rb.erb

@@ -0,0 +1,49 @@
+class <%= @boilerplate.module_name %>::<%= class_name.pluralize %>Controller < <%= @boilerplate.module_name %>::BaseController
+  include AlphaApi::Concerns::Actionable
+
+  protected
+
+  def allow_all
+    true
+  end
+
+  def allowed_associations
+    [:organisation]
+  end
+
+  def allowed_sortings
+    [:email, :name, :role]
+  end
+
+  def collection
+    super.includes(:organisation)
+  end
+
+  def filterable_fields
+    [:email, :name, :role, :organisation_id]
+  end
+
+  def permitted_create_params
+    super.permit(*whitelist)
+  end
+
+  def permitted_update_params(_resource)
+    super.permit(*whitelist)
+  end
+
+  def whitelist
+    [
+      :organisation_id,
+      :name,
+      :email,
+      :role,
+      :password,
+      :password_confirmation
+    ]
+  end
+
+  def destroyable
+    true
+  end
+end
+

data/lib/generators/resource/templates/serializer.rb.erb

@@ -0,0 +1,6 @@
+class <%= @boilerplate.module_name %>::<%= class_name %>Serializer < AlphaApi::ApplicationRecordSerializer
+  attributes \
+    :created_at,
+    :unit_price
+end
+

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: alpha_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alba Hoo
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fast_jsonapi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: api-pagination
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Expose models with restful api
+email:
+- alba@tenty.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- alpha_api.gemspec
+- bin/console
+- bin/setup
+- lib/alpha_api.rb
+- lib/alpha_api/application.rb
+- lib/alpha_api/application_settings.rb
+- lib/alpha_api/concerns/actionable.rb
+- lib/alpha_api/dynamic_setting.rb
+- lib/alpha_api/dynamic_settings_node.rb
+- lib/alpha_api/namespace_settings.rb
+- lib/alpha_api/resource_collection.rb
+- lib/alpha_api/serializers/application_record_serializer.rb
+- lib/alpha_api/settings_node.rb
+- lib/alpha_api/version.rb
+- lib/generators/install/install_generator.rb
+- lib/generators/install/templates/alpha_api.rb.erb
+- lib/generators/resource/resource_generator.rb
+- lib/generators/resource/templates/controller.rb.erb
+- lib/generators/resource/templates/serializer.rb.erb
+homepage: https://github.com/AlbaHoo/AlphaApi
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/AlbaHoo/AlphaApi
+  source_code_uri: https://github.com/AlbaHoo/AlphaApi
+  changelog_uri: https://github.com/AlbaHoo/AlphaApi
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: RESTfulise model with jsonapi
+test_files: []