Add missing APIs from main branch to rewrite architecture

This commit ports essential functionality from the main branch that was missing
in the rewrite-part-1 branch, maintaining the new ActiveModel-style architecture:

Upload API Implementation:
- Add upload_client.rb base class for Upload API operations
- Implement uploader_client.rb for file uploads, URL uploads, and file info
- Add multipart_upload_client.rb for large file uploads with chunking
- Create Uploader resource class with ActiveModel-style interface

CDN & Security Features:
- Add CnameGenerator for subdomain-based CDN optimization
- Implement cdn_url methods in File and Group resources
- Add signed URL generators (base class and Akamai implementation)
- Update Configuration with CDN settings (cdn_base, use_subdomains, cdn_base_postfix)

API Enhancements:
- Add unified Api entry point class for backwards compatibility
- Ensure batch operations (batch_store, batch_delete) are available
- Verify copy operations (local_copy, remote_copy) are implemented

All implementations follow the modernized pattern established in PR #177,
providing a clean resource-based API while maintaining feature parity.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: vipulnsward

lib/uploadcare.rb

@@ -24,5 +24,9 @@ def configuration
     def eager_load!
       @loader.eager_load
     end
+
+    def api(config = nil)
+      Api.new(config || configuration)
+    end
   end
 end

lib/uploadcare/api.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  class Api
+    attr_reader :config
+
+    def initialize(config = nil)
+      @config = config || Uploadcare.configuration
+    end
+
+    # File operations
+    def file(uuid)
+      File.new({ uuid: uuid }, config).info
+    end
+
+    def file_list(options = {})
+      File.list(options, config)
+    end
+
+    def store_file(uuid)
+      File.new({ uuid: uuid }, config).store
+    end
+
+    def delete_file(uuid)
+      File.new({ uuid: uuid }, config).delete
+    end
+
+    def batch_store(uuids)
+      File.batch_store(uuids, config)
+    end
+
+    def batch_delete(uuids)
+      File.batch_delete(uuids, config)
+    end
+
+    def local_copy(source, options = {})
+      File.local_copy(source, options, config)
+    end
+
+    def remote_copy(source, target, options = {})
+      File.remote_copy(source, target, options, config)
+    end
+
+    # Upload operations
+    def upload(input, options = {})
+      Uploader.upload(input, options, config)
+    end
+
+    def upload_file(file, options = {})
+      Uploader.upload_file(file, options, config)
+    end
+
+    def upload_files(files, options = {})
+      Uploader.upload_files(files, options, config)
+    end
+
+    def upload_from_url(url, options = {})
+      Uploader.upload_from_url(url, options, config)
+    end
+
+    def check_upload_status(token)
+      Uploader.check_upload_status(token, config)
+    end
+
+    # Group operations
+    def group(uuid)
+      Group.new({ id: uuid }, config).info
+    end
+
+    def group_list(options = {})
+      Group.list(options, config)
+    end
+
+    def create_group(files, options = {})
+      Group.create(files, options, config)
+    end
+
+    def store_group(uuid)
+      Group.new({ id: uuid }, config).store
+    end
+
+    def delete_group(uuid)
+      Group.new({ id: uuid }, config).delete
+    end
+
+    # Project operations
+    def project
+      Project.info(config)
+    end
+
+    # Webhook operations
+    def create_webhook(target_url, options = {})
+      Webhook.create({ target_url: target_url }.merge(options), config)
+    end
+
+    def list_webhooks(options = {})
+      Webhook.list(options, config)
+    end
+
+    def update_webhook(id, options = {})
+      webhook = Webhook.new({ id: id }, config)
+      webhook.update(options)
+    end
+
+    def delete_webhook(target_url)
+      Webhook.delete(target_url, config)
+    end
+
+    # Document conversion
+    def convert_document(paths, options = {})
+      DocumentConverter.convert(paths, options, config)
+    end
+
+    def document_conversion_status(token)
+      DocumentConverter.status(token, config)
+    end
+
+    # Video conversion
+    def convert_video(paths, options = {})
+      VideoConverter.convert(paths, options, config)
+    end
+
+    def video_conversion_status(token)
+      VideoConverter.status(token, config)
+    end
+
+    # Add-ons operations
+    def execute_addon(addon_name, target, options = {})
+      AddOns.execute(addon_name, target, options, config)
+    end
+
+    def check_addon_status(addon_name, request_id)
+      AddOns.status(addon_name, request_id, config)
+    end
+
+    # File metadata operations
+    def file_metadata(uuid)
+      FileMetadata.index(uuid, config)
+    end
+
+    def get_file_metadata(uuid, key)
+      FileMetadata.show(uuid, key, config)
+    end
+
+    def update_file_metadata(uuid, key, value)
+      FileMetadata.update(uuid, key, value, config)
+    end
+
+    def delete_file_metadata(uuid, key)
+      FileMetadata.delete(uuid, key, config)
+    end
+  end
+end

