any_query 0.1.1

data/lib/any_query/query.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module AnyQuery
+  # @api private
+  class Query
+    include Enumerable
+
+    delegate_missing_to :to_a
+
+    def initialize(model, adapter)
+      @model = model
+      @adapter = adapter
+    end
+
+    def joins(model, primary_key, foreign_key, into:, as: :single, strategy: :default)
+      dup.joins!(model, primary_key, foreign_key, into:, as:, strategy:)
+    end
+
+    def with_single
+      dup.joins!(:show, :id, :id, into: :single, as: :single, strategy: :single)
+    end
+
+    def where(options)
+      dup.where!(options)
+    end
+
+    def select(*args)
+      dup.select!(*args)
+    end
+
+    def limit(limit)
+      dup.limit!(limit)
+    end
+
+    def find(id)
+      @adapter.load_single(@model, id, [])
+    end
+
+    def to_a
+      @adapter.load(@model, select: @select, joins: @joins, where: @where, limit: @limit)
+    end
+
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    def joins!(model, primary_key, foreign_key, into:, as: :single, strategy: :default)
+      @joins ||= []
+      @joins << ({ model:, primary_key:, foreign_key:, into:, as:, strategy: })
+      self
+    end
+
+    def select!(*args)
+      @select ||= []
+      @select += args
+      self
+    end
+
+    def where!(options)
+      @where ||= []
+      @where << options
+      self
+    end
+
+    def limit!(limit)
+      @limit = limit
+      self
+    end
+  end
+end

data/lib/any_query/version.rb

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

data/lib/any_query.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'active_support/all'
+require 'active_record'
+require 'active_model'
+
+# AnyQuery is a library to help you build queries for different data sources
+module AnyQuery
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+
+  autoload :Config
+  autoload :Adapters
+  autoload :Query
+
+  included do
+    delegate_missing_to :@attributes
+  end
+
+  def initialize
+    @attributes = OpenStruct.new
+  end
+
+  module ClassMethods
+    def adapter(name, &block)
+      config = "AnyQuery::Adapters::#{name.to_s.classify}::Config".constantize.new(&block)
+      @adapter = "AnyQuery::Adapters::#{name.to_s.classify}".constantize.new(config)
+    end
+
+    delegate_missing_to :all
+
+    # @return [AnyQuery::Adapters::Base]
+    def _adapter
+      @adapter
+    end
+
+    # @param [Symbol] name
+    # @param [Hash] options
+    # @option options [Symbol] :type
+    # @option options [String] :format
+    # @option options [Integer] :length
+    # @option options [Proc] :transform
+    def field(name, options = {})
+      fields[name] = options
+    end
+
+    # @return [Hash]
+    def fields
+      @fields ||= {}
+    end
+
+    # @return [AnyQuery::Query]
+    def all
+      Query.new(self, @adapter)
+    end
+  end
+end

data/spec/any_query/csv_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ArticleCSV do
+  it 'returns records' do
+    expect(described_class.all.to_a).to have(2).items
+  end
+
+  it 'can be finded' do
+    result = described_class.find(2)
+    expect(result.id).to eq(2)
+    expect(result.user_id).to eq(1)
+    expect(result.title).to eq('the article 2')
+    expect(result.body).to eq('this is the body of your article 2')
+    expect(result.status).to eq(2)
+    expect(result.created_at).to eq('2023-03-10T18:28:02Z'.to_datetime)
+  end
+
+  it 'can be filtered' do
+    expect(described_class.where(status: 1).to_a).to have(1).items
+  end
+
+  it 'can be limited' do
+    expect(described_class.limit(1).to_a).to have(1).items
+  end
+
+  it 'can be joined' do
+    expect do
+      described_class.joins(UserSQL, :id, :user_id, into: :user).to_a.first
+    end.to match_query(/SELECT "users".* FROM "users"/)
+  end
+
+  it 'can be selected with nested selectors' do
+    results = described_class
+              .joins(UserSQL, :id, :user_id, into: :user, as: :single)
+              .select(:id, :title, %i[user email])
+              .to_a
+
+    expect(results).to eq(
+      [[1, 'the article', 'test@test.com'], [2, 'the article 2', 'test@test.com']]
+    )
+  end
+end

