wowsql-sdk 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2f513a4e3b2200161273f4f070b4a03f7ffc87406110a0f4d6b8236bfb46daf3
+  data.tar.gz: 2a5a47b0f6c8702ee2312ce42874d8c81af88a6b2e50573850081bb469959318
+SHA512:
+  metadata.gz: 896e5564f6ee97da1868b69149de1c43781fdeef20e893db433b4c96f026613d4687567d58aaececdd5f4f5a2af63914781f819e1d2ef04c33485628f21fe28f
+  data.tar.gz: 3bda8034b18ace12708ee009d67b940773e893fcffb11884ce6afb24fa563ddee8bff6075d95ad93fbe84cf88be488e1c3af0b86618edfa30d60ba844ba0e40a

data/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 WowSQL
+
+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,554 @@
+# 🚀 WOWSQL Ruby SDK
+
+Official Ruby client for [WOWSQL](https://wowsql.com) - MySQL Backend-as-a-Service with S3 Storage.
+
+[![Gem Version](https://img.shields.io/gem/v/wowsql-sdk.svg)](https://rubygems.org/gems/wowsql-sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## ✨ Features
+
+### Database Features
+- 🗄️ Full CRUD operations (Create, Read, Update, Delete)
+- 🔍 Advanced filtering (eq, neq, gt, gte, lt, lte, like, is_null)
+- 📄 Pagination (limit, offset)
+- 📊 Sorting (order_by)
+- 🎯 Fluent query builder API
+- 📝 Raw SQL queries (read-only)
+- 📋 Table schema introspection
+- 🔒 Built-in error handling
+
+### Storage Features
+- 📦 S3-compatible storage client
+- ⬆️ File upload with automatic quota validation
+- ⬇️ File download (presigned URLs)
+- 📂 File listing with metadata
+- 🗑️ File deletion
+- 📊 Storage quota management
+- 🌍 Multi-region support
+
+## 📦 Installation
+
+### Gemfile
+
+```ruby
+gem 'wowsql-sdk', '~> 1.0'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+### Manual Installation
+
+```bash
+gem install wowsql-sdk
+```
+
+## 🚀 Quick Start
+
+### Database Operations
+
+```ruby
+require 'wowsql'
+
+# Initialize client
+client = WOWSQL::WOWSQLClient.new(
+  'https://your-project.wowsql.com',
+  'your-api-key'  # Get from dashboard
+)
+
+# Select data
+response = client.table('users')
+  .select('id', 'name', 'email')
+  .eq('status', 'active')
+  .limit(10)
+  .get
+
+response['data'].each do |user|
+  puts "#{user['name']} (#{user['email']})"
+end
+
+# Insert data
+new_user = {
+  'name' => 'Jane Doe',
+  'email' => 'jane@example.com',
+  'age' => 25
+}
+
+result = client.table('users').create(new_user)
+puts "Created user with ID: #{result['id']}"
+
+# Update data
+updates = { 'name' => 'Jane Smith' }
+client.table('users').update(result['id'], updates)
+
+# Delete data
+client.table('users').delete(result['id'])
+```
+
+### Storage Operations
+
+```ruby
+require 'wowsql'
+
+# Initialize storage client
+storage = WOWSQL::WOWSQLStorage.new(
+  'your-project-slug',
+  'your-api-key'
+)
+
+# Upload file
+storage.upload_from_path('local-file.pdf', 'uploads/document.pdf', 'documents')
+
+# Get presigned URL
+url_data = storage.get_file_url('uploads/document.pdf', 3600)
+puts "File URL: #{url_data['file_url']}"
+
+# List files
+files = storage.list_files('uploads/')
+files.each do |file|
+  puts "#{file['key']}: #{(file['size'] / 1024.0 / 1024.0).round(2)} MB"
+end
+
+# Delete file
+storage.delete_file('uploads/document.pdf')
+
+# Check storage quota
+quota = storage.get_quota
+puts "Used: #{quota['used_gb']} GB"
+puts "Available: #{quota['available_gb']} GB"
+```
+
+## 📚 Usage Examples
+
+### Select Queries
+
+```ruby
+# Select all columns
+users = client.table('users').select('*').get
+
+# Select specific columns
+users = client.table('users')
+  .select('id', 'name', 'email')
+  .get
+
+# With filters
+active_users = client.table('users')
+  .select('id', 'name', 'email')
+  .eq('status', 'active')
+  .gt('age', 18)
+  .get
+
+# With ordering
+recent_users = client.table('users')
+  .select('*')
+  .order_by('created_at', desc: true)
+  .limit(10)
+  .get
+
+# With pagination
+page1 = client.table('users')
+  .select('*')
+  .limit(20)
+  .offset(0)
+  .get
+
+page2 = client.table('users')
+  .select('*')
+  .limit(20)
+  .offset(20)
+  .get
+
+# Pattern matching
+gmail_users = client.table('users')
+  .select('*')
+  .like('email', '%@gmail.com')
+  .get
+
+# Get single record by ID
+user = client.table('users').get_by_id(123)
+```
+
+### Insert Data
+
+```ruby
+# Insert single record
+new_user = {
+  'name' => 'John Doe',
+  'email' => 'john@example.com',
+  'age' => 30,
+  'status' => 'active'
+}
+
+result = client.table('users').create(new_user)
+puts "New user ID: #{result['id']}"
+```
+
+### Update Data
+
+```ruby
+# Update by ID
+updates = {
+  'name' => 'Jane Smith',
+  'age' => 26
+}
+
+result = client.table('users').update(1, updates)
+puts "Updated #{result['affected_rows']} row(s)"
+```
+
+### Delete Data
+
+```ruby
+# Delete by ID
+result = client.table('users').delete(1)
+puts "Deleted #{result['affected_rows']} row(s)"
+
+# Delete with conditions
+deleted = client.table('users')
+  .eq('status', 'deleted')
+  .delete
+```
+
+### Filter Operators
+
+```ruby
+# Equal
+.eq('status', 'active')
+
+# Not equal
+.neq('status', 'deleted')
+
+# Greater than
+.gt('age', 18)
+
+# Greater than or equal
+.gte('age', 18)
+
+# Less than
+.lt('age', 65)
+
+# Less than or equal
+.lte('age', 65)
+
+# Pattern matching (SQL LIKE)
+.like('email', '%@gmail.com')
+
+# Is null
+.is_null('deleted_at')
+
+# Is not null
+.is_not_null('email')
+```
+
+### Advanced Queries
+
+```ruby
+# Multiple filters with sorting
+active_users = client.table('users')
+  .select('id', 'name', 'email')
+  .eq('status', 'active')
+  .gt('age', 18)
+  .order_by('created_at', desc: true)
+  .limit(20)
+  .get
+
+# Complex filtering
+results = client.table('products')
+  .select('*')
+  .gt('price', 100)
+  .lt('price', 1000)
+  .like('name', '%widget%')
+  .is_not_null('category')
+  .order_by('price', desc: false)  # asc
+  .limit(50)
+  .offset(0)
+  .get
+```
+
+### Storage Operations
+
+```ruby
+storage = WOWSQL::WOWSQLStorage.new(
+  'your-project-slug',
+  'your-api-key'
+)
+
+# Upload file from local path
+storage.upload_from_path(
+  'local-file.pdf',
+  'uploads/document.pdf',
+  'documents'  # bucket/folder
+)
+
+# Check if file exists
+if storage.file_exists?('uploads/document.pdf')
+  puts "File exists!"
+end
+
+# Get file information
+info = storage.get_file_info('uploads/document.pdf')
+puts "Size: #{info['size']} bytes"
+puts "Modified: #{info['last_modified']}"
+
+# List files with prefix
+files = storage.list_files('uploads/2024/')
+files.each do |file|
+  puts "#{file['key']}: #{file['size']} bytes"
+end
+
+# Download file (get presigned URL)
+url_data = storage.get_file_url('uploads/document.pdf', 3600)
+puts "Download URL: #{url_data['file_url']}"
+# URL is valid for 1 hour (3600 seconds)
+
+# Delete single file
+storage.delete_file('uploads/old-file.pdf')
+
+# Delete multiple files
+storage.delete_files([
+  'uploads/file1.pdf',
+  'uploads/file2.pdf',
+  'uploads/file3.pdf'
+])
+
+# Check quota
+quota = storage.get_quota
+puts "Used: #{quota['used_gb'].round(2)} GB"
+puts "Available: #{quota['available_gb'].round(2)} GB"
+puts "Usage: #{quota['usage_percentage'].round(1)}%"
+
+# Check if enough storage before upload
+file_size = File.size('large-file.zip')
+if quota['available_bytes'] < file_size
+  puts "Not enough storage!"
+else
+  storage.upload_from_path('large-file.zip', 'uploads/large-file.zip')
+end
+```
+
+### Error Handling
+
+```ruby
+begin
+  users = client.table('users').select('*').get
+  puts "Success: #{users['data'].count} users"
+rescue WOWSQL::AuthenticationException => e
+  puts "Authentication error: #{e.message}"
+rescue WOWSQL::NotFoundException => e
+  puts "Not found: #{e.message}"
+rescue WOWSQL::RateLimitException => e
+  puts "Rate limit exceeded: #{e.message}"
+rescue WOWSQL::WOWSQLException => e
+  puts "Database error (#{e.status_code}): #{e.message}"
+end
+
+begin
+  storage.upload_from_path('file.pdf', 'uploads/file.pdf')
+rescue WOWSQL::StorageLimitExceededException => e
+  puts "Storage full: #{e.message}"
+  puts "Please upgrade your plan or delete old files"
+rescue WOWSQL::StorageException => e
+  puts "Storage error: #{e.message}"
+end
+```
+
+### Utility Methods
+
+```ruby
+# List all tables
+tables = client.list_tables
+puts "Tables: #{tables.inspect}"
+
+# Get table schema
+schema = client.get_table_schema('users')
+puts "Columns: #{schema['columns'].count}"
+schema['columns'].each do |column|
+  puts "  - #{column['name']} (#{column['type']})"
+end
+
+# Check API health
+health = client.health
+puts "Status: #{health['status']}"
+```
+
+## 🔧 Configuration
+
+### Custom Timeout
+
+```ruby
+# Database client
+client = WOWSQL::WOWSQLClient.new(
+  'https://your-project.wowsql.com',
+  'your-api-key',
+  60  # 60 seconds timeout
+)
+
+# Storage client
+storage = WOWSQL::WOWSQLStorage.new(
+  'your-project-slug',
+  'your-api-key',
+  120  # 2 minutes for large files
+)
+```
+
+### Using Environment Variables
+
+```ruby
+# Best practice: Use environment variables for API keys
+client = WOWSQL::WOWSQLClient.new(
+  ENV['WOWSQL_PROJECT_URL'],
+  ENV['WOWSQL_API_KEY']
+)
+
+storage = WOWSQL::WOWSQLStorage.new(
+  ENV['WOWSQL_PROJECT_URL'],
+  ENV['WOWSQL_API_KEY']
+)
+```
+
+## 🔑 API Keys
+
+WOWSQL uses **different API keys for different operations**. Understanding which key to use is crucial for proper authentication.
+
+### Key Types Overview
+
+| Operation Type | Recommended Key | Alternative Key | Used By |
+|---------------|----------------|-----------------|---------|
+| **Database Operations** (CRUD) | Service Role Key (`wowbase_service_...`) | Anonymous Key (`wowbase_anon_...`) | `WOWSQLClient` |
+| **Storage Operations** | Service Role Key (`wowbase_service_...`) | Anonymous Key (`wowbase_anon_...`) | `WOWSQLStorage` |
+
+### Where to Find Your Keys
+
+All keys are found in: **WOWSQL Dashboard → Authentication → PROJECT KEYS**
+
+1. **Service Role Key** (`wowbase_service_...`)
+   - Location: "Service Role Key (keep secret)"
+   - Used for: Database CRUD operations and storage (recommended for server-side)
+   - **Important**: Click the eye icon to reveal this key
+
+2. **Anonymous Key** (`wowbase_anon_...`)
+   - Location: "Anonymous Key"
+   - Used for: Public/client-side database operations with limited permissions
+   - Optional: Use when exposing database access to frontend/client
+
+### Database Operations
+
+Use **Service Role Key** or **Anonymous Key** for database operations:
+
+```ruby
+# Using Service Role Key (recommended for server-side, full access)
+client = WOWSQL::WOWSQLClient.new(
+  'https://your-project.wowsql.com',
+  'wowbase_service_your-service-key-here'  # Service Role Key
+)
+
+# Using Anonymous Key (for public/client-side access with limited permissions)
+client = WOWSQL::WOWSQLClient.new(
+  'https://your-project.wowsql.com',
+  'wowbase_anon_your-anon-key-here'  # Anonymous Key
+)
+
+# Query data
+users = client.table('users').get
+```
+
+### Security Best Practices
+
+1. **Never expose Service Role Key** in client-side code or public repositories
+2. **Use Anonymous Key** for public database access with limited permissions
+3. **Store keys in environment variables**, never hardcode them
+4. **Rotate keys regularly** if compromised
+
+## 🎨 Framework Integration
+
+### Rails
+
+```ruby
+# config/initializers/wowsql.rb
+WOWSQL_CLIENT = WOWSQL::WOWSQLClient.new(
+  Rails.application.credentials.wowsql[:project_url],
+  Rails.application.credentials.wowsql[:api_key]
+)
+
+# app/models/user.rb
+class User < ApplicationRecord
+  def self.sync_from_wowsql
+    response = WOWSQL_CLIENT.table('users')
+      .select('*')
+      .get
+    
+    response['data'].each do |user_data|
+      User.find_or_create_by(external_id: user_data['id']) do |user|
+        user.name = user_data['name']
+        user.email = user_data['email']
+      end
+    end
+  end
+end
+
+# Usage in Controller
+class UsersController < ApplicationController
+  def index
+    @users = WOWSQL_CLIENT.table('users')
+      .select('id', 'name', 'email')
+      .get['data']
+  end
+end
+```
+
+### Sinatra
+
+```ruby
+require 'sinatra'
+require 'wowsql'
+
+configure do
+  set :wowsql_client, WOWSQL::WOWSQLClient.new(
+    ENV['WOWSQL_PROJECT_URL'],
+    ENV['WOWSQL_API_KEY']
+  )
+end
+
+get '/users' do
+  users = settings.wowsql_client.table('users')
+    .select('id', 'name', 'email')
+    .get['data']
+  
+  content_type :json
+  users.to_json
+end
+```
+
+## 📋 Requirements
+
+- Ruby 2.6.0 or higher
+- Faraday 2.0+
+- JSON 2.0+
+
+## 🔗 Links
+
+- 📚 [Documentation](https://wowsql.com/docs)
+- 🌐 [Website](https://wowsql.com)
+- 💬 [Discord](https://discord.gg/WOWSQL)
+- 🐛 [Issues](https://github.com/wowsql/wowsql/issues)
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## 📞 Support
+
+- Email: support@wowsql.com
+- Discord: https://discord.gg/WOWSQL
+- Documentation: https://wowsql.com/docs
+
+---
+
+Made with ❤️ by the WOWSQL Team

data/lib/wowsql/client.rb

@@ -0,0 +1,84 @@
+require 'faraday'
+require 'json'
+require_relative 'exceptions'
+require_relative 'table'
+
+module WOWSQL
+  # WOWSQL client for interacting with your database via REST API.
+  # 
+  # This client is used for DATABASE OPERATIONS (CRUD on tables).
+  # Use Service Role Key or Anonymous Key for authentication.
+  class WOWSQLClient
+    def initialize(project_url, api_key, timeout = 30)
+      @api_key = api_key
+      @timeout = timeout
+
+      # Build API URL
+      if project_url.start_with?('http://') || project_url.start_with?('https://')
+        base_url = project_url.chomp('/')
+        if base_url.include?('/api')
+          @api_url = base_url.sub('/api', '') + '/api/v2'
+        else
+          @api_url = base_url + '/api/v2'
+        end
+      else
+        @api_url = "https://#{project_url}.wowsql.com/api/v2"
+      end
+
+      @conn = Faraday.new(url: @api_url) do |f|
+        f.request :json
+        f.response :json
+        f.adapter Faraday.default_adapter
+        f.options.timeout = timeout
+      end
+
+      @conn.headers['Authorization'] = "Bearer #{api_key}"
+      @conn.headers['Content-Type'] = 'application/json'
+    end
+
+    # Get a table interface for fluent API.
+    # 
+    # @param table_name [String] Name of the table
+    # @return [Table] Table instance for the specified table
+    def table(table_name)
+      Table.new(self, table_name)
+    end
+
+    # List all tables in the database.
+    # 
+    # @return [Array<String>] List of table names
+    def list_tables
+      response = request('GET', '/tables', nil, nil)
+      response['tables'] || []
+    end
+
+    # Get table schema information.
+    # 
+    # @param table_name [String] Name of the table
+    # @return [Hash] Table schema with columns and primary key
+    def get_table_schema(table_name)
+      request('GET', "/tables/#{table_name}/schema", nil, nil)
+    end
+
+    # Make HTTP request to API.
+    def request(method, path, params = nil, json = nil)
+      begin
+        response = @conn.public_send(method.downcase, path) do |req|
+          req.params = params if params
+          req.body = json if json
+        end
+
+        if response.status >= 400
+          error_data = response.body.is_a?(Hash) ? response.body : {}
+          error_msg = error_data['detail'] || error_data['message'] || "Request failed with status #{response.status}"
+          raise WOWSQLException.new(error_msg, response.status, error_data)
+        end
+
+        response.body
+      rescue Faraday::Error => e
+        raise WOWSQLException.new("Request failed: #{e.message}")
+      end
+    end
+  end
+end
+

data/lib/wowsql/exceptions.rb

@@ -0,0 +1,31 @@
+module WOWSQL
+  # Base exception for WOWSQL SDK errors.
+  class WOWSQLException < StandardError
+    attr_reader :status_code, :response
+
+    def initialize(message, status_code = nil, response = nil)
+      super(message)
+      @status_code = status_code
+      @response = response
+    end
+  end
+
+  # Storage-specific exception.
+  class StorageException < WOWSQLException
+  end
+
+  # Exception raised when storage limit would be exceeded.
+  class StorageLimitExceededException < StorageException
+    def initialize(message, response = nil)
+      super(message, 413, response)
+    end
+  end
+
+  # Exception raised when operation requires service role key but anonymous key was used.
+  class PermissionException < WOWSQLException
+    def initialize(message)
+      super(message, 403)
+    end
+  end
+end
+

data/lib/wowsql/query_builder.rb

@@ -0,0 +1,97 @@
+module WOWSQL
+  # Fluent query builder for constructing database queries.
+  class QueryBuilder
+    def initialize(client, table_name)
+      @client = client
+      @table_name = table_name
+      @params = {}
+    end
+
+    def select(*columns)
+      if columns.length == 1 && columns[0] == '*'
+        @params['select'] = '*'
+      else
+        @params['select'] = columns.join(',')
+      end
+      self
+    end
+
+    def eq(column, value)
+      add_filter(column, 'eq', value)
+      self
+    end
+
+    def neq(column, value)
+      add_filter(column, 'neq', value)
+      self
+    end
+
+    def gt(column, value)
+      add_filter(column, 'gt', value)
+      self
+    end
+
+    def gte(column, value)
+      add_filter(column, 'gte', value)
+      self
+    end
+
+    def lt(column, value)
+      add_filter(column, 'lt', value)
+      self
+    end
+
+    def lte(column, value)
+      add_filter(column, 'lte', value)
+      self
+    end
+
+    def like(column, pattern)
+      add_filter(column, 'like', pattern)
+      self
+    end
+
+    def is_null(column)
+      add_filter(column, 'is', nil)
+      self
+    end
+
+    def order_by(column, desc: false)
+      @params['order'] = column
+      @params['order_direction'] = desc ? 'desc' : 'asc'
+      self
+    end
+
+    def limit(limit)
+      @params['limit'] = limit.to_s
+      self
+    end
+
+    def offset(offset)
+      @params['offset'] = offset.to_s
+      self
+    end
+
+    def get
+      @client.request('GET', "/#{@table_name}", @params, nil)
+    end
+
+    def first
+      result = limit(1).get
+      result['data']&.first
+    end
+
+    private
+
+    def add_filter(column, op, value)
+      filter_value = "#{column}.#{op}.#{value || 'null'}"
+      
+      if @params['filter']
+        @params['filter'] += ",#{filter_value}"
+      else
+        @params['filter'] = filter_value
+      end
+    end
+  end
+end
+

data/lib/wowsql/table.rb

@@ -0,0 +1,60 @@
+require_relative 'query_builder'
+
+module WOWSQL
+  # Table interface for database operations.
+  class Table
+    def initialize(client, table_name)
+      @client = client
+      @table_name = table_name
+    end
+
+    # Start a query with column selection.
+    # 
+    # @param columns [Array<String>] Column(s) to select
+    # @return [QueryBuilder] QueryBuilder for chaining
+    def select(*columns)
+      QueryBuilder.new(@client, @table_name).select(*columns)
+    end
+
+    # Get all records with optional filters.
+    # 
+    # @return [Hash] Query response
+    def get
+      QueryBuilder.new(@client, @table_name).get
+    end
+
+    # Get a single record by ID.
+    # 
+    # @param record_id [Object] Record ID
+    # @return [Hash] Record data
+    def get_by_id(record_id)
+      @client.request('GET', "/#{@table_name}/#{record_id}", nil, nil)
+    end
+
+    # Create a new record.
+    # 
+    # @param data [Hash] Record data
+    # @return [Hash] Create response with new record ID
+    def create(data)
+      @client.request('POST', "/#{@table_name}", nil, data)
+    end
+
+    # Update a record by ID.
+    # 
+    # @param record_id [Object] Record ID
+    # @param data [Hash] Data to update
+    # @return [Hash] Update response
+    def update(record_id, data)
+      @client.request('PATCH', "/#{@table_name}/#{record_id}", nil, data)
+    end
+
+    # Delete a record by ID.
+    # 
+    # @param record_id [Object] Record ID
+    # @return [Hash] Delete response
+    def delete(record_id)
+      @client.request('DELETE', "/#{@table_name}/#{record_id}", nil, nil)
+    end
+  end
+end
+

data/lib/wowsql/version.rb

@@ -0,0 +1,4 @@
+module WOWSQL
+  VERSION = "1.0.0"
+end
+

data/lib/wowsql.rb

@@ -0,0 +1,10 @@
+require_relative 'wowsql/version'
+require_relative 'wowsql/exceptions'
+require_relative 'wowsql/client'
+require_relative 'wowsql/table'
+require_relative 'wowsql/query_builder'
+
+module WOWSQL
+  # Main module for WOWSQL SDK
+end
+

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: wowsql-sdk
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- WOWSQL Team
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Official Ruby client library for WOWSQL - MySQL Backend-as-a-Service
+  with S3 Storage
+email:
+- support@wowsql.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/wowsql.rb
+- lib/wowsql/client.rb
+- lib/wowsql/exceptions.rb
+- lib/wowsql/query_builder.rb
+- lib/wowsql/table.rb
+- lib/wowsql/version.rb
+homepage: https://github.com/wowsql/wowsql-sdk-ruby
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Official Ruby client library for WOWSQL - MySQL Backend-as-a-Service with
+  S3 Storage
+test_files: []