kriangle 0.1.0

data/lib/generators/kriangle/templates/controllers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+<%- unless skip_swagger -%>
+require 'grape-swagger'
+<%- end -%>
+
+module Api
+  module <%= wrapper.capitalize %>
+    class Controllers < Grape::API
+      <%- unless skip_swagger -%>
+
+      add_swagger_documentation(
+        api_version: "<%= wrapper.underscore %>",
+        hide_documentation_path: true,
+        mount_path: "/kriangle/api/<%= wrapper.underscore %>/swagger_doc",
+        hide_format: true
+      )
+      <%- end -%>
+    end
+  end
+end

data/lib/generators/kriangle/templates/counter_cache_migration.rb

@@ -0,0 +1,5 @@
+class Add<%= class_name.pluralize %>CountTo<%= @options[:belongs_to].classify.pluralize %> < ActiveRecord::Migration[5.2]
+  def change
+    add_column :<%= @options[:belongs_to].pluralize %>, :<%= class_name.pluralize.underscore %>_count, :integer, default: 0
+  end
+end

data/lib/generators/kriangle/templates/create_authentications.rb

@@ -0,0 +1,10 @@
+class CreateAuthentications < ActiveRecord::Migration<%= "[#{Rails::VERSION::STRING[0..2]}]" if Rails::VERSION::MAJOR > 4 %>
+  def change
+    create_table :authentications do |t|
+      t.references :<%= underscored_user_class %>, foreign_key: true
+
+      t.text :client_id
+      t.text :token
+    end
+  end
+end

data/lib/generators/kriangle/templates/create_avatars.rb

@@ -0,0 +1,10 @@
+class CreateAvatars < ActiveRecord::Migration<%= "[#{Rails::VERSION::STRING[0..2]}]" if Rails::VERSION::MAJOR > 4 %>
+  def change
+    create_table :avatars do |t|
+      t.references :<%= underscored_user_class %>, foreign_key: true
+
+      t.text :image
+      t.integer :sorting, default: 0
+    end
+  end
+end

data/lib/generators/kriangle/templates/create_users.rb.erb

@@ -0,0 +1,48 @@
+class Create<%= user_class.pluralize %> < ActiveRecord::Migration<%= "[#{Rails::VERSION::STRING[0..2]}]" if Rails::VERSION::MAJOR > 4 %>
+  def change
+    create_table :<%= user_class.pluralize.underscore %> do |t|
+      ## User Info
+      <%- for attribute in model_attributes -%>
+      <%- next if attribute.name == 'email' -%>
+      t.<%= attribute.type %> :<%= attribute.name %>
+      <%- end -%>
+
+      ## Database authenticatable
+      t.string :email,              :null => false, :default => ""
+      t.string :encrypted_password, :null => false, :default => ""
+
+      ## Recoverable
+      t.string   :reset_password_token
+      t.datetime :reset_password_sent_at
+      t.boolean  :allow_password_change, :default => false
+
+      ## Rememberable
+      t.datetime :remember_created_at
+
+      ## Trackable
+      t.integer  :sign_in_count, :default => 0, :null => false
+      t.datetime :current_sign_in_at
+      t.datetime :last_sign_in_at
+      t.string   :current_sign_in_ip
+      t.string   :last_sign_in_ip
+
+      ## Confirmable
+      t.string   :confirmation_token
+      t.datetime :confirmed_at
+      t.datetime :confirmation_sent_at
+      t.string   :unconfirmed_email # Only if using reconfirmable
+
+      ## Lockable
+      t.integer  :failed_attempts, :default => 0, :null => false # Only if lock strategy is :failed_attempts
+      t.string   :unlock_token # Only if unlock strategy is :email or :both
+      t.datetime :locked_at
+
+      t.timestamps
+    end
+
+    add_index :<%= user_class.pluralize.underscore %>, :email,                unique: true
+    add_index :<%= user_class.pluralize.underscore %>, :reset_password_token, unique: true
+    add_index :<%= user_class.pluralize.underscore %>, :confirmation_token,   unique: true
+    # add_index :<%= user_class.pluralize.underscore %>, :unlock_token,       unique: true
+  end
+end

data/lib/generators/kriangle/templates/custom_description.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Api
+  module CustomDescription
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def description(title)
+        desc title,
+             headers: {
+               'X-Uid' => {
+                 description: 'User Id',
+                 required: true,
+                 default: ENV['X_UID']
+               },
+               'X-Client-Id' => {
+                 description: 'Client Id',
+                 required: true,
+                 default: ENV['X_CLIENT_ID']
+               },
+               'X-Authentication-Token' => {
+                 description: 'Authentication Token',
+                 required: true,
+                 default: ENV['X_AUTH_TOKEN']
+               }
+             }
+      end
+    end
+  end
+end