data/spec/any_query/fixed_length_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ArticleFL do
+  it 'returns records' do
+    expect(described_class.all.to_a).to have(2).items
+  end
+
+  it 'can be finded' do
+    result = described_class.find(2)
+    expect(result.id).to eq(2)
+    expect(result.user_id).to eq(1)
+    expect(result.title).to eq('this is another sample')
+    expect(result.body).to eq('this is an example of a body for an article that is very long and dirty')
+    expect(result.status).to eq(2)
+    expect(result.created_at).to eq('2023-12-31T19:00:00Z'.to_datetime)
+  end
+
+  it 'can be filtered' do
+    expect(described_class.where(status: 1).to_a).to have(1).items
+  end
+
+  it 'can be limited' do
+    expect(described_class.limit(1).to_a).to have(1).items
+  end
+
+  it 'can be joined' do
+    expect do
+      described_class.joins(UserSQL, :id, :user_id, into: :user).to_a.first
+    end.to match_query(/SELECT "users".* FROM "users"/)
+  end
+
+  it 'can be selected with nested selectors' do
+    results = described_class
+              .joins(UserSQL, :id, :user_id, into: :user, as: :single)
+              .select(:id, :title, %i[user email])
+              .to_a
+
+    expect(results).to eq(
+      [
+        [1, 'this is a sample', 'test@test.com'],
+        [2, 'this is another sample', 'test@test.com']
+      ]
+    )
+  end
+end

data/spec/any_query/http_spec.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ArticleHTTP do
+  before do
+    stub_request(:get, 'http://example.com/articles?page=0&some_query_param=1')
+      .to_return(
+        headers: { content_type: 'application/json' },
+        body: JSON.dump(
+          {
+            items: [
+              {
+                id: 1,
+                user_id: 1,
+                name: 'some article'
+              },
+              {
+                id: 2,
+                user_id: 1,
+                name: 'some article 2'
+              }
+            ]
+          }
+        )
+      )
+
+    stub_request(:get, 'http://example.com/articles?page=1&some_query_param=1')
+      .to_return(
+        headers: { content_type: 'application/json' },
+        body: '{ "items": [] }'
+      )
+  end
+
+  it 'returns records' do
+    expect(described_class.all.to_a).to have(2).items
+  end
+
+  it 'can be finded' do
+    stub_request(:get, 'http://example.com/articles/1')
+      .to_return(
+        headers: { content_type: 'application/json' },
+        body: JSON.dump(
+          {
+            id: 1,
+            user_id: 1,
+            title: 'some article'
+          }
+        )
+      )
+    result = described_class.find(1)
+    expect(result.id).to eq(1)
+    expect(result.user_id).to eq(1)
+    expect(result.title).to eq('some article')
+  end
+
+  it 'can be filtered' do
+    stub_request(:get, 'http://example.com/articles?page=0&some_query_param=1&status=1')
+      .to_return(
+        headers: { content_type: 'application/json' },
+        body: JSON.dump(
+          {
+            items: [
+              {
+                id: 1,
+                name: 'some article'
+              }
+            ]
+          }
+        )
+      )
+    stub_request(:get, 'http://example.com/articles?page=1&some_query_param=1&status=1')
+      .to_return(
+        headers: { content_type: 'application/json' },
+        body: '{ "items": [] }'
+      )
+
+    expect(described_class.where(status: 1).to_a).to have(1).items
+  end
+
+  it 'can be limited' do
+    expect(described_class.limit(1).to_a).to have(1).items
+  end
+
+  it 'can be joined with SQL' do
+    described_class.joins(UserSQL, :id, :user_id, into: :user).to_a.first
+  end
+
+  it 'can be joined with itself using the show endpoint' do
+    stub_request(:get, 'http://example.com/articles/1')
+      .to_return(
+        headers: { content_type: 'application/json' },
+        body: JSON.dump(
+          {
+            id: 1,
+            user_id: 1,
+            title: 'some article',
+            some_additional_field: 'some value'
+          }
+        )
+      )
+
+    stub_request(:get, 'http://example.com/articles/2')
+      .to_return(
+        headers: { content_type: 'application/json' },
+        body: JSON.dump(
+          {
+            id: 2,
+            user_id: 1,
+            title: 'some article 2',
+            some_additional_field: 'some value'
+          }
+        )
+      )
+
+    result = described_class.with_single.to_a.first
+    expect(result.some_additional_field).to eq('some value')
+  end
+
+  it 'can be joined with HTTP(s)' do
+    stub_request(:get, 'http://example.com/users?id%5B%5D=1&some_query_param=true')
+      .to_return(
+        headers: { content_type: 'application/json' },
+        body: JSON.dump(
+          items: [
+            { "id": 1, "email": 'gianni@gianni.com' }
+          ],
+          cursor: '123123123'
+        )
+      )
+
+    stub_request(:get, 'http://example.com/users?id%5B%5D=1&some_query_param=true&cursor=123123123')
+      .to_return(
+        headers: { content_type: 'application/json' },
+        body: JSON.dump(
+          items: [],
+          cursor: '123123123'
+        )
+      )
+
+    result = described_class.joins(UserHTTP, :id, :user_id, into: :user).to_a.first
+    expect(result.user.email).to eq('gianni@gianni.com')
+  end
+
+  it 'can be selected with nested selectors' do
+    results = described_class
+              .joins(UserSQL, :id, :user_id, into: :user, as: :single)
+              .select(:id, :title, %i[user email])
+              .to_a
+
+    expect(results).to have(2).items
+    expect(results[0]).to have(3).items
+  end
+
+  context 'with url params' do
+    it 'can be filtered using query params' do
+      stub_request(:get, 'http://example.com/1/users')
+      ScopedUserHTTP.where(company_id: 1).to_a
+    end
+  end
+end

