squarecloud-unofficial 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0d8f21e29130213fd94e5300d77e9740f833b2f2f6e0dc07cc14fe9c8c4efa79
+  data.tar.gz: a6225e8763e621119e145b247babb0b0fac2bef624a0e7421c9d2d90d60944e4
+SHA512:
+  metadata.gz: 4f237a9df7cad30cc37e33740646037036a97b7dfbb3b5020c2e6e43dd2aa0f2553ffe1d40ba2bf2197fb61ec6fb1e1df2d2c7759e90e6b4fa9c573fd5209af3
+  data.tar.gz: d4915b72e9df155421fe161237bb777ebb1e5c7714927c915fc05ec5e308fad5d297546ec297616215aa31300e3d3cea49ddcfe89889f997d511b947e9677188

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Júlia Klee
+
+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,169 @@
+# Square Cloud Ruby SDK (Unofficial)
+
+An unofficial Ruby SDK for the [Square Cloud](https://squarecloud.app/) API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'squarecloud-unofficial'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install squarecloud-unofficial
+```
+
+## Getting API Key
+
+To get your API key/token, go to the [Square Cloud](https://squarecloud.app) website and register/login. 
+After that, navigate to `dashboard` > `my account` > `Regenerate API/CLI KEY` and copy the key.
+
+## Usage
+
+### Authentication
+
+To use the SDK, you need to authenticate with your API key from the Square Cloud dashboard.
+
+```ruby
+require 'squarecloud'
+
+# Initialize the client with your API key
+client = Squarecloud::Client.new(api_key: 'YOUR_API_KEY')
+```
+
+### User Information
+
+```ruby
+# Get user information
+user = client.user
+puts "User: #{user.name}"
+puts "Plan: #{user.plan.name}"
+```
+
+### Application Management
+
+```ruby
+# List all applications
+apps = client.all_apps
+apps.each do |app|
+  puts "#{app.name} (#{app.id})"
+end
+
+# Get a specific application by ID
+app = client.app('APP_ID')
+
+# Get application status
+status = app.status
+puts "Running: #{status.running}"
+puts "CPU: #{status.cpu}"
+puts "RAM: #{status.ram}"
+
+# Get application logs
+logs = app.logs
+puts logs.logs
+
+# Start, stop, and restart an application
+app.start
+app.stop
+app.restart
+
+# Delete an application
+app.delete
+```
+
+### File Operations
+
+```ruby
+# List files in a directory
+files = app.files_list('/')
+files.each do |file|
+  puts "#{file.name} (#{file.type}, #{file.size} bytes)"
+end
+
+# Read a file's content
+content = app.read_file('/path/to/file')
+
+# Create a new file
+new_file = Squarecloud::File.new('local_file.txt', 'text/plain')
+app.create_file(new_file, '/path/in/app.txt')
+
+# Move a file
+app.move_file('/old/path.txt', '/new/path.txt')
+
+# Delete a file
+app.delete_file('/path/to/file.txt')
+```
+
+### Backups
+
+```ruby
+# Create a backup
+backup = app.backup
+puts "Backup URL: #{backup.url}"
+
+# List all backups
+backups = app.all_backups
+backups.each do |backup|
+  puts "#{backup.name} (#{backup.size} bytes)"
+end
+
+# Download a backup
+backup.download('./backups/')
+```
+
+### Domain Management
+
+```ruby
+# Set a custom domain
+app.set_custom_domain('example.com')
+
+# Get domain analytics
+analytics = app.domain_analytics
+visits = analytics.domain.analytics.total.first.visits
+puts "Total visits: #{visits}"
+
+# Get DNS records
+records = app.dns_records
+records.each do |record|
+  puts "#{record.type} #{record.name} #{record.value}"
+end
+```
+
+### GitHub Integration
+
+```ruby
+# Set up GitHub integration
+app.create_github_integration('GITHUB_TOKEN')
+
+# Get current integration
+integration = app.current_integration
+puts "Current integration: #{integration}"
+```
+
+## Examples
+
+For more examples, check the `examples/` directory in this repository:
+
+- `examples/client_example.rb` - Basic usage of the client
+- `examples/file_operations.rb` - Examples of file operations
+
+## Disclaimer
+
+This is an **unofficial** SDK not affiliated with or endorsed by Square Cloud. This project was created to provide Ruby developers with an easy way to interact with the Square Cloud API.
+
+## Contributing
+
+Feel free to contribute with suggestions or bug reports at our GitHub repository.
+
+## License
+
+This SDK is available as open source under the terms of the MIT License.

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "squarecloud"
+
+require "irb"
+IRB.start(__FILE__) 

data/lib/squarecloud/application.rb

@@ -0,0 +1,146 @@
+module Squarecloud
+  class File
+    attr_reader :path, :mime_type, :filename
+    
+    def initialize(path, mime_type = 'application/zip')
+      @path = path
+      @mime_type = mime_type
+      @filename = ::File.basename(path)
+    end
+  end
+  
+  class Application
+    attr_reader :id, :name, :cluster, :ram, :language, :domain, :custom, :desc
+    
+    def initialize(http:, data:)
+      @http = http
+      
+      if data.is_a?(Hash)
+        @id = data[:id]
+        @name = data[:name]
+        @cluster = data[:cluster]
+        @ram = data[:ram]
+        @language = data[:language]
+        @domain = data[:domain]
+        @custom = data[:custom]
+        @desc = data[:desc]
+      else
+        
+        
+        @id = nil
+      end
+    end
+    
+    def status
+      response = @http.fetch_app_status(@id)
+      StatusData.new(response)
+    end
+    
+    def logs
+      response = @http.fetch_logs(@id)
+      LogsData.new(response)
+    end
+    
+    def start
+      @http.start_application(@id)
+      true
+    end
+    
+    def stop
+      @http.stop_application(@id)
+      true
+    end
+    
+    def restart
+      @http.restart_application(@id)
+      true
+    end
+    
+    def backup
+      response = @http.backup(@id)
+      Backup.new(response)
+    end
+    
+    def delete
+      @http.delete_application(@id)
+      true
+    end
+    
+    def commit(file)
+      @http.commit(@id, file)
+      true
+    end
+    
+    def files_list(path)
+      response = @http.fetch_app_files_list(@id, path)
+      response.map { |file_data| FileInfo.new(@id, file_data) }
+    end
+    
+    def read_file(path)
+      @http.read_app_file(@id, path)
+    end
+    
+    def create_file(file, path)
+      @http.create_app_file(@id, file, path)
+      true
+    end
+    
+    def delete_file(path)
+      @http.file_delete(@id, path)
+      true
+    end
+    
+    def move_file(origin, dest)
+      @http.move_app_file(@id, origin, dest)
+      true
+    end
+    
+    def last_deploys
+      response = @http.get_last_deploys(@id)
+      response.map do |deploy_group|
+        deploy_group.map { |deploy| DeployData.new(deploy) }
+      end
+    end
+    
+    def create_github_integration(access_token)
+      @http.create_github_integration(@id, access_token)
+    end
+    
+    def current_integration
+      @http.get_app_current_integration(@id)
+    end
+    
+    def domain_analytics
+      response = @http.domain_analytics(@id)
+      DomainAnalytics.new(response)
+    end
+    
+    def set_custom_domain(custom_domain)
+      @http.update_custom_domain(@id, custom_domain)
+      true
+    end
+    
+    def all_backups
+      response = @http.get_all_app_backups(@id)
+      response.map { |backup| BackupInfo.new(backup) }
+    end
+    
+    def dns_records
+      response = @http.dns_records(@id)
+      response.map { |record| DNSRecord.new(record) }
+    end
+    
+    def to_h
+      {
+        id: @id,
+        name: @name,
+        cluster: @cluster,
+        ram: @ram,
+        language: @language,
+        domain: @domain,
+        custom: @custom,
+        desc: @desc
+      }
+    end
+  end
+end 

data/lib/squarecloud/http/client.rb

@@ -0,0 +1,274 @@
+module Squarecloud
+  module HTTP
+    class Response
+      attr_reader :data, :route, :status, :code, :message, :response
+      
+      def initialize(data, route)
+        @data = data
+        @route = route
+        @status = data.is_a?(Hash) ? data[:status] : nil
+        @code = data.is_a?(Hash) ? data[:code] : nil
+        @message = data.is_a?(Hash) ? data[:message] : nil
+        @response = data.is_a?(Hash) ? data[:response] : data
+      end
+      
+      def to_s
+        "
+      end
+    end
+    
+    class Client
+      BASE_URL = 'https://api.squarecloud.app/v2'.freeze
+      
+      attr_reader :api_key, :last_response
+      
+      def initialize(api_key:)
+        @api_key = api_key
+        @last_response = nil
+      end
+      
+      def request(endpoint, method: 'GET', params: {}, multipart: false, body: nil)
+        conn = Faraday.new(url: BASE_URL) do |f|
+          f.request :multipart if multipart
+          f.request :json
+          f.response :json, content_type: /\bjson$/
+          f.adapter Faraday.default_adapter
+        end
+        
+        url = endpoint.build_path(params)
+        
+        begin
+          response = conn.send(method.downcase) do |req|
+            req.url url
+            req.headers['Authorization'] = @api_key
+            req.headers['User-Agent'] = "squarecloud-ruby/
+            req.body = body if body
+          end
+          
+          data = response.body
+          extra_error_kwargs = {}
+          
+          
+          if params[:custom_domain]
+            extra_error_kwargs[:domain] = params[:custom_domain]
+          end
+          
+          
+          case response.status
+          when 401
+            raise Squarecloud::AuthenticationFailure.new(
+              route: endpoint.name,
+              status_code: response.status,
+              code: data.is_a?(Hash) ? data[:code] : nil
+            )
+          when 404
+            raise Squarecloud::NotFoundError.new(
+              route: endpoint.name,
+              status_code: response.status,
+              code: data.is_a?(Hash) ? data[:code] : nil
+            )
+          when 400
+            error_code = data.is_a?(Hash) ? data[:code] : nil
+            error_class = get_error(error_code)
+            if error_class
+              raise error_class.new(
+                route: endpoint.name,
+                status_code: response.status,
+                code: error_code,
+                **extra_error_kwargs
+              )
+            else
+              raise Squarecloud::BadRequestError.new(
+                route: endpoint.name,
+                status_code: response.status,
+                code: error_code,
+                message: "Bad request: 
+              )
+            end
+          when 429
+            raise Squarecloud::TooManyRequests.new(
+              route: endpoint.name,
+              status_code: response.status,
+              code: data.is_a?(Hash) ? data[:code] : nil
+            )
+          end
+          
+          
+          @last_response = Response.new(data, endpoint)
+          
+          if @last_response.status == 'error'
+            error_class = get_error(@last_response.code)
+            if error_class
+              raise error_class.new(
+                route: endpoint.name,
+                status_code: response.status,
+                code: @last_response.code,
+                **extra_error_kwargs
+              )
+            else
+              raise Squarecloud::RequestError.new(
+                route: endpoint.name,
+                status_code: response.status,
+                code: @last_response.code,
+                message: "Request error: 
+              )
+            end
+          end
+          
+          @last_response.response
+        rescue Faraday::Error => e
+          
+          raise Squarecloud::RequestError.new(
+            route: endpoint.name,
+            message: "Network error: 
+          )
+        end
+      end
+      
+      def get_error(code)
+        errors = {
+          'FEW_MEMORY' => Squarecloud::FewMemory,
+          'BAD_MEMORY' => Squarecloud::BadMemory,
+          'MISSING_CONFIG' => Squarecloud::MissingConfigFile,
+          'MISSING_DEPENDENCIES_FILE' => Squarecloud::MissingDependenciesFile,
+          'MISSING_MAIN' => Squarecloud::MissingMainFile,
+          'INVALID_MAIN' => Squarecloud::InvalidMain,
+          'INVALID_DISPLAY_NAME' => Squarecloud::InvalidDisplayName,
+          'MISSING_DISPLAY_NAME' => Squarecloud::MissingDisplayName,
+          'INVALID_MEMORY' => Squarecloud::InvalidMemory,
+          'MISSING_MEMORY' => Squarecloud::MissingMemory,
+          'INVALID_VERSION' => Squarecloud::InvalidVersion,
+          'MISSING_VERSION' => Squarecloud::MissingVersion,
+          'INVALID_ACCESS_TOKEN' => Squarecloud::InvalidAccessToken,
+          'REGEX_VALIDATION' => Squarecloud::InvalidDomain,
+          'INVALID_START' => Squarecloud::InvalidStart
+        }
+        
+        errors[code]
+      end
+      
+      def fetch_user_info
+        endpoint = Squarecloud::HTTP::Endpoint.user
+        request(endpoint)
+      end
+      
+      def fetch_app_status(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.app_status
+        request(endpoint, params: { app_id: app_id })
+      end
+      
+      def fetch_logs(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.logs
+        request(endpoint, params: { app_id: app_id })
+      end
+      
+      def start_application(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.start
+        request(endpoint, method: 'POST', params: { app_id: app_id })
+      end
+      
+      def stop_application(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.stop
+        request(endpoint, method: 'POST', params: { app_id: app_id })
+      end
+      
+      def restart_application(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.restart
+        request(endpoint, method: 'POST', params: { app_id: app_id })
+      end
+      
+      def backup(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.backup
+        request(endpoint, method: 'POST', params: { app_id: app_id })
+      end
+      
+      def delete_application(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.delete_app
+        request(endpoint, method: 'DELETE', params: { app_id: app_id })
+      end
+      
+      def commit(app_id, file)
+        endpoint = Squarecloud::HTTP::Endpoint.commit
+        form_data = { file: Faraday::Multipart::FilePart.new(file.path, file.mime_type) }
+        request(endpoint, method: 'POST', params: { app_id: app_id }, multipart: true, body: form_data)
+      end
+      
+      def upload(file)
+        endpoint = Squarecloud::HTTP::Endpoint.upload
+        form_data = { file: Faraday::Multipart::FilePart.new(file.path, file.mime_type) }
+        request(endpoint, method: 'POST', multipart: true, body: form_data)
+      end
+      
+      def fetch_app_files_list(app_id, path)
+        endpoint = Squarecloud::HTTP::Endpoint.files_list
+        request(endpoint, params: { app_id: app_id, path: path })
+      end
+      
+      def read_app_file(app_id, path)
+        endpoint = Squarecloud::HTTP::Endpoint.files_read
+        request(endpoint, params: { app_id: app_id, path: path })
+      end
+      
+      def create_app_file(app_id, file, path)
+        endpoint = Squarecloud::HTTP::Endpoint.files_create
+        form_data = { file: Faraday::Multipart::FilePart.new(file.path, file.mime_type), path: path }
+        request(endpoint, method: 'PUT', params: { app_id: app_id }, multipart: true, body: form_data)
+      end
+      
+      def file_delete(app_id, path)
+        endpoint = Squarecloud::HTTP::Endpoint.files_delete
+        request(endpoint, method: 'DELETE', params: { app_id: app_id, path: path })
+      end
+      
+      def get_app_data(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.app_data
+        request(endpoint, params: { app_id: app_id })
+      end
+      
+      def get_last_deploys(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.last_deploys
+        request(endpoint, params: { app_id: app_id })
+      end
+      
+      def create_github_integration(app_id, github_access_token)
+        endpoint = Squarecloud::HTTP::Endpoint.github_integration
+        request(endpoint, method: 'POST', params: { app_id: app_id }, body: { access_token: github_access_token })
+      end
+      
+      def update_custom_domain(app_id, custom_domain)
+        endpoint = Squarecloud::HTTP::Endpoint.custom_domain
+        request(endpoint, method: 'POST', params: { app_id: app_id, custom_domain: custom_domain }, body: { custom_domain: custom_domain })
+      end
+      
+      def domain_analytics(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.domain_analytics
+        request(endpoint, params: { app_id: app_id })
+      end
+      
+      def get_all_app_backups(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.all_backups
+        request(endpoint, params: { app_id: app_id })
+      end
+      
+      def all_apps_status
+        endpoint = Squarecloud::HTTP::Endpoint.all_apps_status
+        request(endpoint)
+      end
+      
+      def move_app_file(app_id, origin, dest)
+        endpoint = Squarecloud::HTTP::Endpoint.move_file
+        request(endpoint, method: 'PATCH', params: { app_id: app_id }, body: { origin: origin, dest: dest })
+      end
+      
+      def dns_records(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.dns_records
+        request(endpoint, params: { app_id: app_id })
+      end
+      
+      def get_app_current_integration(app_id)
+        endpoint = Squarecloud::HTTP::Endpoint.current_integration
+        request(endpoint, params: { app_id: app_id })
+      end
+    end
+  end
+end