blazer_json_api 0.1.1d → 0.1.1e

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f6334f046a09d7f2a4ab42a69c12658d08c8cfd8741b6dd970e1245b65c664c
-  data.tar.gz: f7b09af286f45776b3801d0b2aff67f55c67bea066c7ea7a681708e5182973b6
+  metadata.gz: e325bb61490d8a0910e0952abd8a51236162e3f706d3f9fa61536e3a1096c0e6
+  data.tar.gz: 95b2f4209f73d76db0b0efcbd298e07c2c1240df2c6cccaef75207443281da74
 SHA512:
-  metadata.gz: 3409b404960bd3c197aa03731653f559e6eca6c2f38a732c98318c0a8eefe410a2ba13c09b9d2d2bd6111c9437f8105b486c22c5b6e8d68aff7d32c7320ef214
-  data.tar.gz: 114d9d8e40a4c2205b6bb2f0ff94a0c2113d8342cffbb91f64fa1946e61156d3a8ad92656364ce02a822dd98a2b3786a13284778316d67da764928ac0b4919d1
+  metadata.gz: 576b3fcce73e53db19fe1a4381ca94e439061f50406ffe198ecd5f67c1bd37a401af0ae16c6efde9111a4fb290c53d2dfe14964ef1d48bad33859aca1dcbd013
+  data.tar.gz: 0be572b3cf7d73ea051e2c20f896f7449f498fb1e39063bbc9a1fb2af738ba0c0798991a75a06f6eed7e48e1be90e829c4dbf20fc9d0ee335583329c4363b014

data/README.md

