कॉन्फ़िगरेशन

ये आपके पहले send पर किसी उलझाऊ विफलता के रूप में सामने आने के बजाय उसी पंक्ति से ArgumentError raise करते हैं जिसमें ग़लत मान था। संदेश बताता है कि क्या ग़लत था और उसकी जगह क्या पास करना है, और वह कभी कोई क्रेडेंशियल नहीं दोहराता।

क्लाइंट एक बार बनाइए और उसी को साझा कीजिए। हर रिक्वेस्ट पर नया क्लाइंट अपने खुले कनेक्शन बेवजह फेंक देता है, और उस पर रखी कोई भी स्थिति प्रति-कॉलर नहीं होती। बनने के बाद क्लाइंट frozen हो जाता है और एक साथ कई थ्रेड्स से इस्तेमाल करना सुरक्षित है, इसलिए Puma या Sidekiq प्रोसेस को सिर्फ़ एक चाहिए, और fork के बाद चाइल्ड अपने कनेक्शन खोलता है।

जिस स्थिति में वरना हर कुंजी के लिए एक क्लाइंट बनाना पड़ता, जैसे कई वर्कस्पेस की ओर से भेजने वाला कोई जॉब, वहाँ कॉल पर ही api_key: पास करें। यह उस रिक्वेस्ट के लिए Authorization हेडर बदल देता है और क्लाइंट पर कुछ भी पीछे नहीं छोड़ता।

message = {from: "[email protected]", to: "[email protected]", subject: "Your invoice", text: "Attached."}workspace_key = ENV.fetch("OPENEMAIL_API_KEY") client.emails.send(message) client.emails.send(message, api_key: workspace_key) client.threads.list(folder: "inbox", api_key: workspace_key)client.webhooks.list(api_key: workspace_key)

temp_mail के बाहर हर मेथड इसे keyword argument के रूप में लेता है, सूची पर फ़िल्टरों के साथ, और temp_mail के मेथड इसकी जगह inbox_token: लेते हैं। रिक्वेस्ट भेजे जाने से पहले इसकी जाँच उसी नियम से होती है जो क्लाइंट इस्तेमाल करता है, इसलिए टाइपो पर किसी ऐसे क्रेडेंशियल के बारे में 401 के बजाय, जिसे फिर आपको ढूँढना पड़े, इस कॉल को पास की गई api_key के बारे में एक ArgumentError raise होता है। दोबारा आज़माई गई कॉल वही कुंजी रखती है जो उसे दी गई थी।

client.raw वह transport है जिससे हर मेथड गुज़रता है। client.raw.request ऐसे path को कॉल करता है जिसे अभी कोई मेथड नहीं लपेटता, क्लाइंट के क्रेडेंशियल, बेस URL, टाइमआउट और पुनः प्रयास नीति को लागू करते हुए, और पार्स की गई बॉडी उसी तरह लौटाता है जैसे कोई मेथड लौटाता है।

ping = client.raw.request("/ping") label = client.raw.request("/labels", method: :post, body: {name: "Invoices"}) p ping[:ok], label[:id]

OpenEmail.create_temp_mail डिस्पोज़ेबल इनबॉक्स के लिए ऐसा क्लाइंट बनाता है जो कोई API कुंजी नहीं रखता और एनवायरनमेंट से भी कोई नहीं पढ़ता। यह गुमनाम रूप से इनबॉक्स बनाता है, और हर पढ़ाई वह इनबॉक्स टोकन भेजती है जो create ने लौटाया था, या वह नया टोकन जो extend ने लौटाया, या तो प्रति कॉल inbox_token: के रूप में या एक बार OpenEmail.create_temp_mail(inbox_token:) के रूप में।

temp_mail = OpenEmail.create_temp_mail inbox = temp_mail.createpage = temp_mail.list_messages(inbox[:id], inbox_token: inbox[:token]) p page.items.size, page.expires_at

किसी व्यक्ति का OAuth से जोड़ा गया ऐप, जैसे कमांड लाइन टूल या कोई एजेंट, API कुंजी के बजाय एक्सेस टोकन रखता है। उसे access_token: के रूप में दें: या तो ख़ुद टोकन, या कुछ भी जो call का जवाब दे और टोकन लौटाए, जैसे कोई lambda या Method। यह हर कॉल के लिए एक बार चलता है, और उस कॉल के पुनः प्रयास वही इस्तेमाल करते हैं जो इसने लौटाया, इसलिए टोकन की मियाद ख़त्म होने के क़रीब हो तो उसे इसी के अंदर नया करें, और क्लाइंट को कभी दोबारा बनाना नहीं पड़ेगा।

