autorender 0.1.0

data/lib/autorender/resources/folders.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Autorender
+  module Resources
+    # Folder management endpoints (API key required)
+    class Folders
+      # Create folder
+      #
+      # @overload create(name:, parent_folder_no: nil, request_options: {})
+      #
+      # @param name [String] Folder name without slashes
+      #
+      # @param parent_folder_no [String] Parent folder number
+      #
+      # @param request_options [Autorender::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Autorender::Models::FolderCreateResponse]
+      #
+      # @see Autorender::Models::FolderCreateParams
+      def create(params)
+        parsed, options = Autorender::FolderCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "api/v1/folders",
+          body: parsed,
+          model: Autorender::Models::FolderCreateResponse,
+          options: options
+        )
+      end
+
+      # List folders
+      #
+      # @overload list(parent_folder_no: nil, search: nil, sort: nil, request_options: {})
+      #
+      # @param parent_folder_no [String] Filter by parent folder number
+      #
+      # @param search [String] Partial name match (case-insensitive)
+      #
+      # @param sort [Symbol, Autorender::Models::FolderListParams::Sort]
+      #
+      # @param request_options [Autorender::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Autorender::Models::FolderListResponse]
+      #
+      # @see Autorender::Models::FolderListParams
+      def list(params = {})
+        parsed, options = Autorender::FolderListParams.dump_request(params)
+        query = Autorender::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "api/v1/folders",
+          query: query,
+          model: Autorender::Models::FolderListResponse,
+          options: options
+        )
+      end
+
+      # Delete folder
+      #
+      # @overload delete(folder_no, request_options: {})
+      #
+      # @param folder_no [String]
+      # @param request_options [Autorender::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see Autorender::Models::FolderDeleteParams
+      def delete(folder_no, params = {})
+        @client.request(
+          method: :delete,
+          path: ["api/v1/folders/%1$s", folder_no],
+          model: NilClass,
+          options: params[:request_options]
+        )
+      end
+
+      # Rename folder
+      #
+      # @overload rename(folder_no, name:, request_options: {})
+      #
+      # @param folder_no [String]
+      #
+      # @param name [String] New folder name without slashes
+      #
+      # @param request_options [Autorender::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Autorender::Models::FolderRenameResponse]
+      #
+      # @see Autorender::Models::FolderRenameParams
+      def rename(folder_no, params)
+        parsed, options = Autorender::FolderRenameParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["api/v1/folders/rename/%1$s", folder_no],
+          body: parsed,
+          model: Autorender::Models::FolderRenameResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Autorender::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/autorender/resources/multipart_uploads.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Autorender
+  module Resources
+    # Upload endpoints (API key required)
+    class MultipartUploads
+      # Finalise a multipart upload session and return the stored file record.
+      #
+      # @overload complete(session_id:, uuid: nil, request_options: {})
+      #
+      # @param session_id [String]
+      # @param uuid [String]
+      # @param request_options [Autorender::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Autorender::Models::MultipartUploadCompleteResponse]
+      #
+      # @see Autorender::Models::MultipartUploadCompleteParams
+      def complete(params)
+        parsed, options = Autorender::MultipartUploadCompleteParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "api/v1/multipart/complete",
+          body: parsed,
+          model: Autorender::Models::MultipartUploadCompleteResponse,
+          options: options
+        )
+      end
+
+      # Initialise a multipart upload session and receive pre-signed part URLs.
+      #
+      # @overload start(file_name:, format_:, size:, custom_id: nil, folder: nil, metadata: nil, random_prefix: nil, tags: nil, ttl_seconds: nil, request_options: {})
+      #
+      # @param file_name [String]
+      # @param format_ [String]
+      # @param size [Integer]
+      # @param custom_id [String]
+      # @param folder [String]
+      # @param metadata [Hash{Symbol=>Object}]
+      # @param random_prefix [Boolean]
+      # @param tags [Array<String>, String]
+      # @param ttl_seconds [Integer]
+      # @param request_options [Autorender::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Autorender::Models::MultipartUploadStartResponse]
+      #
+      # @see Autorender::Models::MultipartUploadStartParams
+      def start(params)
+        parsed, options = Autorender::MultipartUploadStartParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "api/v1/multipart/start",
+          body: parsed,
+          model: Autorender::Models::MultipartUploadStartResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Autorender::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/autorender/resources/uploads.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Autorender
+  module Resources
+    # Upload endpoints (API key required)
+    class Uploads
+      # Upload a file from your backend server using multipart/form-data.
+      #
+      # @overload create(file:, file_name:, custom_id: nil, folder: nil, metadata: nil, random_prefix: nil, tags: nil, transform: nil, webhook_url: nil, request_options: {})
+      #
+      # @param file [Pathname, StringIO, IO, String, Autorender::FilePart] File to upload.
+      #
+      # @param file_name [String] File name (e.g. product.jpg)
+      #
+      # @param custom_id [String] Custom identifier
+      #
+      # @param folder [String] Optional folder path
+      #
+      # @param metadata [String] JSON string of metadata
+      #
+      # @param random_prefix [String] true/false to append random suffix
+      #
+      # @param tags [String] Comma-separated tags
+      #
+      # @param transform [String] Transform string (w_300,h_300,c_crop,...)
+      #
+      # @param webhook_url [String] URL to notify on success
+      #
+      # @param request_options [Autorender::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Autorender::Models::UploadCreateResponse]
+      #
+      # @see Autorender::Models::UploadCreateParams
+      def create(params)
+        parsed, options = Autorender::UploadCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "api/v1/uploads",
+          headers: {"content-type" => "multipart/form-data"},
+          body: parsed,
+          model: Autorender::Models::UploadCreateResponse,
+          options: options
+        )
+      end
+
+      # Download a file from a remote URL and store it in AutoRender.
+      #
+      # @overload create_from_url(remote_url:, custom_id: nil, file_name: nil, folder: nil, metadata: nil, random_prefix: nil, tags: nil, webhook_url: nil, request_options: {})
+      #
+      # @param remote_url [String] HTTP/HTTPS URL to fetch
+      #
+      # @param custom_id [String]
+      #
+      # @param file_name [String] Override file name
+      #
+      # @param folder [String] Destination folder path
+      #
+      # @param metadata [String] JSON string of metadata object
+      #
+      # @param random_prefix [String] true/false to append random suffix
+      #
+      # @param tags [String] Comma-separated tags
+      #
+      # @param webhook_url [String]
+      #
+      # @param request_options [Autorender::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Autorender::Models::UploadCreateFromURLResponse]
+      #
+      # @see Autorender::Models::UploadCreateFromURLParams
+      def create_from_url(params)
+        parsed, options = Autorender::UploadCreateFromURLParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "api/v1/uploads/remote",
+          body: parsed,
+          model: Autorender::Models::UploadCreateFromURLResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Autorender::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/autorender/version.rb

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