data/spec/any_query/sql_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ArticleSQL do
+  before do
+    ActiveRecord::Base.connection.execute('INSERT INTO articles VALUES (1, 1, "Title 1", "Body 1", 1, "2021-01-01 00:00:00", "2021-01-01 00:00:00")')
+    ActiveRecord::Base.connection.execute('INSERT INTO articles VALUES (2, 1, "Title 2", "Body 2", 2, "2021-01-01 00:00:00", "2021-01-01 00:00:00")')
+  end
+
+  it 'returns records' do
+    expect(described_class.all.to_a).to have(2).items
+  end
+
+  it 'can be finded' do
+    result = described_class.find(2)
+    expect(result.id).to eq(2)
+    expect(result.user_id).to eq(1)
+    expect(result.title).to eq('Title 2')
+    expect(result.body).to eq('Body 2')
+    expect(result.status).to eq(2)
+    expect(result.created_at).to eq('2021-01-01 00:00:00 UTC'.to_datetime)
+  end
+
+  it 'can be filtered' do
+    expect(described_class.where(status: 1).to_a).to have(1).items
+  end
+
+  it 'can be limited' do
+    expect(described_class.limit(1).to_a).to have(1).items
+  end
+
+  it 'can be joined' do
+    expect do
+      described_class.joins(UserSQL, :id, :user_id, into: :user).to_a.first
+    end.to match_query(/ LEFT OUTER JOIN "users"/)
+  end
+
+  it 'can be joined on many' do
+    ActiveRecord::Base.connection.execute('INSERT INTO comments VALUES (1, 1, "content")')
+    ActiveRecord::Base.connection.execute('INSERT INTO comments VALUES (2, 1, "content2")')
+
+    expect do
+      result = described_class.joins(CommentSQL, :id, :article_id, into: :comments, as: :list).to_a.first
+      expect(result.comments).to have(2).items
+    end.to match_query(/ LEFT OUTER JOIN "comments" ON "comments"/)
+  end
+
+  it 'can be selected with nested selectors' do
+    results = described_class
+              .joins(UserSQL, :id, :user_id, into: :user, as: :single)
+              .select(:id, :title, %i[user email])
+              .to_a
+
+    expect(results).to have(2).items
+    expect(results[0]).to have(3).items
+  end
+end

data/spec/fixtures/sample.csv

@@ -0,0 +1,3 @@
+id,user_id,title,body,status,created_at
+1,1,the article,this is the body of your article,1,2022-12-03 10:28:02
+2,1,the article 2,this is the body of your article 2,2,2023-03-10 18:28:02

data/spec/fixtures/sample.txt

