mongo_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6001ced1910df6e81de93e36b958637d92e4e0cb9edc20ca0afa1ca0ec53fa0f
+  data.tar.gz: c07e8e771d53832530d3acc0f5707e7a3970aeb47aabf95d39c4227c1ce735fb
+SHA512:
+  metadata.gz: d010ddab038f1603c6d55ba7b79cefeceb1998e49b9aaf0821344f5e99872db5b127a69bf369f96281550b4d1f3ba7ec3d30ee12373958f8f2f078ac3809429f
+  data.tar.gz: 01ef197bcd8f69c308e35b53ce898708e10880cdbc4329d21c16fceddcad82a88cec7c34ce25ca06f574bd6c52e538a4a6d8800f5a76f274a207fce67f6f9cae

data/.byebug_history

@@ -0,0 +1,18 @@
+c
+response
+c
+Users.all
+Users.body
+c
+Users.body
+c
+Users.all
+c
+Users.base_url
+.base_url
+Users
+c
+Users.base_url
+Users.all
+Users
+ENV['MONGO_DATABASE_NAME']

data/.env

@@ -0,0 +1,5 @@
+MONGO_ATLAS_API_URL='https://sa-east-1.aws.data.mongodb-api.com/app/data-ixudq/endpoint/data/v1'
+MONGO_ATLAS_API_KEY='y2XeNaFtEH2PtFFvJtHS1v9ZnvzaR6r8vUwdPNhWTgGvJfa9XzxFjlVaVAH6aw3z'
+MONGO_DATABASE_NAME='mongo_api'
+MONGO_COLLECTION_NAME='users'
+MONGO_DATASOURCE_NAME='ojeda'

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 3.2.0
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-08-05
+
+- Initial release

data/Gemfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in mongo_api.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "service_client", "~> 0.1.10"
+
+group :development, :test do
+  gem "byebug", "~> 11.0"
+  gem "dotenv", "~> 2.7"
+  gem "rubocop", "~> 1.21"
+end

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: .
+  specs:
+    mongo_api (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    byebug (11.1.3)
+    diff-lcs (1.5.0)
+    dotenv (2.8.1)
+    httparty (0.21.0)
+      mini_mime (>= 1.0.0)
+      multi_xml (>= 0.5.2)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    mini_mime (1.1.2)
+    multi_xml (0.6.0)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.1)
+    rexml (3.2.6)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.55.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    ruby-progressbar (1.13.0)
+    service_client (0.1.10)
+      httparty (~> 0.21.0)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  byebug (~> 11.0)
+  dotenv (~> 2.7)
+  mongo_api!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+  service_client (~> 0.1.10)
+
+BUNDLED WITH
+   2.4.12

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Alef Ojeda de Oliveira
+
+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,46 @@
+# MongoApi
+
+The gem 'mongo_api' is a simple wrapper around the MongoDb Atlas Data API to make it easier to use in Ruby applications to access data in MongoDb Atlas.
+
+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/mongo_api`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add mongo_api
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install mongo_api
+
+## Usage
+
+The gem is a simple wrapper around the MongoDb Atlas Data API to make it easier to use in Ruby applications to access data in MongoDb Atlas.
+
+### Example
+
+```ruby
+require 'mongo_api'
+
+class Users < MongoApi::Base
+    base_url ENV['MONGO_ATLAS_API_URL']
+  default_headers 'Content-Type': 'application/json',
+                  'api-key': ENV['MONGO_ATLAS_API_KEY'],
+                  'Access-Control-Request-Headers': '*'
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. 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]/mongo_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,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/mongo_api/base.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "mongo_api/request"
+
+module MongoApi
+  # MongoApi::Base is a class to help you to create a REST API using MongoDB Atlas Data API.
+  class Base < Request
+    # This method is used to find all documents
+    # Example: Mongo::Atlas::Api::Base.all(limit: 100, sort: { _id: 1 })
+    #
+    # @param [Integer] limit
+    # @param [Hash] sort
+    # @return [Array|ServiceClient::Response] the documents array or the response
+    def self.all(limit: 100, sort: { _id: 1 })
+      parse_response { find(limit:, sort:) }
+    end
+
+    # This method is used to select documents by filter
+    # Example: Mongo::Atlas::Api::Base.select(filter: { name: 'John' }, limit: 100, sort: { _id: 1 })
+    #
+    # @param [Hash] filter
+    # @param [Integer] limit
+    # @param [Hash] sort
+    # @return [Array|ServiceClient::Response] the documents array or the response
+    def self.select(filter:, limit: 100, sort: { _id: 1 })
+      parse_response { find(filter:, limit:, sort:) }
+    end
+
+    # This method is used to insert one document
+    # Example: Mongo::Atlas::Api::Base.insert(document)
+    #
+    # @param [Hash] document
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.insert(document)
+      parse_response { insert_one(document) }
+    end
+
+    # This method is used to insert many documents
+    # Example: Mongo::Atlas::Api::Base.insert_all(documents)
+    #
+    # @param [Array] documents
+    # @return [Array|ServiceClient::Response] the documents array or the response
+    def self.insert_all(documents)
+      parse_response { insert_many(documents) }
+    end
+
+    # This method is used to delete one document
+    # Example: Mongo::Atlas::Api::Base.destroy(where: { name: 'John' })
+    #
+    # @param [Hash] where
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.destroy(where: {})
+      parse_response { delete_one(filter: where) }
+    end
+
+    # This method is used to delete many documents
+    # Example: Mongo::Atlas::Api::Base.destroy_all(where: { name: 'John' })
+    #
+    # @param [Hash] where
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.destroy_all(where: {})
+      parse_response { delete_many(filter: where) }
+    end
+
+    # This method is used to update one document
+    # Example: Mongo::Atlas::Api::Base.update(where: { name: 'John' }, set: { name: 'John Doe' })
+    #
+    # @param [Hash] where
+    # @param [Hash] set
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.update(where: {}, set: {})
+      parse_response { update_one(filter: where, update: { '$set': set }) }
+    end
+
+    # This method is used to update many documents
+    # Example: Mongo::Atlas::Api::Base.update_all(where: { name: 'John' }, set: { name: 'John Doe' })
+    #
+    # @param [Hash] where
+    # @param [Hash] set
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.update_all(where: {}, set: {})
+      parse_response { update_many(filter: where, update: { '$set': set }) }
+    end
+
+    # This method is used to count documents
+    # Example: Mongo::Atlas::Api::Base.count
+    #
+    # @return [Integer|ServiceClient::Response] the documents count or the response
+    def self.size
+      count
+    end
+
+    class << self
+      def body
+        {
+          database: ENV["MONGO_DATABASE_NAME"],
+          collection: ENV["MONGO_COLLECTION_NAME"],
+          dataSource: ENV["MONGO_DATASOURCE_NAME"]
+        }
+      end
+    end
+  end
+end