@@ -2,16 +2,17 @@
 An extension to [Blazer](https://github.com/ankane/blazer) to enable exposing your queries as JSON via API so it can be consumed outside of Blazer by your application.
 
 ## Features
-- **Powered by SQL** Author APIs quickly using Blazers IDE. Particular useful for private/internal APIs that fall outside of your standard API endpoints
-- **No deploy APIs** Expermental APIs can be authored quickly via Blazer without the need to do a deploy
-- **Flexible structure** JSON response structure can be controlled directly in SQL by using a column naming convention (double underscore denotes a nesting by default, but can be overridden)
-- **Security** You'll likely want to lock down API access so APIs are authenticated separately to standard Blazer authentication using HTTP basic authentication to avoid granding everyone with access to Blazer also access to your APIs. 
-- **URL parameters** URL parameters are also supported built on Blazers query variables meaning the APIs can be highly dynamic and flexible
+- **Powered by SQL** Author APIs quickly using Blazers SQL based IDE. Particular useful for private/internal APIs that fall outside of your standard API endpoints
+- **No deploy APIs** Expermental APIs can be authored and iterated on quickly via Blazer without the need to do a deploy.
+- **Flexible structure** JSON response structure can be controlled directly in SQL by using a column naming convention (double underscore `__` denotes a nesting by default, but can be overridden)
+- **Security** You'll likely want to lock down API access so APIs are authenticated separately to the standard Blazer auth model, so authentication is enabled using HTTP basic authentication to avoid granding everyone with access to Blazer also access to your APIs. 
+- **URL parameters** URL parameters are also supported via Blazers query variables meaning the APIs can be highly dynamic and flexible
 - **Pagination** Pagination can be controlled using query variables in combination with limits and offsets
-- **Multiple data sources** Blazer supports multiple datasources meaning you can potentially build APIs that access beyond the applications database (e.g. ElasticSearch, Google BigQuery, Salesforce)
+- **Multiple data sources** Blazer supports multiple data sources meaning you can potentially build APIs that access beyond the applications database (e.g. ElasticSearch, Google BigQuery, Salesforce)
+- **Permissions** Use Blazers [basic permissions mode](https://github.com/ankane/blazer#query-permissions) with your own naming conventions to control access to APIs based queries.
 
 ## Installation
-Follow the installation steps described to get Blazer up and running.
+Follow the installation steps described to get [Blazer](https://github.com/ankane/blazer#installation) up and running.
 Then, add this line to your application's Gemfile:
 
 ```ruby
@@ -26,30 +27,149 @@ $ bundle
 And mount the engine in your `config/routes.rb`:
 
 ```ruby
-mount BlazerJsonAPI, at: 'blazer-api'
+mount Blazer::Api::Engine, at: 'blazer-api'
 ```
 
-Configure authentication in an initializer as follows (e.g. in `initializers/blazer_json_api.rb`)
+Configure authentication in an initializer as follows (e.g. in `initializers/blazer_api.rb`)
 
 ```ruby
-BlazerJsonAPI::Config.username = <api-username>
-BlazerJsonAPI::Config.password = <api-password>
+Blazer::Api::Config.username = <api-username>
+Blazer::Api::Config.password = <api-password>
 ```
 
 ## Usage
 Create queries as normal via Blazer and use the query identifier to render the JSON via the mounted location. 
 
-e.g. `/blazer-api/queries/1-all-users`
+e.g. `/blazer-api/queries/1-all-users` or `/blazer-api/queries/1`
+URL params can be added where necessary also
+e.g. `/blazer-api/queries/1-all-users?page=1&per_page=30`
 
 ### Example queries
 
+#### A simple index like request
+Fetching specifics of all users as follows:
 
-> TODO
+```sql
+SELECT id, username, first_name, last_name, email, country
+FROM users
+```
+This would result in the following API response
+```json
+[
+   {
+      "id":1,
+      "username":"blazer_tommy",
+      "first_name":"Tom",
+      "last_name":"Carey",
+      "email":"tom.carey@gmail.com",
+      "country":"Ireland"
+   },
+   {
+      "id":2,
+      "username":"blazer_john",
+      "first_name":"John",
+      "last_name":"Doyle",
+      "email":"john.doyle@gmail.com",
+      "country":"USA"
+   }
+  // ...
+]
+```
+#### A simple single resource GET request using a variable
 
-## Contributing
+Using a variable, a specific resource can be fetched.
+Note: the use of `LIMIT 1` can be used to be explicit in desiring a single record in the response, as opposed to a collection
+
+```sql
+SELECT id, username, first_name, last_name, email, country
+FROM users
+WHERE username={username}
+LIMIT 1
+```
+Now, the username can be passed as a URL parameter to the API to fetch the relevant record.
+It would result in the following response.
+```json
+{
+  "id":2,
+  "username":"blazer_john",
+  "first_name":"John",
+  "last_name":"Doyle",
+  "email":"john.doyle@gmail.com",
+  "country":"USA"
+}
+```
+#### Controlling response structure
+Standard queries return flat JSON responses that correspond to the results table from executing the SQL.
+It's possible to control the JSON structure by using double underscores to denote the desired nesting
+
+Take, for example, the following query:
 
+```sql
+SELECT users.id, username, first_name, last_name, teams.name as team__name, teams.location as team__location, email
+FROM users
+JOIN users ON users.team_id = teams.id
+```
+
+Would result in the following structure in the response:
+
+```json
+[
+  {
+    "id":1,
+    "username":"blazer_tommy",
+    "first_name":"Tom",
+    "last_name":"Carey",
+    "team":{
+      "name":"defenders",
+      "location":"Dublin"
+    },
+    "email":"tom.carey@gmail.com"
+  },
+  {
+    "id":2,
+    "username":"blazer_john",
+    "first_name":"John",
+    "last_name":"Doyle",
+    "team":{
+      "name":"responders",
+      "location":"London"
+    },
+    "email":"john.doyle@gmail.com"
+  }
+]
+```
+Deeper nesting is also possible, just continue the pattern e.g. `a__deeper__nested__value`
+
+#### Paginating potentially large responses
+If your query could return a large response, it's generally a good idea to paginate it.
+Pagination can be achieved in many ways, but a basic example can be done as follows using a combination
+of variables in the query and `LIMIT` and `OFFSET`.
+
+```sql
+SELECT id, username, first_name, last_name, email, country
+FROM users
+LIMIT {per_page}
+OFFSET ({page}-1)*{per_page}
+```
+Using this technique, URL params can be used by the requester to control pagination.
+In this example, `page` corresponds to the desired page in the paginated collection and `per_page` corresponds to the desired size of records in each page
+
+This technique can be used in combination with some default settings for these parameters in blazers config file `blazer.yml`.
+Having defaults means if they are not specified by the requester, the defaults will automatically be applied.
+```yaml
+    variable_defaults:
+      # pagination defaults
+      per_page: 30
+      page: 1
+```
+
+## Contributing
+Want to improve this library, please do!
 
-> TODO
+* Report bugs
+* Fix bugs and submit pull requests
+* Write, clarify, or fix documentation
+* Suggest or add new features
 
 ## License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -10,7 +10,7 @@ require 'rdoc/task'
 
 RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'BlazerJsonApi'
+  rdoc.title    = 'Blazer::Api'
   rdoc.options << '--line-numbers'
   rdoc.rdoc_files.include('README.md')
   rdoc.rdoc_files.include('lib/**/*.rb')

data/app/assets/config/blazer_json_api_manifest.js

@@ -1,2 +1,2 @@
-//= link_directory ../javascripts/blazer_json_api .js
-//= link_directory ../stylesheets/blazer_json_api .css
+//= link_directory ../javascripts/blazer/api .js
+//= link_directory ../stylesheets/blazer/api .css

data/app/controllers/blazer/api/application_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Blazer
+  module Api
+    class ApplicationController < ActionController::Base
+      protect_from_forgery with: :exception
+
+      def record_not_found
+        render json: [], status: :not_found
+      end
+
+      def render_errors(error_messages)
+        render json: { errors: error_messages }, status: :bad_request
+      end
+    end
+  end
+end

data/app/controllers/blazer/api/queries_controller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Blazer
+  module Api
+    class QueriesController < ApplicationController
+      if Blazer::Api::Config.username && Blazer::Api::Config.password
+        http_basic_authenticate_with name: Blazer::Api::Config.username, password: Blazer::Api::Config.password
+      end
+      before_action :set_query
+
+      def show
+        @statement = @query.statement
+        data_source = @query.data_source
+        process_variables(@statement, data_source)
+        result = Blazer.data_sources[data_source].run_statement(@statement)
+
+        if result.error.present?
+          render_errors(Array(result.error))
+        else
+          render json: Blazer::Api::ResultToNestedJson.new(@statement, result).call
+        end
+      end
+
+      private
+
+      def set_query
+        @query = Blazer::Query.find_by(id: params[:id].to_s.split('-').first)
+        record_not_found && return if @query.blank?
+      end
+
+      def process_variables(statement, data_source)
+        Blazer::Api::ProcessStatementVariables.new(statement, data_source, params).call
+      end
+    end
+  end
+end

data/app/helpers/blazer/api/application_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Blazer
+  module Api
+    module ApplicationHelper
+    end
+  end
+end

data/app/jobs/blazer/api/application_job.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Blazer
+  module Api
+    class ApplicationJob < ActiveJob::Base
+    end
+  end
+end

data/app/mailers/blazer/api/application_mailer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Blazer
+  module Api
+    class ApplicationMailer < ActionMailer::Base
+      default from: 'from@example.com'
+      layout 'mailer'
+    end
+  end
+end

data/app/models/blazer/api/application_record.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Blazer
+  module Api
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/views/layouts/blazer/api/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Blazer json api</title>
+  <%= stylesheet_link_tag    "blazer/api/application", media: "all" %>
+  <%= javascript_include_tag "blazer/api/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-BlazerJsonAPI::Engine.routes.draw do
+Blazer::Api::Engine.routes.draw do
   resources :queries, only: :show
 end

data/lib/blazer/api/config.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Blazer
+  module Api
+    class Config
+      # defaults
+      @@nesting_column_separator = '__'
+
+      cattr_accessor :username
+      cattr_accessor :password
+      cattr_accessor :nesting_column_separator
+    end
+  end
+end

data/lib/blazer/api/engine.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Blazer
+  module Api
+    class Engine < ::Rails::Engine
+      isolate_namespace Blazer::Api
+    end
+  end
+end

data/lib/blazer/api/process_statement_variables.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Taken from: https://github.com/ankane/blazer/blob/ac7e02e0fe19ee6c0bc8c7f3ba87be0d260f8255/app/controllers/blazer/base_controller.rb#L35
+# Necessary for processing any query variables safely
+# Refactored to avoid rubocop breaches
+module Blazer
+  module Api
+    class ProcessStatementVariables
+      attr_reader :statement, :data_source, :params
+
+      def initialize(statement, data_source, params)
+        @statement = statement
+        @data_source = data_source
+        @params = params
+      end
+
+      def call
+        return unless bind_variables.all? { |v| params[v] }
+
+        bind_variables.each do |variable|
+          value = params[variable].presence
+          if value
+            if variable.end_with?('_at')
+              begin
+                value = Blazer.time_zone.parse(value)
+              rescue StandardError
+                # do nothing
+              end
+            end
+
+            if /\A\d+\z/.match?(value.to_s)
+              value = value.to_i
+            elsif /\A\d+\.\d+\z/.match?(value.to_s)
+              value = value.to_f
+            end
+          end
+          value = Blazer.transform_variable.call(variable, value) if Blazer.transform_variable
+          statement.gsub!("{#{variable}}", ActiveRecord::Base.connection.quote(value))
+        end
+      end
+
+      private
+
+      def bind_variables
+        @bind_variables ||=
+          begin
+            (bind_variables ||= []).concat(Blazer.extract_vars(statement)).uniq!
+            bind_variables.each do |variable|
+              params[variable] ||= Blazer.data_sources[data_source].variable_defaults[variable]
+            end
+          end
+      end
+    end
+  end
+end

data/lib/blazer/api/result_to_nested_json.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Converts a blazer query result table into nested JSON
+# Used the convention of a double underscore in the column header to denote a parent key or nesting
+# e.g. { 'parent__child': '1' } becomes { 'parent': { 'child': 1 }}
+module Blazer
+  module Api
+    class ResultToNestedJson
+      delegate :nesting_column_separator, to: Blazer::Api::Config
+
+      attr_reader :statement, :blazer_result
+
+      def initialize(statement, blazer_result)
+        @statement = statement
+        @blazer_result = blazer_result
+      end
+
+      def call
+        transformed_result =
+          blazer_result_to_json(blazer_result).each do |hash|
+            hash.keys.select { |key| key =~ /#{nesting_column_separator}/ }.each do |namespaced_key|
+              nested_keys = namespaced_key.to_s.split(nesting_column_separator)
+              hash.deep_merge!(deep_hash_set(*nested_keys[0..nested_keys.size], hash[namespaced_key]))
+              hash.delete(namespaced_key)
+            end
+          end
+        collection_or_single_record(transformed_result)
+      end
+
+      private
+
+      def blazer_result_to_json(blazer_result)
+        blazer_result.rows.map do |row|
+          row_hash = {}
+          row.each_with_index do |value, value_index|
+            row_hash[blazer_result.columns[value_index]] = value
+          end
+          row_hash
+        end
+      end
+
+      # recursively sets a nested key in a hash (like the opposite to Hash.dig)
+      # e.g. deep_hash_set(*['a', 'b' , 'c'], 4)
+      # { a => { b => { c => 4 } } }
+      # @return Hash
+      def deep_hash_set(*keys, value)
+        keys.empty? ? value : { keys.first => deep_hash_set(*keys.drop(1), value) }
+      end
+
+      # Use the presence of LIMIT 1 in the query to decide whether to render
+      # a collection response (like an index)
+      # or a single entry response
+      def collection_or_single_record(result)
+        /LIMIT 1$/i.match?(statement) ? result.first : result
+      end
+    end
+  end
+end

data/lib/blazer/api/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Blazer
+  module Api
+    VERSION = '0.1.1e'
+  end
+end

data/lib/blazer/json_api.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'blazer/api/engine'
+require 'blazer/api/config'
+require 'blazer/api/process_statement_variables'
+require 'blazer/api/result_to_nested_json'
+
+module Blazer
+  module Api
+  end
+end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: blazer_json_api
 version: !ruby/object:Gem::Version
-  version: 0.1.1d
+  version: 0.1.1e
 platform: ruby
 authors:
 - John Farrell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-02 00:00:00.000000000 Z
+date: 2021-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: railties
+  name: blazer
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: blazer
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -64,22 +64,22 @@ files:
 - README.md
 - Rakefile
 - app/assets/config/blazer_json_api_manifest.js
-- app/assets/javascripts/blazer_json_api/application.js
-- app/assets/stylesheets/blazer_json_api/application.css
-- app/controllers/blazer_json_api/application_controller.rb
-- app/controllers/blazer_json_api/queries_controller.rb
-- app/helpers/blazer_json_api/application_helper.rb
-- app/jobs/blazer_json_api/application_job.rb
-- app/mailers/blazer_json_api/application_mailer.rb
-- app/models/blazer_json_api/application_record.rb
-- app/views/layouts/blazer_json_api/application.html.erb
+- app/assets/javascripts/blazer/api/application.js
+- app/assets/stylesheets/blazer/api/application.css
+- app/controllers/blazer/api/application_controller.rb
+- app/controllers/blazer/api/queries_controller.rb
+- app/helpers/blazer/api/application_helper.rb
+- app/jobs/blazer/api/application_job.rb
+- app/mailers/blazer/api/application_mailer.rb
+- app/models/blazer/api/application_record.rb
+- app/views/layouts/blazer/api/application.html.erb
 - config/routes.rb
-- lib/blazer_json_api.rb
-- lib/blazer_json_api/config.rb
-- lib/blazer_json_api/engine.rb
-- lib/blazer_json_api/process_statement_variables.rb
-- lib/blazer_json_api/result_to_nested_json.rb
-- lib/blazer_json_api/version.rb
+- lib/blazer/api/config.rb
+- lib/blazer/api/engine.rb
+- lib/blazer/api/process_statement_variables.rb
+- lib/blazer/api/result_to_nested_json.rb
+- lib/blazer/api/version.rb
+- lib/blazer/json_api.rb
 - lib/tasks/blazer_json_api_tasks.rake
 homepage: https://github.com/johnmfarrell1/blazer_json_api
 licenses:
@@ -93,7 +93,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"

data/app/controllers/blazer_json_api/application_controller.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module BlazerJsonApi
-  class ApplicationController < ActionController::Base
-    protect_from_forgery with: :exception
-
-    def record_not_found
-      render json: [], status: :not_found
-    end
-
-    def render_errors(error_messages)
-      render json: { errors: error_messages }, status: :bad_request
-    end
-  end
-end

data/app/controllers/blazer_json_api/queries_controller.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module BlazerJsonApi
-  class QueriesController < ApplicationController
-    if BlazerJsonAPI::Config.username && BlazerJsonAPI::Config.password
-      http_basic_authenticate_with name: BlazerJsonAPI::Config.username, password: BlazerJsonAPI::Config.password
-    end
-    before_action :set_query
-
-    def show
-      @statement = @query.statement
-      data_source = @query.data_source
-      process_variables(@statement, data_source)
-      result = Blazer.data_sources[data_source].run_statement(@statement)
-
-      if result.error.present?
-        render_errors(Array(result.error))
-      else
-        render json: BlazerJsonAPI::ResultToNestedJson.new(@statement, result).call
-      end
-    end
-
-    private
-
-    def set_query
-      @query = Blazer::Query.find_by(id: params[:id].to_s.split('-').first)
-      record_not_found && return if @query.blank?
-    end
-
-    def process_variables(statement, data_source)
-      BlazerJsonAPI::ProcessStatementVariables.new(statement, data_source, params).call
-    end
-  end
-end

data/app/helpers/blazer_json_api/application_helper.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module BlazerJsonApi
-  module ApplicationHelper
-  end
-end

data/app/jobs/blazer_json_api/application_job.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module BlazerJsonApi
-  class ApplicationJob < ActiveJob::Base
-  end
-end

data/app/mailers/blazer_json_api/application_mailer.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module BlazerJsonApi
-  class ApplicationMailer < ActionMailer::Base
-    default from: 'from@example.com'
-    layout 'mailer'
-  end
-end

data/app/models/blazer_json_api/application_record.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module BlazerJsonApi
-  class ApplicationRecord < ActiveRecord::Base
-    self.abstract_class = true
-  end
-end

data/app/views/layouts/blazer_json_api/application.html.erb

@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Blazer json api</title>
-  <%= stylesheet_link_tag    "blazer_json_api/application", media: "all" %>
-  <%= javascript_include_tag "blazer_json_api/application" %>
-  <%= csrf_meta_tags %>
-</head>
-<body>
-
-<%= yield %>
-
-</body>
-</html>

data/lib/blazer_json_api/config.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module BlazerJsonAPI
-  class Config
-    # defaults
-    @@nesting_column_separator = '__'
-
-    cattr_accessor :username
-    cattr_accessor :password
-    cattr_accessor :nesting_column_separator
-  end
-end

data/lib/blazer_json_api/engine.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module BlazerJsonAPI
-  class Engine < ::Rails::Engine
-    isolate_namespace BlazerJsonAPI
-  end
-end

data/lib/blazer_json_api/process_statement_variables.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-# Taken from: https://github.com/ankane/blazer/blob/ac7e02e0fe19ee6c0bc8c7f3ba87be0d260f8255/app/controllers/blazer/base_controller.rb#L35
-# Necessary for processing any query variables safely
-# Refactored to avoid rubocop breaches
-module BlazerJsonAPI
-  class ProcessStatementVariables
-    attr_reader :statement, :data_source, :params
-
-    def initialize(statement, data_source, params)
-      @statement = statement
-      @data_source = data_source
-      @params = params
-    end
-
-    def call
-      return unless bind_variables.all? { |v| params[v] }
-
-      bind_variables.each do |variable|
-        value = params[variable].presence
-        if value
-          if variable.end_with?('_at')
-            begin
-              value = Blazer.time_zone.parse(value)
-            rescue StandardError
-              # do nothing
-            end
-          end
-
-          if /\A\d+\z/.match?(value.to_s)
-            value = value.to_i
-          elsif /\A\d+\.\d+\z/.match?(value.to_s)
-            value = value.to_f
-          end
-        end
-        if Blazer.transform_variable
-          value = Blazer.transform_variable.call(variable, value)
-      end
-        statement.gsub!("{#{variable}}", ActiveRecord::Base.connection.quote(value))
-      end
-    end
-
-    private
-
-    def bind_variables
-      @bind_variables ||=
-        begin
-          (bind_variables ||= []).concat(Blazer.extract_vars(statement)).uniq!
-          bind_variables.each do |variable|
-            params[variable] ||= Blazer.data_sources[data_source].variable_defaults[variable]
-          end
-        end
-    end
-  end
-end

data/lib/blazer_json_api/result_to_nested_json.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-# Converts a blazer query result table into nested JSON
-# Used the convention of a double underscore in the column header to denote a parent key or nesting
-# e.g. { 'parent__child': '1' } becomes { 'parent': { 'child': 1 }}
-module BlazerJsonAPI
-  class ResultToNestedJson
-    delegate :nesting_column_separator, to: BlazerJsonAPI::Config
-
-    attr_reader :statement, :blazer_result
-
-    def initialize(statement, blazer_result)
-      @statement = statement
-      @blazer_result = blazer_result
-    end
-
-    def call
-      transformed_result =
-        blazer_result_to_json(blazer_result).each do |hash|
-          hash.keys.select { |key| key =~ /#{nesting_column_separator}/ }.each do |namespaced_key|
-            nested_keys = namespaced_key.to_s.split(nesting_column_separator)
-            hash.deep_merge!(deep_hash_set(*nested_keys[0..nested_keys.size], hash[namespaced_key]))
-            hash.delete(namespaced_key)
-          end
-        end
-      collection_or_single_record(transformed_result)
-    end
-
-    private
-
-    def blazer_result_to_json(blazer_result)
-      blazer_result.rows.map do |row|
-        row_hash = {}
-        row.each_with_index do |value, value_index|
-          row_hash[blazer_result.columns[value_index]] = value
-        end
-        row_hash
-      end
-    end
-
-    # recursively sets a nested key in a hash (like the opposite to Hash.dig)
-    # e.g. deep_hash_set(*['a', 'b' , 'c'], 4)
-    # { a => { b => { c => 4 } } }
-    # @return Hash
-    def deep_hash_set(*keys, value)
-      keys.empty? ? value : { keys.first => deep_hash_set(*keys.drop(1), value) }
-    end
-
-    # Use the presence of LIMIT 1 in the query to decide whether to render
-    # a collection response (like an index)
-    # or a single entry response
-    def collection_or_single_record(result)
-      /LIMIT 1$/i.match?(statement) ? result.first : result
-    end
-  end
-end

data/lib/blazer_json_api/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module BlazerJsonAPI
-  VERSION = '0.1.1d'
-end

data/lib/blazer_json_api.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'blazer_json_api/engine'
-require 'blazer_json_api/config'
-require 'blazer_json_api/process_statement_variables'
-require 'blazer_json_api/result_to_nested_json'
-
-module BlazerJsonAPI
-end