data/lib/generators/kriangle/templates/defaults.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Api
+  module <%= wrapper.capitalize %>
+    module Defaults
+      extend ActiveSupport::Concern
+
+      included do
+        prefix "api"
+        version "<%= wrapper.underscore %>", using: :path
+        default_format :json
+        format :json
+        formatter :json, Grape::Formatter::ActiveModelSerializers
+
+        # Authenticator and Responder
+        <%- unless skip_authentication -%>
+        include Api::Authenticator
+        <%- end -%>
+        include Api::Responder
+
+        helpers do
+          def logger
+            Rails.logger
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/kriangle/templates/kriangle.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Kriangle.setup do |config|
+  config.database = '<%= database %>'
+end

data/lib/generators/kriangle/templates/model.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class <%= class_name %> < ApplicationRecord
+  <%- for ma in model_associations.uniq { |ma| ma.association_name } -%>
+  <%= ma.association %>
+  <%- end -%>
+  <%- if self_reference -%>
+  belongs_to :<%= parent_association_name %>, :class_name => '<%= class_name %>', optional: true
+  has_many :<%= child_association_name %>, :class_name => '<%= class_name %>', :foreign_key => '<%= parent_association_name %>_id'
+
+  scope :only_parent, -> { includes(:<%= child_association_name %>).where(<%= parent_association_name %>_id: nil) }
+  <%- end -%>
+  <%- for polymorphic in @options[:polymorphics] -%>
+  belongs_to :<%= polymorphic %>, polymorphic: true
+  # use below into referenced model
+  # has_many :<%= polymorphic.gsub('able','').pluralize %>, as: :<%= polymorphic %>, dependent: :destroy
+  <%- end -%>
+  <%- for parent_model in @options[:references] -%>
+    <%- if !reference || parent_model != user_class -%>
+  belongs_to :<%= parent_model %>
+    <%- end -%>
+  <%- end -%>
+  <%- if database == 'sqlite3' -%>
+    <%- attributes.select { |a| a.type == 'array' }.each do |a| -%>
+  serialize :<%= a.name %>, Array
+    <%- end -%>
+  <%- end -%>
+  <%- if @options[:attributes].size != 0 -%>
+
+  # validation's on columns
+  validates :<%= @options[:attributes].join(', :') %>, presence: true
+  <%- end -%>
+end

data/lib/generators/kriangle/templates/module_migration.rb

@@ -0,0 +1,33 @@
+class Create<%= class_name.pluralize %> < ActiveRecord::Migration[5.2]
+  def change
+    create_table :<%= controller_file_name %> do |t|
+      <%- for ma in model_associations.select { |ma| ma.association_type == 'belongs_to' }.uniq { |ma| ma.association_name } -%>
+        <%- if ma.foreign_key.present? -%>
+      t.integer :<%= ma.foreign_key %>, index: true
+        <%- else -%>
+      t.references :<%= ma.association_name %><%= ", foreign_key: true" if ma.class_name.blank? %>
+        <%- end -%>
+      <%- end -%>
+      <%- if self_reference -%>
+      t.references :<%= parent_association_name %>, index: true
+      <%- end -%>
+      <%- for attribute in @polymorphics -%>
+      t.references :<%= attribute.name %>, polymorphic: true
+      <%- end -%>
+      <%- for attribute in @attributes -%>
+        <%- if attribute.type == 'array' -%>
+          <%- if database == 'sqlite3' -%>
+      t.text :<%= attribute.name %>
+          <%- else -%>
+      t.text :<%= attribute.name %>, array: true, default: []
+          <%- end -%>
+        <%- else -%>
+      t.<%= attribute.type || 'string'  %> :<%= attribute.name %><%= ", default: #{attribute.default.gsub('~', "'")}" unless attribute.default.nil? %>
+        <%- end -%>
+      <%- end -%>
+      <%- unless skip_timestamps -%>
+      t.timestamps
+      <%- end -%>
+    end
+  end
+end

