buchida 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d609f12cc9ce58b4802a97f2b0bdb1e37150472571d7bb4f7165eab82a884eba
+  data.tar.gz: e6db0119d1dce466a631cbb23b99629a38038e5c72d8d58d49865bccd8ec6232
+SHA512:
+  metadata.gz: 0bf53456137333f4e788a172820ad8995beba3d1a8b1233ed20107348d3a0b055410846d80756c7259764ffebcc1616b625d15e9fe973bec93af51d0a9cfe902
+  data.tar.gz: 9c06e7301bcb567579664b876a626f3e13f3e0eec85a981c2d4be49d19a81bffa1b7079d130a3f1b7a2346e4f7cda94e82041160b26bcb35d04686c72d33f4d7

data/lib/buchida/client.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Buchida
+	class Client
+		DEFAULT_BASE_URL = "https://api.buchida.com"
+		DEFAULT_TIMEOUT = 30
+
+		attr_reader :emails, :domains, :api_keys, :webhooks, :templates, :metrics
+
+		def initialize(api_key, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT)
+			raise ArgumentError, "API key is required" if api_key.nil? || api_key.empty?
+
+			@api_key = api_key
+			@base_url = base_url.chomp("/")
+			@timeout = timeout
+
+			@emails = Resources::Emails.new(self)
+			@domains = Resources::Domains.new(self)
+			@api_keys = Resources::ApiKeys.new(self)
+			@webhooks = Resources::Webhooks.new(self)
+			@templates = Resources::Templates.new(self)
+			@metrics = Resources::Metrics.new(self)
+		end
+
+		def request(method, path, body = nil)
+			uri = URI("#{@base_url}#{path}")
+
+			req = case method
+			when :get then Net::HTTP::Get.new(uri)
+			when :post then Net::HTTP::Post.new(uri)
+			when :delete then Net::HTTP::Delete.new(uri)
+			else raise ArgumentError, "Unsupported method: #{method}"
+			end
+
+			req["Authorization"] = "Bearer #{@api_key}"
+			req["Content-Type"] = "application/json"
+			req["User-Agent"] = "buchida-ruby/#{VERSION}"
+			req.body = JSON.generate(body) if body
+
+			http = Net::HTTP.new(uri.host, uri.port)
+			http.use_ssl = uri.scheme == "https"
+			http.open_timeout = @timeout
+			http.read_timeout = @timeout
+
+			response = http.request(req)
+
+			unless response.is_a?(Net::HTTPSuccess) || response.code == "204"
+				handle_error(response)
+			end
+
+			return nil if response.code == "204" || response.body.nil? || response.body.empty?
+
+			JSON.parse(response.body)
+		end
+
+		private
+
+		def handle_error(response)
+			body = begin
+				JSON.parse(response.body)
+			rescue
+				{ "message" => response.message }
+			end
+
+			message = body["message"] || response.message
+			status = response.code.to_i
+
+			case status
+			when 401 then raise AuthenticationError, message
+			when 404 then raise NotFoundError, message
+			when 422 then raise ValidationError, message
+			when 429 then raise RateLimitError, message
+			else raise Error.new(message, status, body["code"])
+			end
+		end
+	end
+end

data/lib/buchida/errors.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Buchida
+	class Error < StandardError
+		attr_reader :status_code, :code
+
+		def initialize(message, status_code, code = nil)
+			super(message)
+			@status_code = status_code
+			@code = code
+		end
+	end
+
+	class AuthenticationError < Error
+		def initialize(message = "Invalid API key")
+			super(message, 401, "authentication_error")
+		end
+	end
+
+	class RateLimitError < Error
+		def initialize(message = "Rate limit exceeded")
+			super(message, 429, "rate_limit_error")
+		end
+	end
+
+	class NotFoundError < Error
+		def initialize(message = "Resource not found")
+			super(message, 404, "not_found")
+		end
+	end
+
+	class ValidationError < Error
+		def initialize(message = "Validation failed")
+			super(message, 422, "validation_error")
+		end
+	end
+end

data/lib/buchida/resources/api_keys.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Buchida
+	module Resources
+		class ApiKeys
+			def initialize(client)
+				@client = client
+			end
+
+			def create(name:, permission:)
+				@client.request(:post, "/api-keys", { name: name, permission: permission })
+			end
+
+			def list
+				@client.request(:get, "/api-keys")
+			end
+
+			def delete(id)
+				@client.request(:delete, "/api-keys/#{id}")
+			end
+		end
+	end
+end