tokens = {current: "token-from-your-oauth-flow"} oauth_client = OpenEmail::Client.new(access_token: -> { tokens.fetch(:current) }) me = oauth_client.me.get puts me[:clientId], me[:expiresAt] if me[:object] == "oauth_token"

किसी संवेदनशील बदलाव से पहले, जैसे डोमेन हटाना या वेबहुक बदलना, API एक्सेस टोकन से वह सत्यापन कोड माँगता है जो वेब ऐप व्यक्ति से माँगता। कॉल एक OpenEmail::PermissionError raise करती है, एक 403 जिसका step_up_required? true होता है, और कुछ नहीं बदला गया। कोड माँगें, व्यक्ति से मिला कोड सत्यापित करें, फिर कॉल दोबारा करें। API कुंजी से कभी नहीं माँगा जाता।

domain_id = "b3e1f0a4-6c2d-4e8a-9f17-2d5c8a0b4e6f" begin  client.domains.delete(domain_id)rescue OpenEmail::ApiError => error  raise unless error.step_up_required?   challenge = client.security.begin_step_up   if challenge[:method] == "email"    puts "Enter the code we emailed to #{challenge[:sentTo]}"  else    puts "Enter the code from your authenticator app, or a backup code"  end   client.security.verify_step_up(code: $stdin.gets.to_s.strip)  client.domains.delete(domain_id)end

जब RubyGems पर gem का नया वर्शन होता है, तो क्लाइंट यह बात हर प्रोसेस में एक बार, standard error पर, ℹ openemail 0.0.2 is available, you are on 0.0.1. जैसी एक पंक्ति के रूप में बताता है, और उसके बाद gem का पेज। यह जाँच पहला क्लाइंट बनते समय, दो सेकंड के टाइमआउट वाले एक बैकग्राउंड थ्रेड में, सिर्फ़ तब चलती है जब standard output कोई terminal हो, और RubyGems तक न पहुँच पाने को अनदेखा कर दिया जाता है।

डिफ़ॉल्ट एडैप्टर अपना प्रॉक्सी Ruby के अपने URI#find_proxy से ढूँढता है, इसलिए वह बाक़ी मानक लाइब्रेरी जैसे ही नियम मानता है: https_proxy या HTTPS_PROXY प्रॉक्सी का नाम बताता है, और no_proxy या NO_PROXY उन होस्ट की सूची देता है जो सीधे जुड़ते हैं। प्रॉक्सी URL में यूज़र नाम और पासवर्ड प्रॉक्सी को भेजे जाते हैं, और इस मशीन पर चल रहे सर्वर तक कभी प्रॉक्सी के ज़रिए नहीं पहुँचा जाता।

adapter: HTTP परत की जगह लेता है। यह कुछ भी हो सकता है जो call(request) का जवाब दे, lambda भी, और status, headers और body वाला OpenEmail::HttpResponse लौटाए। रिक्वेस्ट method, url, headers, body और timeout वाला एक OpenEmail::HttpRequest होती है, इसलिए टेस्ट ठीक-ठीक जाँच सकता है कि क्या बाहर जाता।

requests = [] adapter = lambda do |request|  requests << request  OpenEmail::HttpResponse.new(    status: 200,    headers: {"content-type" => "application/json"},    body: JSON.generate({id: "msg_test", status: "sent", replayed: false})  )end test_client = OpenEmail::Client.new(api_key: "oe_test_fake", adapter:, max_retries: 0, disable_update_notice: true) sent = test_client.emails.send(from: "[email protected]", to: "[email protected]", subject: "Hi", text: "Hello") p sent[:status], requests.first.method, requests.first.url, requests.first.headers["Idempotency-Key"]p requests.first

किसी रिक्वेस्ट को प्रिंट करने पर उसका Authorization हेडर [redacted] के रूप में दिखता है, इसलिए टेस्ट लॉग में कभी कुंजी नहीं होती।

• —मेल खाती OpenEmail::ApiError subclass पाने के लिए 2xx से बाहर का कोई status लौटाएँ, जिसकी बॉडी API का error envelope हो, जैसे {"error": {"type": "validation_error", "code": "invalid_parameter", "message": "..."}}।
• —ऐसा OpenEmail::NetworkError पाने के लिए जिसका timeout? true हो, call से Timeout::Error raise करें, या Net::ReadTimeout, जो उसी का एक प्रकार है। कोई भी दूसरा StandardError, जैसे Errno::ECONNREFUSED, ऐसा NetworkError बन जाता है जिसका timeout? false होता है।
• —एडैप्टर के अंदर raise हुए NameError, TypeError और ArgumentError उसी के bug माने जाते हैं। वे बिना बदले raise होते हैं और उन पर कभी पुनः प्रयास नहीं होता।