data/lib/generators/kriangle/templates/responder.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+class JsonResponse
+  attr_reader :success, :message, :data, :meta, :errors
+
+  def initialize(options = {})
+    @success = options[:success].to_s.empty? ? true : options[:success]
+    @message = options[:message] || options[:errors].try(:first) || ''
+    @data = options[:data] || []
+    @meta = options[:meta] || {}
+    @errors = options[:errors] || []
+  end
+
+  def as_json(*)
+    {
+      success: success,
+      message: message,
+      data: data,
+      meta: meta,
+      errors: errors
+    }
+  end
+end
+
+module Api
+  module Responder
+    extend ActiveSupport::Concern
+
+    included do
+      # catch exception and return JSON-formatted error
+      # def handle_exceptions
+      #   begin
+      #     yield
+      #   rescue <%= get_record_not_found_exception %> => e
+      #     status_code = 404
+      #   rescue <%= get_record_invalid_exception %> => e
+      #     json_error_response(e.record) && return
+      #   rescue ArgumentError => e
+      #     status_code = 400
+      #   rescue StandardError => e
+      #     status_code = 500
+      #   end
+      #   json_error_response({ message: e.class.to_s, errors: [{ detail: e.message, trace: e.backtrace }] }, status_code) unless e.class == NilClass
+      # end
+
+      helpers do
+        # extract options
+        # i.e. serializer = nil, options = {}, additional_response = {}
+        def extract_options resource, options, collection = false
+          # identify serializer
+          @serializer = options[:serializer]
+          unless @serializer
+            if collection
+              class_name = resource&.first&.class
+              if class_name.present? && class_name != NilClass
+                @serializer = "#{class_name}Serializer".constantize
+              end
+            else
+              @serializer = "#{resource.class}Serializer".constantize
+            end
+          end
+
+          # additional params
+          @serializer_options = options[:serializer_options] || {}
+          @additional_response = options[:additional_response] || {}
+        end
+
+        # render single object with serializer
+        def render_object object, **options
+          extract_options(object, options) # extract required options
+
+          json_success_response({
+            data: @serializer.present? ? single_serializer.new(object, serializer: @serializer, serializer_options: @serializer_options) : {}
+          }.merge(@additional_response))
+        end
+
+        def format_aggregation(aggs)
+          return [] if aggs.blank?
+
+          aggregations = []
+          aggs.each do |k, value|
+            value['buckets'].each do |bucket|
+              bucket['count'] = bucket.delete('doc_count')
+            end
+            aggregations << { name: k, buckets: value['buckets'] }
+          end
+          aggregations
+        end
+
+        # render collection of objects with serializer
+        def render_objects objects, **options
+          extract_options(objects.to_a, options, true) # extract required options
+
+          # collect meta data if any present there
+          meta = options[:extra_params].present? ? options[:extra_params] : {}
+          meta[:suggestions]  = objects.suggestions if objects.respond_to?(:suggestions) && objects.suggestions.present?
+          meta[:aggregations] = format_aggregation(objects.aggs) if objects.respond_to?(:aggs)
+          if objects.respond_to?(:total_count)
+            meta[:pagination] = {
+              total_count: objects.total_count,
+              current_page: objects.current_page,
+              next_page: objects.next_page,
+              per_page: objects.try(:per_page) || objects.try(:limit_value) || 10000
+            }
+          end
+
+          # send data & meta
+          json_success_response({
+            data: @serializer.present? ? array_serializer.new(objects, serializer: @serializer, serializer_options: @serializer_options) : [],
+            meta: meta
+          }.merge(@additional_response))
+        end
+
+        def render_not_found(resource)
+          render_error_response(["#{ resource } not found."], :not_found)
+        end
+
+        def render_errors(object)
+          render_error_response(object.errors, :unprocessable_entity)
+        end
+
+        def render_error
+          render_error_response(['Something went wrong. Please try after sometime.'], :unprocessable_entity)
+        end
+
+        def render_interval_server_error
+          render_error_response(['Internal server error.'], 500)
+        end
+
+        def render_unprocessable_entity(errors)
+          render_error_response(errors, 422) and return
+        end
+
+        def render_unauthorized_access
+          render_error_response(['Invalid or expired token.'], 401) and return
+        end
+
+        def render_error_response(errors = [], status = 422)
+          json_error_response({ errors: errors }, status)
+        end
+
+        def json_success_response response = {}
+          JsonResponse.new(response.merge(status: true)).as_json
+        end
+
+        def json_error_response response = {}, status = 422
+          error!(JsonResponse.new(response.merge(status: true)).as_json, status)
+        end
+
+        def array_serializer
+          ActiveModel::Serializer::CollectionSerializer
+        end
+
+        def single_serializer
+          ActiveModelSerializers::SerializableResource
+        end
+      end
+
+      rescue_from <%= get_record_not_found_exception %> do |e|
+        message = e.try(:problem) || e.try(:message)
+        model_name = message.match(/(?<=class|find)[^w]+/)&.to_s&.strip
+        json_error_response(errors: ["No #{model_name || 'Record'} Found."], status: 404)
+      end
+
+      rescue_from <%= get_record_invalid_exception %> do |e|
+        json_error_response(errors: [e.message], status: 422)
+      end
+    end
+  end
+end

data/lib/generators/kriangle/templates/serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class <%= @options[:class_name] || class_name %>Serializer < ActiveSerializer
+  attributes :<%= @options[:attributes].join(', :') %>
+  <%- unless skip_tips -%>
+  # attributes :custom_function
+  <%- end -%>
+
+  <%- @options[:references].try(:each) do |parent_model| -%>
+  belongs_to :<%= parent_model %>
+  <%- end -%>
+  <%- for ma in model_associations -%>
+  <%= ma.association_type_with_name %>
+  <%- end -%>
+  <%- if self_reference -%>
+  has_many :<%= child_association_name %>, serializer: <%= @options[:class_name] || class_name %>Serializer
+  <%- end -%>
+  <%- unless skip_tips -%>
+  # association's example
+  # belongs_to :user
+  # has_one :address
+  # has_many :avatars
+
+  # def custom_function
+  #   object.association(:association_model_name).loaded? ? object.association_model_name : {}
+  # end
+
+  # add your custom attributes here if required
+  # def attributes(*args)
+  #  hash = super
+  #  # hash[:your_key] = object.some_method_call
+  #  hash
+  # end
+  <%- end -%>
+end