data/lib/mongo_api/request.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "service_client/base"
+
+# This class is used to make requests to the cluster mongo-atlas
+module MongoApi
+  # This class is used to make requests to the cluster mongo-atlas
+  class Request < ServiceClient::Base
+    # This method is used to find one document
+    # Example: Mongo::Atlas::Api::Request.find_one(projection: { _id: 0 })
+    #
+    # @param [Hash] filter
+    # @param [Hash] projection
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.find_one(filter: {}, projection: {})
+      data = body.merge(projection:, filter:)
+      response = post("action/findOne", body: data.to_json)
+
+      response.data
+    rescue StandardError => e
+      e.response
+    end
+
+    # This method is used to find many documents
+    # Example: Mongo::Atlas::Api::Request
+    # .find(limit: 20, filter: { name: 'John' }, sort: { name: 1 }, projection: { _id: 0 }, skip: 0)
+    #
+    # @param [Integer] limit
+    # @param [Hash] filter
+    # @param [Hash] sort
+    # @param [Hash] projection
+    # @param [Integer] skip
+    # @return [Array|ServiceClient::Response] the documents array or the response
+    def self.find(limit: 20, filter: {}, sort: {}, projection: {}, skip: 0)
+      data = body.merge(limit:, filter:, sort:, skip:, projection:)
+      response = post("action/find", body: data.to_json)
+
+      response.data
+    rescue StandardError => e
+      e.response
+    end
+
+    # This method is used to insert one document
+    # Example: Mongo::Atlas::Api::Request.insert_one({ name: 'John', email: 'user@teste.com' })
+    #
+    # @param [Hash] document
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.insert_one(document, url: "action/insertOne")
+      data = url.eql?("action/insertOne") ? body.merge(document:) : body.merge(documents: document)
+
+      response = post(url, body: data.to_json)
+
+      response.data
+    rescue StandardError => e
+      e.response
+    end
+
+    # This method is used to insert many documents
+    # Example: Mongo::Atlas::Api::Request.insert_many([{ name: 'John', email: 'user@teste.com' }, ...])
+    #
+    # @param [Array] documents
+    # @return [Array|ServiceClient::Response] the documents array or the response
+    def self.insert_many(documents)
+      documents.each_slice(1000).map do |documents_slice|
+        insert_one(documents_slice, url: "action/insertMany")
+      end
+    end
+
+    # This method is used to update one document
+    # Example: Mongo::Atlas::Api::Request.update_one(filter: { name: 'John' }, update: { $set: { name: 'John Doe' } })
+    # @param [Hash] filter
+    # @param [Hash] update
+    # @param [Boolean] upsert
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.update_one(filter: {}, update: {}, upsert: false)
+      data = body.merge(filter:, update:, upsert:)
+      response = post("action/updateOne", body: data.to_json)
+
+      response.data
+    rescue StandardError => e
+      e.response
+    end
+
+    # This method is used to update many documents
+    # Example: Mongo::Atlas::Api::Request.update_many(filter: { name: 'John' }, update: { $set: { name: 'John Doe' } })
+    #
+    # @param [Hash] filter
+    # @param [Hash] update
+    # @param [Boolean] upsert
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.update_many(filter: {}, update: {}, upsert: false)
+      data = body.merge(filter:, update:, upsert:)
+      response = post("action/updateMany", body: data.to_json)
+
+      response.data
+    rescue StandardError => e
+      e.response
+    end
+
+    # This method is used to replace one document
+    # Example: Mongo::Atlas::Api::Request.replace_one(filter: { name: 'John' }, replacement: { name: 'John Doe' })
+    #
+    # @param [Hash] filter
+    # @param [Hash] replacement
+    # @param [Boolean] upsert
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.replace_one(filter: {}, replacement: {}, upsert: false)
+      data = body.merge(filter:, replacement:, upsert:)
+      response = post("action/replaceOne", body: data.to_json)
+
+      response.data
+    rescue StandardError => e
+      e.response
+    end
+
+    # This method is used to delete one document
+    # Example: Mongo::Atlas::Api::Request.delete_one(filter: { name: 'John' })
+    #
+    # @param [Hash] filter
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.delete_one(filter: {})
+      data = body.merge(filter:)
+      response = post("action/deleteOne", body: data.to_json)
+
+      response.data
+    rescue StandardError => e
+      e.response
+    end
+
+    # This method is used to delete many documents
+    # Example: Mongo::Atlas::Api::Request.delete_many(filter: { name: 'John' })
+    #
+    # @param [Hash] filter
+    # @return [Hash|ServiceClient::Response] the document hash or the response
+    def self.delete_many(filter: {})
+      data = body.merge(filter:)
+      response = post("action/deleteMany", body: data.to_json)
+
+      response.data
+    rescue StandardError => e
+      e.response
+    end
+
+    # This method is used to aggregate documents
+    # Example: Mongo::Atlas::Api::Request.aggregate(pipeline: [{ '$match': { name: 'John' } }])
+    #
+    # @param [Array] pipeline
+    # @return [Array|ServiceClient::Response] the documents array or the response
+    def self.aggregate(pipeline: [])
+      data = body.merge(pipeline:)
+      response = post("action/aggregate", body: data.to_json)
+
+      response.data
+    rescue StandardError => e
+      e.response
+    end
+
+    # This method is used to count documents
+    # Example: Mongo::Atlas::Api::Request.count
+    #
+    # @return [Integer|ServiceClient::Response] the documents count or the response
+    def self.count
+      pipeline = [
+        { '$group': { _id: nil, count: { '$sum': 1 } } },
+        { '$project': { _id: 0 } }
+      ].freeze
+
+      response = aggregate(pipeline:)
+
+      response["documents"].first["count"]
+    rescue StandardError => e
+      e.response
+    end
+
+    class << self
+      private
+
+      def parse_response(&block)
+        data = block.call
+
+        case data
+        when ServiceClient::Response
+          { code: data.code, error: data.data }
+        when Hash
+          data["documents"] || data
+        end
+      end
+    end
+  end
+end

data/lib/mongo_api/version.rb

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

data/lib/mongo_api.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "mongo_api/version"
+require_relative "mongo_api/request"
+require_relative "mongo_api/base"

data/sig/mongo_api.rbs

@@ -0,0 +1,4 @@
+module MongoApi
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: mongo_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alef Ojeda de Oliveira
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-08-06 00:00:00.000000000 Z
+dependencies: []
+description: Use this gem to create a REST API using MongoDB Atlas Data API.
+email:
+- alef.oliveira@dimensa.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".byebug_history"
+- ".env"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mongo_api.rb
+- lib/mongo_api/base.rb
+- lib/mongo_api/request.rb
+- lib/mongo_api/version.rb
+- sig/mongo_api.rbs
+homepage: https://github.com/nemuba/mongo_api
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nemuba/mongo_api
+  source_code_uri: https://github.com/nemuba/mongo_api/tree/main
+  changelog_uri: https://github.com/nemuba/mongo_api/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.12
+signing_key: 
+specification_version: 4
+summary: MongoApi is a gem to help you to create a REST API using MongoDB Atlas Data
+  API.
+test_files: []