data/lib/autorender.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Standard libraries.
+# rubocop:disable Lint/RedundantRequireStatement
+require "English"
+require "base64"
+require "cgi"
+require "date"
+require "erb"
+require "etc"
+require "json"
+require "net/http"
+require "openssl"
+require "pathname"
+require "rbconfig"
+require "securerandom"
+require "set"
+require "stringio"
+require "time"
+require "uri"
+# rubocop:enable Lint/RedundantRequireStatement
+
+# We already ship the preferred sorbet manifests in the package itself.
+# `tapioca` currently does not offer us a way to opt out of unnecessary compilation.
+if Object.const_defined?(:Tapioca) &&
+   caller.chain([$PROGRAM_NAME]).chain(ARGV).any?(/tapioca/) &&
+   ARGV.none?(/dsl/)
+  return
+end
+
+# Gems.
+require "connection_pool"
+
+# Package files.
+require_relative "autorender/version"
+require_relative "autorender/internal/util"
+require_relative "autorender/internal/type/converter"
+require_relative "autorender/internal/type/unknown"
+require_relative "autorender/internal/type/boolean"
+require_relative "autorender/internal/type/file_input"
+require_relative "autorender/internal/type/enum"
+require_relative "autorender/internal/type/union"
+require_relative "autorender/internal/type/array_of"
+require_relative "autorender/internal/type/hash_of"
+require_relative "autorender/internal/type/base_model"
+require_relative "autorender/internal/type/base_page"
+require_relative "autorender/internal/type/request_parameters"
+require_relative "autorender/internal"
+require_relative "autorender/request_options"
+require_relative "autorender/file_part"
+require_relative "autorender/errors"
+require_relative "autorender/internal/transport/base_client"
+require_relative "autorender/internal/transport/pooled_net_requester"
+require_relative "autorender/client"
+require_relative "autorender/internal/page_pagination"
+require_relative "autorender/models/file_delete_params"
+require_relative "autorender/models/file_list_params"
+require_relative "autorender/models/file_list_response"
+require_relative "autorender/models/file_rename_params"
+require_relative "autorender/models/file_rename_response"
+require_relative "autorender/models/file_retrieve_params"
+require_relative "autorender/models/file_retrieve_response"
+require_relative "autorender/models/folder_create_params"
+require_relative "autorender/models/folder_create_response"
+require_relative "autorender/models/folder_delete_params"
+require_relative "autorender/models/folder_list_params"
+require_relative "autorender/models/folder_list_response"
+require_relative "autorender/models/folder_rename_params"
+require_relative "autorender/models/folder_rename_response"
+require_relative "autorender/models/multipart_upload_complete_params"
+require_relative "autorender/models/multipart_upload_complete_response"
+require_relative "autorender/models/multipart_upload_start_params"
+require_relative "autorender/models/multipart_upload_start_response"
+require_relative "autorender/models/upload_create_from_url_params"
+require_relative "autorender/models/upload_create_from_url_response"
+require_relative "autorender/models/upload_create_params"
+require_relative "autorender/models/upload_create_response"
+require_relative "autorender/models"
+require_relative "autorender/resources/files"
+require_relative "autorender/resources/folders"
+require_relative "autorender/resources/multipart_uploads"
+require_relative "autorender/resources/uploads"