data/lib/buchida/resources/domains.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Buchida
+	module Resources
+		class Domains
+			def initialize(client)
+				@client = client
+			end
+
+			def create(name:)
+				@client.request(:post, "/domains", { name: name })
+			end
+
+			def list
+				@client.request(:get, "/domains")
+			end
+
+			def get(id)
+				@client.request(:get, "/domains/#{id}")
+			end
+
+			def verify(id)
+				@client.request(:post, "/domains/#{id}/verify")
+			end
+		end
+	end
+end

data/lib/buchida/resources/emails.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Buchida
+	module Resources
+		class Emails
+			def initialize(client)
+				@client = client
+			end
+
+			def send(from:, to:, subject:, html: nil, text: nil, reply_to: nil, cc: nil, bcc: nil, tags: nil, scheduled_at: nil)
+				body = { from: from, to: to, subject: subject }
+				body[:html] = html if html
+				body[:text] = text if text
+				body[:replyTo] = reply_to if reply_to
+				body[:cc] = cc if cc
+				body[:bcc] = bcc if bcc
+				body[:tags] = tags if tags
+				body[:scheduledAt] = scheduled_at if scheduled_at
+				@client.request(:post, "/emails", body)
+			end
+
+			def get(id)
+				@client.request(:get, "/emails/#{id}")
+			end
+
+			def list(cursor: nil, limit: nil, status: nil, from: nil, to: nil)
+				params = {}
+				params[:cursor] = cursor if cursor
+				params[:limit] = limit if limit
+				params[:status] = status if status
+				params[:from] = from if from
+				params[:to] = to if to
+				qs = URI.encode_www_form(params) unless params.empty?
+				path = qs ? "/emails?#{qs}" : "/emails"
+				@client.request(:get, path)
+			end
+
+			def cancel(id)
+				@client.request(:post, "/emails/#{id}/cancel")
+			end
+
+			def send_batch(emails)
+				@client.request(:post, "/emails/batch", emails)
+			end
+		end
+	end
+end

data/lib/buchida/resources/metrics.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Buchida
+	module Resources
+		class Metrics
+			def initialize(client)
+				@client = client
+			end
+
+			def get(from:, to:, granularity: nil)
+				params = { from: from, to: to }
+				params[:granularity] = granularity if granularity
+				qs = URI.encode_www_form(params)
+				@client.request(:get, "/metrics?#{qs}")
+			end
+		end
+	end
+end

data/lib/buchida/resources/templates.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Buchida
+	module Resources
+		class Templates
+			def initialize(client)
+				@client = client
+			end
+
+			def list
+				@client.request(:get, "/templates")
+			end
+
+			def get(id)
+				@client.request(:get, "/templates/#{id}")
+			end
+		end
+	end
+end

data/lib/buchida/resources/webhooks.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Buchida
+	module Resources
+		class Webhooks
+			def initialize(client)
+				@client = client
+			end
+
+			def create(url:, events:)
+				@client.request(:post, "/webhooks", { url: url, events: events })
+			end
+
+			def list
+				@client.request(:get, "/webhooks")
+			end
+
+			def delete(id)
+				@client.request(:delete, "/webhooks/#{id}")
+			end
+		end
+	end
+end

data/lib/buchida/version.rb

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

data/lib/buchida.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "buchida/version"
+require_relative "buchida/errors"
+require_relative "buchida/client"
+require_relative "buchida/resources/emails"
+require_relative "buchida/resources/domains"
+require_relative "buchida/resources/api_keys"
+require_relative "buchida/resources/webhooks"
+require_relative "buchida/resources/templates"
+require_relative "buchida/resources/metrics"
+
+module Buchida
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: buchida
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- buchida
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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'
+description: Ruby client for the buchida email API with CJK-first template support.
+email: hello@buchida.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/buchida.rb
+- lib/buchida/client.rb
+- lib/buchida/errors.rb
+- lib/buchida/resources/api_keys.rb
+- lib/buchida/resources/domains.rb
+- lib/buchida/resources/emails.rb
+- lib/buchida/resources/metrics.rb
+- lib/buchida/resources/templates.rb
+- lib/buchida/resources/webhooks.rb
+- lib/buchida/version.rb
+homepage: https://github.com/Vyblor/buchida-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK for buchida email API
+test_files: []