@@ -0,0 +1,2 @@
+00010001this is a sample              this is an example of a body for an article that is very long                                       120220101103822
+00020001this is another sample        this is an example of a body for an article that is very long and dirty                             220231231190000

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+# require 'rails'
+# require 'action_controller/railtie'
+# require 'action_mailer/railtie'
+# require 'action_view/railtie'
+# require 'rspec/rails'
+# require 'cancancan'
+# require 'active_model_serializers'
+require 'any_query'
+require 'rspec/collection_matchers'
+require 'rspec/sql_matcher'
+require 'webmock/rspec'
+
+# I18n.enforce_available_locales = false
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false
+
+# Rails.application.config.eager_load = false
+# Rails.application.config.active_record.legacy_connection_handling = false
+
+Dir[File.expand_path('support/*.rb', __dir__)].each { |f| require f }
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    Schema.create
+  end
+
+  config.around(:each) do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end

data/spec/support/schema.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+# @example
+class ArticleSQL
+  include AnyQuery
+
+  adapter :sql do
+    url 'sqlite3::memory:'
+    primary_key :id
+    table 'articles'
+  end
+end
+
+# @example
+class UserSQL
+  include AnyQuery
+
+  adapter :sql do
+    url 'sqlite3::memory:'
+    primary_key :id
+    table 'users'
+  end
+end
+
+# @example
+class CommentSQL
+  include AnyQuery
+
+  adapter :sql do
+    url 'sqlite3::memory:'
+    primary_key :id
+    table 'comments'
+  end
+end
+
+class ArticleHTTP
+  include AnyQuery
+
+  adapter :http do
+    url 'http://example.com'
+    primary_key :id
+    endpoint :list, :get, "/articles",
+    wrapper: [:items],
+    pagination: { type: :page },
+    default_params: {
+      query: { some_query_param: 1 },
+      headers: { 'Authorization': 'some' }
+    }
+    endpoint :show, :get, "/articles/{id}"
+  end
+end
+
+class UserHTTP
+  include AnyQuery
+
+  adapter :http do
+    url 'http://example.com'
+    primary_key :id
+    endpoint :list, :get, "/users",
+    wrapper: [:items],
+    pagination: { type: :cursor },
+    default_params: {
+      query: { some_query_param: true },
+      headers: { 'Authorization': 'some' }
+    }
+    endpoint :show, :get, "/users/{id}"
+  end
+end
+
+class ScopedUserHTTP
+  include AnyQuery
+
+  adapter :http do
+    url 'http://example.com'
+    primary_key :id
+    endpoint :list, :get, "/{company_id}/users",
+    wrapper: [:items],
+    pagination: { type: :none },
+    default_params: {
+      headers: { 'Authorization': 'some' }
+    }
+    endpoint :show, :get, "/{company_id}/users/{id}"
+  end
+end
+
+class ArticleCSV
+  include AnyQuery
+
+  adapter :csv do
+    url File.join(__dir__, '../fixtures/sample.csv')
+    primary_key :id
+  end
+
+  field :id, type: :integer
+  field :user_id, type: :integer
+  field :title, type: :string
+  field :body, type: :string
+  field :status, type: :integer
+  field :created_at, type: :datetime, format: '%Y-%m-%d %H:%M:%S'
+end
+
+class ArticleFL
+  include AnyQuery
+
+  adapter :fixed_length do
+    url File.join(__dir__, '../fixtures/sample.txt')
+    primary_key :id
+  end
+
+  field :id, type: :integer, length: 4
+  field :user_id, type: :integer, length: 4
+  field :title, type: :string, length: 30
+  field :body, type: :string, length: 100
+  field :status, type: :integer, length: 1
+  field :created_at, type: :datetime, format: '%Y%m%d%H%M%S', length: 14
+end
+
+module Schema
+  def self.create
+    ActiveRecord::Migration.verbose = false
+
+    ActiveRecord::Schema.define do
+      create_table :users, force: true do |t|
+        t.string   :email
+        t.timestamps null: false
+      end
+
+      create_table :articles, force: true do |t|
+        t.integer  :user_id
+        t.string   :title
+        t.text     :body
+        t.integer   :status
+        t.timestamps null: false
+      end
+
+      create_table :comments, force: true do |t|
+        t.integer  :article_id
+        t.text     :body
+      end
+
+      ActiveRecord::Base.connection.execute("INSERT INTO users VALUES (1, 'test@test.com', '2021-01-01 00:00:00', '2021-01-01 00:00:00')")
+    end
+  end
+end