data/manifest.yaml

@@ -0,0 +1,17 @@
+dependencies:
+  - English
+  - base64
+  - cgi
+  - date
+  - erb
+  - etc
+  - json
+  - net/http
+  - openssl
+  - pathname
+  - rbconfig
+  - securerandom
+  - set
+  - stringio
+  - time
+  - uri

data/rbi/autorender/client.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Autorender
+  class Client < Autorender::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES = 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS = T.let(60.0, Float)
+
+    DEFAULT_INITIAL_RETRY_DELAY = T.let(0.5, Float)
+
+    DEFAULT_MAX_RETRY_DELAY = T.let(8.0, Float)
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :api_key
+
+    # Upload endpoints (API key required)
+    sig { returns(Autorender::Resources::Uploads) }
+    attr_reader :uploads
+
+    # File management endpoints (API key required)
+    sig { returns(Autorender::Resources::Files) }
+    attr_reader :files
+
+    # Folder management endpoints (API key required)
+    sig { returns(Autorender::Resources::Folders) }
+    attr_reader :folders
+
+    # Upload endpoints (API key required)
+    sig { returns(Autorender::Resources::MultipartUploads) }
+    attr_reader :multipart_uploads
+
+    # @api private
+    sig { override.returns(T::Hash[String, String]) }
+    private def auth_headers
+    end
+
+    # Creates and returns a new client for interacting with the API.
+    sig do
+      params(
+        api_key: T.nilable(String),
+        base_url: T.nilable(String),
+        max_retries: Integer,
+        timeout: Float,
+        initial_retry_delay: Float,
+        max_retry_delay: Float
+      ).returns(T.attached_class)
+    end
+    def self.new(
+      # Defaults to `ENV["AUTORENDER_API_KEY"]`
+      api_key: ENV["AUTORENDER_API_KEY"],
+      # Override the default base URL for the API, e.g.,
+      # `"https://api.example.com/v2/"`. Defaults to `ENV["AUTORENDER_BASE_URL"]`
+      base_url: ENV["AUTORENDER_BASE_URL"],
+      # Max number of retries to attempt after a failed retryable request.
+      max_retries: Autorender::Client::DEFAULT_MAX_RETRIES,
+      timeout: Autorender::Client::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: Autorender::Client::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: Autorender::Client::DEFAULT_MAX_RETRY_DELAY
+    )
+    end
+  end
+end