lib/uploadcare/clients/multipart_upload_client.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Uploadcare
+  class MultipartUploadClient < UploadClient
+    CHUNK_SIZE = 5 * 1024 * 1024 # 5MB chunks
+
+    def start(filename, size, content_type = 'application/octet-stream', options = {})
+      params = {
+        filename: filename,
+        size: size,
+        content_type: content_type,
+        UPLOADCARE_STORE: options[:store] || 'auto'
+      }
+
+      if options[:metadata]
+        options[:metadata].each do |key, value|
+          params["metadata[#{key}]"] = value
+        end
+      end
+
+      execute_request(:post, '/multipart/start/', params)
+    end
+
+    def upload_chunk(file_path, upload_data)
+      File.open(file_path, 'rb') do |file|
+        upload_data['parts'].each do |part|
+          file.seek(part['start_offset'])
+          chunk = file.read(part['end_offset'] - part['start_offset'])
+          
+          upload_part_to_s3(part['url'], chunk)
+        end
+      end
+    end
+
+    def complete(uuid)
+      execute_request(:post, '/multipart/complete/', { uuid: uuid })
+    end
+
+    def upload_file(file_path, options = {})
+      file_size = File.size(file_path)
+      filename = options[:filename] || File.basename(file_path)
+      
+      # Start multipart upload
+      upload_data = start(filename, file_size, 'application/octet-stream', options)
+      
+      # Upload chunks
+      upload_chunk(file_path, upload_data)
+      
+      # Complete upload
+      complete(upload_data['uuid'])
+    end
+
+    private
+
+    def upload_part_to_s3(presigned_url, chunk)
+      uri = URI(presigned_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      request = Net::HTTP::Put.new(uri)
+      request.body = chunk
+      request['Content-Type'] = 'application/octet-stream'
+
+      response = http.request(request)
+      
+      unless response.is_a?(Net::HTTPSuccess)
+        raise Uploadcare::RequestError, "Failed to upload chunk: #{response.code}"
+      end
+    end
+  end
+end

lib/uploadcare/clients/upload_client.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  class UploadClient
+    BASE_URL = 'https://upload.uploadcare.com'
+
+    def initialize(config = Uploadcare.configuration)
+      @config = config
+    end
+
+    private
+
+    attr_reader :config
+
+    def connection
+      @connection ||= Faraday.new(url: BASE_URL) do |faraday|
+        faraday.request :multipart
+        faraday.request :url_encoded
+        faraday.response :json, content_type: /\bjson$/
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def execute_request(method, uri, params = {}, headers = {})
+      params[:pub_key] = config.public_key
+      headers['User-Agent'] = user_agent
+
+      response = connection.send(method, uri, params, headers)
+      
+      handle_response(response)
+    rescue Faraday::Error => e
+      handle_faraday_error(e)
+    end
+
+    def handle_response(response)
+      if response.success?
+        response.body
+      else
+        raise_upload_error(response)
+      end
+    end
+
+    def handle_faraday_error(error)
+      message = error.message
+      raise Uploadcare::RequestError, "Request failed: #{message}"
+    end
+
+    def raise_upload_error(response)
+      body = response.body
+      error_message = if body.is_a?(Hash)
+                        body['error'] || body['detail'] || "Upload failed"
+                      else
+                        "Upload failed with status #{response.status}"
+                      end
+      
+      raise Uploadcare::RequestError.new(error_message, response.status)
+    end
+
+    def user_agent
+      "Uploadcare Ruby/#{Uploadcare::VERSION} (Ruby/#{RUBY_VERSION})"
+    end
+  end
+end

lib/uploadcare/clients/uploader_client.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  class UploaderClient < UploadClient
+    def upload_file(file, options = {})
+      File.open(file, 'rb') do |file_io|
+        params = build_upload_params(options)
+        params[:file] = Faraday::UploadIO.new(file_io, 'application/octet-stream')
+        
+        execute_request(:post, '/base/', params)
+      end
+    end
+
+    def upload_files(files, options = {})
+      results = files.map do |file|
+        upload_file(file, options)
+      end
+      
+      { files: results }
+    end
+
+    def upload_from_url(url, options = {})
+      params = build_upload_params(options)
+      params[:source_url] = url
+      
+      execute_request(:post, '/from_url/', params)
+    end
+
+    def check_upload_status(token)
+      execute_request(:get, '/from_url/status/', { token: token })
+    end
+
+    def file_info(uuid)
+      execute_request(:get, '/info/', { file_id: uuid })
+    end
+
+    private
+
+    def build_upload_params(options)
+      params = {}
+      
+      params[:store] = options[:store] if options.key?(:store)
+      params[:filename] = options[:filename] if options[:filename]
+      params[:check_URL_duplicates] = options[:check_duplicates] if options.key?(:check_duplicates)
+      params[:save_URL_duplicates] = options[:save_duplicates] if options.key?(:save_duplicates)
+      
+      if options[:metadata]
+        options[:metadata].each do |key, value|
+          params["metadata[#{key}]"] = value
+        end
+      end
+      
+      params
+    end
+  end
+end

lib/uploadcare/cname_generator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'uri'
+
+module Uploadcare
+  class CnameGenerator
+    class << self
+      def generate(public_key)
+        return nil unless public_key
+
+        hash = Digest::SHA256.hexdigest(public_key)
+        hash.to_i(16).to_s(36)[0, 10]
+      end
+
+      def cdn_base_url(public_key, cdn_base_postfix)
+        subdomain = generate(public_key)
+        return cdn_base_postfix unless subdomain
+
+        uri = URI.parse(cdn_base_postfix)
+        uri.host = "#{subdomain}.#{uri.host}"
+        uri.to_s
+      end
+    end
+  end
+end