stackshift-assets 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 807ebbf9dcca45f0527128331eacd65c6438581f68aba83fc00ee8353f1436e6
+  data.tar.gz: 801b1dfeb2e91fcd06718a61360d723d181ac7a4b7ef7b121909669273b38345
+SHA512:
+  metadata.gz: 6f54bb7b1538c96213db8d49c56074f3c930edb154db01e181eacfcfc52a9af8883e0ea088dff7e086363155c57e02d54664539d1a6321c0373a8cc0b18101e4
+  data.tar.gz: bf63657edece479337ddd300ed942814a3ae10a1451b704605e50276350ac58c5c684f594ca10b5e692772e8e3932b69f6d8e304259b3fe48d41d88c68048e3c

data/README.md

@@ -0,0 +1,3 @@
+# StackShift Assets for Ruby
+
+Require \`stackshift/assets_client\`. Rails applications can inject the client and use resumable upload sessions for direct uploads. Every mutating call takes the current revision and sends \`If-Match\`.

data/lib/stackshift/assets.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "assets_client"
+require_relative "rails" if defined?(Rails::Railtie)

data/lib/stackshift/assets_client.rb

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+require "net/http"
+require "securerandom"
+require "uri"
+
+module StackShift
+  class AssetsClient
+    def initialize(api_key:, base_url: "https://api.stackshift.cloud/api/v1", cdn_base_url: "https://cdn.stackshift.cloud")
+      raise ArgumentError, "StackShift SDK requires an API key" if api_key.to_s.strip.empty?
+
+      @api_key = api_key
+      @base_url = base_url.sub(%r{/$}, "")
+      @cdn_base_url = cdn_base_url.sub(%r{/$}, "")
+    end
+
+    def list(**filters)
+      request(:get, "/assets", query: compact(filters))
+    end
+
+    def get(asset_id)
+      request(:get, "/assets/#{escape(asset_id)}")
+    end
+
+    def delete(asset_id, revision:, idempotency_key: nil)
+		headers = if_match(revision)
+		headers["Idempotency-Key"] = idempotency_key if idempotency_key
+      request(:delete, "/assets/#{escape(asset_id)}", headers: headers)
+    end
+
+    def upload(file_path, **options)
+      multipart(:post, "/assets/upload", file_path, options)
+    end
+
+    def replace(asset_id, file_path, revision:, **options)
+      multipart(:put, "/assets/#{escape(asset_id)}/replace", file_path, options, headers: if_match(revision))
+    end
+
+    def create_upload_session(idempotency_key: nil, **options)
+      headers = idempotency_key ? { "Idempotency-Key" => idempotency_key } : {}
+      request(:post, "/assets/upload-sessions", body: compact(options), headers: headers)
+    end
+
+    def signed_upload_url(idempotency_key: nil, **options)
+      headers = idempotency_key ? { "Idempotency-Key" => idempotency_key } : {}
+      request(:post, "/assets/upload-url", body: compact(options), headers: headers)
+    end
+
+    def upload_chunk(upload_url_or_token, part_number, bytes)
+      target = if upload_url_or_token.start_with?("http")
+                 upload_url_or_token.sub(%r{/$}, "")
+               else
+                 @base_url.sub(%r{/api/v1$}, "") + "/uploads/#{escape(upload_url_or_token)}"
+               end
+      request_absolute(:put, "#{target}/parts/#{part_number}", body: bytes, json: false, authenticated: false,
+						headers: { "Content-Type" => "application/octet-stream", "X-Content-SHA256" => Digest::SHA256.hexdigest(bytes) })
+    end
+
+    def complete_upload_session(session_id)
+      request(:post, "/assets/upload-sessions/#{escape(session_id)}/complete")
+    end
+
+    def resume_upload_session(session_id)
+      request(:get, "/assets/upload-sessions/#{escape(session_id)}")
+    end
+
+    def cancel_upload_session(session_id)
+      request(:delete, "/assets/upload-sessions/#{escape(session_id)}")
+    end
+
+    def signed_url(asset_id, expires_in: "10m", max_downloads: nil)
+      request(:post, "/assets/#{escape(asset_id)}/signed-url",
+				body: compact(expires_in: expires_in, max_downloads: max_downloads))
+    end
+
+    def list_buckets
+      request(:get, "/assets/buckets")
+    end
+
+    def create_bucket(**policy)
+      request(:post, "/assets/buckets", body: compact(policy))
+    end
+
+    def update_bucket(bucket_id, revision:, **policy)
+      request(:put, "/assets/buckets/#{escape(bucket_id)}", body: compact(policy), headers: if_match(revision))
+    end
+
+    def delete_bucket(bucket_id, revision:)
+      request(:delete, "/assets/buckets/#{escape(bucket_id)}", headers: if_match(revision))
+    end
+
+    def patch(asset_id, revision:, **changes)
+      request(:patch, "/assets/#{escape(asset_id)}", body: compact(changes), headers: if_match(revision))
+    end
+
+    def set_tags(asset_id, tags, revision:)
+      request(:put, "/assets/#{escape(asset_id)}/tags", body: { tags: tags }, headers: if_match(revision))
+    end
+
+    def patch_metadata(asset_id, metadata, revision:)
+      request(:patch, "/assets/#{escape(asset_id)}/metadata", body: { metadata: metadata }, headers: if_match(revision))
+    end
+
+		def get_ai_config
+			request(:get, "/assets/ai/config")
+		end
+
+		def get_policy
+			request(:get, "/assets/policy")
+		end
+
+		def update_policy(**policy)
+			request(:put, "/assets/policy", body: compact(policy))
+		end
+
+		def list_transformations
+			request(:get, "/assets/transformations")
+		end
+
+		def create_transformation(name, **options)
+			request(:post, "/assets/transformations", body: compact(options.merge(name: name)))
+		end
+
+		def delete_transformation(name)
+			request(:delete, "/assets/transformations/#{escape(name)}")
+		end
+
+		def signed_transform_url(asset_id, **options)
+			request(:post, "/assets/#{escape(asset_id)}/transform-url", body: compact(options))
+		end
+
+		def update_ai_config(revision:, enabled_actions:, monthly_spend_cap_micros:)
+			request(:put, "/assets/ai/config", body: {
+				enabled_actions: enabled_actions, monthly_spend_cap_micros: monthly_spend_cap_micros
+			}, headers: if_match(revision))
+		end
+
+		def job(job_id)
+			request(:get, "/assets/jobs/#{escape(job_id)}")
+		end
+
+		def cancel_job(job_id)
+			request(:post, "/assets/jobs/#{escape(job_id)}/cancel")
+		end
+
+		def analyze(asset_id, idempotency_key: nil)
+			asset_job("/assets/#{escape(asset_id)}/ai/analyze", idempotency_key)
+		end
+
+		def ai(asset_id)
+			request(:get, "/assets/#{escape(asset_id)}/ai")
+		end
+
+		def moderate(asset_id, idempotency_key: nil)
+			asset_job("/assets/#{escape(asset_id)}/moderation", idempotency_key)
+		end
+
+		def transcript(asset_id)
+			request(:get, "/assets/#{escape(asset_id)}/transcript")
+		end
+
+		def request_transcript(asset_id, idempotency_key: nil)
+			asset_job("/assets/#{escape(asset_id)}/transcript", idempotency_key)
+		end
+
+		def request_smart_crop(asset_id, idempotency_key: nil)
+			asset_job("/assets/#{escape(asset_id)}/smart-crop", idempotency_key)
+		end
+
+		def request_background_removal(asset_id, idempotency_key: nil)
+			asset_job("/assets/#{escape(asset_id)}/background-remove", idempotency_key)
+		end
+
+		def create_lifecycle_rule(**rule)
+			request(:post, "/assets/lifecycle-rules", body: compact(rule))
+		end
+
+		def list_lifecycle_rules
+			request(:get, "/assets/lifecycle-rules")
+		end
+
+		def delete_lifecycle_rule(rule_id)
+			request(:delete, "/assets/lifecycle-rules/#{escape(rule_id)}")
+		end
+
+		def create_domain(domain)
+			request(:post, "/assets/domains", body: { domain: domain })
+		end
+
+		def list_domains
+			request(:get, "/assets/domains")
+		end
+
+		def verify_domain(domain_id)
+			request(:post, "/assets/domains/#{escape(domain_id)}/verify")
+		end
+
+		def delete_domain(domain_id)
+			request(:delete, "/assets/domains/#{escape(domain_id)}")
+		end
+
+		def analytics
+			request(:get, "/assets/analytics")
+		end
+
+		def usage_summary
+			request(:get, "/assets/summary")
+		end
+
+		def events(limit: 50)
+			request(:get, "/assets/events", query: { limit: limit })
+		end
+
+		def create_webhook(url, event_types: ['asset.*'])
+			request(:post, '/assets/webhooks', body: { url: url, event_types: event_types })
+		end
+
+		def list_webhooks
+			request(:get, '/assets/webhooks')
+		end
+
+		def delete_webhook(webhook_id)
+			request(:delete, "/assets/webhooks/#{escape(webhook_id)}")
+		end
+
+		def list_webhook_deliveries(webhook_id, limit: 50)
+			request(:get, "/assets/webhooks/#{escape(webhook_id)}/deliveries", query: { limit: limit })
+		end
+
+		def retry_webhook_delivery(delivery_id)
+			request(:post, "/assets/webhook-deliveries/#{escape(delivery_id)}/retry")
+		end
+
+		def purge(asset_id)
+			request(:post, "/assets/#{escape(asset_id)}/purge")
+		end
+
+		def bulk(action:, items:, idempotency_key: nil, **options)
+			headers = idempotency_key ? { "Idempotency-Key" => idempotency_key } : {}
+			request(:post, "/assets/bulk", body: options.merge(action: action, items: items), headers: headers)
+		end
+
+		def versions(asset_id)
+			request(:get, "/assets/#{escape(asset_id)}/versions")
+		end
+
+		def create_branch(asset_id, name, from_version_id: nil)
+			request(:post, "/assets/#{escape(asset_id)}/branches", body: compact(name: name, from_version_id: from_version_id))
+		end
+
+		def restore_version(asset_id, version_id)
+			request(:post, "/assets/#{escape(asset_id)}/versions/#{escape(version_id)}/restore")
+		end
+
+		def promote_branch(asset_id, branch)
+			request(:post, "/assets/#{escape(asset_id)}/branches/#{escape(branch)}/promote")
+		end
+
+		def collections
+			request(:get, "/assets/collections")
+		end
+
+		def create_collection(**collection)
+			request(:post, "/assets/collections", body: compact(collection))
+		end
+
+		def update_collection(collection_id, **collection)
+			request(:put, "/assets/collections/#{escape(collection_id)}", body: compact(collection))
+		end
+
+		def delete_collection(collection_id)
+			request(:delete, "/assets/collections/#{escape(collection_id)}")
+		end
+
+		def saved_searches
+			request(:get, "/assets/saved-searches")
+		end
+
+		def create_saved_search(**search)
+			request(:post, "/assets/saved-searches", body: compact(search))
+		end
+
+		def update_saved_search(search_id, **search)
+			request(:put, "/assets/saved-searches/#{escape(search_id)}", body: compact(search))
+		end
+
+		def delete_saved_search(search_id)
+			request(:delete, "/assets/saved-searches/#{escape(search_id)}")
+		end
+
+    def immutable_version_url(asset_id, version_id, filename = "asset")
+      "#{@cdn_base_url}/assets/#{escape(asset_id)}/versions/#{escape(version_id)}/#{escape(filename)}"
+    end
+
+		def version_url(asset_id, version_id, token: nil)
+			prefix = token ? "/private/assets" : "/assets"
+			url = "#{@cdn_base_url}#{prefix}/#{escape(asset_id)}/versions/#{escape(version_id)}"
+			token ? "#{url}?token=#{escape(token)}" : url
+		end
+
+		def branch_url(asset_id, branch, token: nil)
+			prefix = token ? "/private/assets" : "/assets"
+			url = "#{@cdn_base_url}#{prefix}/#{escape(asset_id)}/branches/#{escape(branch)}"
+			token ? "#{url}?token=#{escape(token)}" : url
+		end
+
+		def video_url(asset_id, kind, profile = "default", token: nil)
+			prefix = token ? "/private/assets" : "/assets"
+			url = "#{@cdn_base_url}#{prefix}/#{escape(asset_id)}/video/#{escape(kind)}/#{escape(profile)}"
+			token ? "#{url}?token=#{escape(token)}" : url
+		end
+
+    private
+
+		def multipart(method, path, file_path, fields, headers: {})
+			raise ArgumentError, "Asset upload path is not a file" unless File.file?(file_path)
+
+			boundary = "stackshift-#{SecureRandom.hex(16)}"
+			body = String.new(encoding: Encoding::BINARY)
+			compact(fields).each do |name, value|
+				serialized = value.is_a?(Hash) || value.is_a?(Array) ? JSON.generate(value) : value.to_s
+				body << "--#{boundary}\r\nContent-Disposition: form-data; name=\"#{name}\"\r\n\r\n#{serialized}\r\n"
+			end
+			filename = File.basename(file_path).gsub(/[\"\r\n]/, "_")
+			body << "--#{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"#{filename}\"\r\n"
+			body << "Content-Type: application/octet-stream\r\n\r\n" << File.binread(file_path) << "\r\n--#{boundary}--\r\n"
+			request_absolute(method, "#{@base_url}#{path}", body: body,
+				headers: headers.merge("Content-Type" => "multipart/form-data; boundary=#{boundary}"), json: false, authenticated: true)
+		end
+
+		def asset_job(path, idempotency_key)
+			headers = idempotency_key ? { "Idempotency-Key" => idempotency_key } : {}
+			request(:post, path, headers: headers)
+		end
+
+    def request(method, path, body: nil, query: nil, headers: {})
+      uri = URI("#{@base_url}#{path}")
+      uri.query = URI.encode_www_form(query) if query && !query.empty?
+      request_absolute(method, uri.to_s, body: body, headers: headers, json: true, authenticated: true)
+    end
+
+    def request_absolute(method, url, body:, headers:, json:, authenticated:)
+      uri = URI(url)
+      klass = Net::HTTP.const_get(method.to_s.capitalize)
+      outgoing = klass.new(uri)
+      outgoing["Authorization"] = "Bearer #{@api_key}" if authenticated
+      headers.each { |name, value| outgoing[name] = value }
+      if body
+        outgoing.body = json ? JSON.generate(body) : body
+        outgoing["Content-Type"] ||= "application/json" if json
+      end
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(outgoing) }
+      payload = response.body.to_s.empty? ? nil : JSON.parse(response.body)
+      unless response.is_a?(Net::HTTPSuccess)
+        raise "#{payload&.dig('error', 'message') || payload&.dig('message') || 'StackShift API request failed'} (#{response.code})"
+      end
+      payload.is_a?(Hash) && payload.key?("data") ? payload["data"] : payload
+    end
+
+    def compact(values)
+      values.reject { |_key, value| value.nil? || value == "" }
+    end
+
+    def escape(value)
+      URI.encode_www_form_component(value.to_s)
+    end
+
+    def if_match(revision)
+      { "If-Match" => %("#{Integer(revision)}") }
+    end
+  end
+end

data/lib/stackshift/rails.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module StackShift
+  class AssetsRailtie < Rails::Railtie
+    initializer "stackshift.assets" do
+      Rails.application.config.x.stackshift_assets = lambda do
+        StackShift::AssetsClient.new(
+          api_key: ENV.fetch("STACKSHIFT_API_KEY"),
+          base_url: ENV.fetch("STACKSHIFT_API_URL", "https://api.stackshift.cloud/api/v1"),
+          cdn_base_url: ENV.fetch("STACKSHIFT_CDN_URL", "https://cdn.stackshift.cloud")
+        )
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: stackshift-assets
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- StackShift
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-08-02 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- support@stackshift.cloud
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/stackshift/assets.rb
+- lib/stackshift/assets_client.rb
+- lib/stackshift/rails.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Official StackShift Assets SDK for Ruby and Rails
+test_files: []