data/rbi/autorender/errors.rbi

@@ -0,0 +1,205 @@
+# typed: strong
+
+module Autorender
+  module Errors
+    class Error < StandardError
+      sig { returns(T.nilable(StandardError)) }
+      attr_accessor :cause
+    end
+
+    class ConversionError < Autorender::Errors::Error
+      sig { returns(T.nilable(StandardError)) }
+      def cause
+      end
+
+      # @api private
+      sig do
+        params(
+          on: T::Class[StandardError],
+          method: Symbol,
+          target: T.anything,
+          value: T.anything,
+          cause: T.nilable(StandardError)
+        ).returns(T.attached_class)
+      end
+      def self.new(on:, method:, target:, value:, cause: nil)
+      end
+    end
+
+    class APIError < Autorender::Errors::Error
+      sig { returns(URI::Generic) }
+      attr_accessor :url
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :status
+
+      sig { returns(T.nilable(T::Hash[String, String])) }
+      attr_accessor :headers
+
+      sig { returns(T.nilable(T.anything)) }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: T.nilable(Integer),
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: nil
+      )
+      end
+    end
+
+    class APIConnectionError < Autorender::Errors::APIError
+      sig { returns(NilClass) }
+      attr_accessor :status
+
+      sig { returns(NilClass) }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          headers: T.nilable(T::Hash[String, String]),
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Connection error."
+      )
+      end
+    end
+
+    class APITimeoutError < Autorender::Errors::APIConnectionError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          headers: T.nilable(T::Hash[String, String]),
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Request timed out."
+      )
+      end
+    end
+
+    class APIStatusError < Autorender::Errors::APIError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.for(
+        url:,
+        status:,
+        headers:,
+        body:,
+        request:,
+        response:,
+        message: nil
+      )
+      end
+
+      sig { returns(Integer) }
+      attr_accessor :status
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status:,
+        headers:,
+        body:,
+        request:,
+        response:,
+        message: nil
+      )
+      end
+    end
+
+    class BadRequestError < Autorender::Errors::APIStatusError
+      HTTP_STATUS = 400
+    end
+
+    class AuthenticationError < Autorender::Errors::APIStatusError
+      HTTP_STATUS = 401
+    end
+
+    class PermissionDeniedError < Autorender::Errors::APIStatusError
+      HTTP_STATUS = 403
+    end
+
+    class NotFoundError < Autorender::Errors::APIStatusError
+      HTTP_STATUS = 404
+    end
+
+    class ConflictError < Autorender::Errors::APIStatusError
+      HTTP_STATUS = 409
+    end
+
+    class UnprocessableEntityError < Autorender::Errors::APIStatusError
+      HTTP_STATUS = 422
+    end
+
+    class RateLimitError < Autorender::Errors::APIStatusError
+      HTTP_STATUS = 429
+    end
+
+    class InternalServerError < Autorender::Errors::APIStatusError
+      HTTP_STATUS = T.let((500..), T::Range[Integer])
+    end
+  end
+end

data/rbi/autorender/file_part.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Autorender
+  class FilePart
+    sig { returns(T.any(Pathname, StringIO, IO, String)) }
+    attr_reader :content
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :content_type
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :filename
+
+    # @api private
+    sig { returns(String) }
+    private def read
+    end
+
+    sig { params(a: T.anything).returns(String) }
+    def to_json(*a)
+    end
+
+    sig { params(a: T.anything).returns(String) }
+    def to_yaml(*a)
+    end
+
+    sig do
+      params(
+        content: T.any(Pathname, StringIO, IO, String),
+        filename: T.nilable(T.any(Pathname, String)),
+        content_type: T.nilable(String)
+      ).returns(T.attached_class)
+    end
+    def self.new(content, filename: nil, content_type: nil)
+    end
+  end
+end