norairrecord 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e43689c499a7d1d54963791d0dacd275d2cc9c8b0c2dc27b636884b51596bbee
+  data.tar.gz: '01970ece2dddb567110ebaaec5f855df7240d329f1403c33aad49e3632aa978e'
+SHA512:
+  metadata.gz: '097efbecab4facd4d22299b7b5629b015c032c93808342f88cb6cdb652d572b72e7d1a5c48d165827ea5d35e9be41c0d6d37aafb82a411474d302e14e911fb8b'
+  data.tar.gz: f166ce6e3be2bdd525c78168df6c9f0e7dc10bd95c779abe55b742a710fb904f8694bd2604c42d93264ff607a2df962fb07dc88d7d9610c7dc269f8ef2ea5e64

data/.github/workflows/gem-push.yml

@@ -0,0 +1,26 @@
+name: gemerald
+
+on:
+  push:
+    branches: [ "main" ]
+
+jobs:
+  push:
+    name: Push gem to RubyGems.org
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
+      contents: write # IMPORTANT: this permission is required for `rake release` to push the release tag
+
+    steps:
+      # Set up
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: 3.3.5
+
+      # Release
+      - uses: rubygems/release-gem@v1

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+vendor/
+test/fixtures
+.byebug_history
+*.gem
+.idea

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.7.2
+  - 3.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in airtable.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2017 Simon Eskildsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+# Norairrecord
+
+[airrecord](https://github.com/sirupsen/airrecord) : norairrecord :: epinephrine : norepinephrine
+
+stuff not in the OG:
+* `Table#comment`
+  * ```ruby
+    rec.comment "pretty cool record!"
+    ```
+* `Table#patch`!
+  * ```ruby
+    rec.patch({ # this will fire off a request 
+      "field 1" => "new value 1", # that only modifies
+      "field 2" => "new value 2", # the specified fields
+    })
+    ```
+* """""transactions"""""!
+  * they're not great but they kinda do a thing!
+  * ```ruby
+    rec.transaction do |rec| # pipes optional
+      # do some stuff to rec...
+      # all changes inside the block happen in 1 request
+      # none of the changes happen if an error is hit
+    end
+    ```
+* custom endpoint URL
+  * handy for inspecting/ratelimiting
+  * `Norairrecord.base_url = "https://somewhere_else"`
+* custom UA
+  * `Norairrecord.user_agent = "i'm the reason why you're getting 429s!"`
+* `Table#airtable_url`
+  * what it says on the tin!

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "norairrecord"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/production-test.rb

@@ -0,0 +1,11 @@
+require 'norairrecord'
+
+p Faraday::VERSION
+
+Tea = Norairrecord.table(
+  ENV["AIRTABLE_TOKEN"],
+  "appZJC9q8TBYPDF7j",
+  "Teas"
+)
+
+# p Tea.all

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/norairrecord/client.rb

@@ -0,0 +1,50 @@
+require_relative 'faraday_rate_limiter'
+require 'erb'
+
+module Norairrecord
+  class Client
+    attr_reader :api_key
+    attr_writer :connection
+
+    # Per Airtable's documentation you will get throttled for 30 seconds if you
+    # issue more than 5 requests per second. Airrecord is a good citizen.
+    AIRTABLE_RPS_LIMIT = 5
+
+    def initialize(api_key)
+      @api_key = api_key
+    end
+
+    def connection
+      @connection ||= Faraday.new(
+        url: Norairrecord.base_url || "https://api.airtable.com",
+        headers: {
+          "Authorization" => "Bearer #{api_key}",
+          "User-Agent"    => Norairrecord.user_agent || "Airrecord (nora's version)/#{Norairrecord::VERSION}",
+        },
+      ) do |conn|
+        if Norairrecord.throttle?
+          conn.request :airrecord_rate_limiter, requests_per_second: AIRTABLE_RPS_LIMIT
+        end
+        conn.adapter :net_http_persistent
+      end
+    end
+
+    def escape(*args) 
+      ERB::Util.url_encode(*args)
+    end
+
+    def parse(body)
+      JSON.parse(body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def handle_error(status, error)
+      if error.is_a?(Hash) && error['error']
+        raise Error, "HTTP #{status}: #{error['error']['type']}: #{error['error']['message']}"
+      else
+        raise Error, "HTTP #{status}: Communication error: #{error}"
+      end
+    end
+  end
+end

data/lib/norairrecord/faraday_rate_limiter.rb

@@ -0,0 +1,61 @@
+require 'thread'
+
+module Norairrecord
+  class FaradayRateLimiter < Faraday::Middleware
+    class << self
+      attr_accessor :requests
+    end
+
+    def initialize(app, requests_per_second: nil, sleeper: nil)
+      super(app)
+      @rps = requests_per_second
+      @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+      @mutex = Mutex.new
+      clear
+    end
+
+    def call(env)
+      @mutex.synchronize do
+        wait if too_many_requests_in_last_second?
+        @app.call(env).on_complete do |_response_env|
+          requests << Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          requests.shift if requests.size > @rps
+        end
+      end
+    end
+
+    def clear
+      self.class.requests = []
+    end
+
+    private
+
+    def requests
+      self.class.requests
+    end
+
+    def too_many_requests_in_last_second?
+      return false unless @rps
+      return false unless requests.size >= @rps
+
+      window_span < 1.0
+    end
+
+    def wait
+      # Time to wait until making the next request to stay within limits.
+      # [1.1, 1.2, 1.3, 1.4, 1.5] => 1 - 0.4 => 0.6
+      wait_time = 1.0 - window_span
+      @sleeper.call(wait_time)
+    end
+
+    # [1.1, 1.2, 1.3, 1.4, 1.5] => 1.5 - 1.1 => 0.4
+    def window_span
+      requests.last - requests.first
+    end
+  end
+end
+
+Faraday::Request.register_middleware(
+  # Avoid polluting the global middleware namespace with a prefix.
+  airrecord_rate_limiter: Norairrecord::FaradayRateLimiter
+)

data/lib/norairrecord/table.rb

@@ -0,0 +1,306 @@
+require 'rubygems' # For Gem::Version
+
+module Norairrecord
+  class Table
+    class << self
+      attr_accessor :base_key, :table_name
+      attr_writer :api_key
+
+      def client
+        @@clients ||= {}
+        @@clients[api_key] ||= Client.new(api_key)
+      end
+
+      def api_key
+        defined?(@api_key) ? @api_key : Norairrecord.api_key
+      end
+
+      def has_many(method_name, options)
+        define_method(method_name.to_sym) do
+          # Get association ids in reverse order, because Airtable's UI and API
+          # sort associations in opposite directions. We want to match the UI.
+          ids = (self[options.fetch(:column)] || []).reverse
+          table = Kernel.const_get(options.fetch(:class))
+          return table.find_many(ids) unless options[:single]
+
+          (id = ids.first) ? table.find(id) : nil
+        end
+
+        define_method("#{method_name}=".to_sym) do |value|
+          self[options.fetch(:column)] = Array(value).map(&:id).reverse
+        end
+      end
+
+      def belongs_to(method_name, options)
+        has_many(method_name, options.merge(single: true))
+      end
+
+      alias has_one belongs_to
+
+      def find(id)
+        response = client.connection.get("v0/#{base_key}/#{client.escape(table_name)}/#{id}")
+        parsed_response = client.parse(response.body)
+
+        if response.success?
+          self.new(parsed_response["fields"], id: id, created_at: parsed_response["createdTime"])
+        else
+          client.handle_error(response.status, parsed_response)
+        end
+      end
+
+      def find_many(ids)
+        return [] if ids.empty?
+
+        or_args = ids.map { |id| "RECORD_ID() = '#{id}'"}.join(',')
+        formula = "OR(#{or_args})"
+        records(filter: formula).sort_by { |record| or_args.index(record.id) }
+      end
+
+      def update(id, update_hash = {}, options = {})
+        # To avoid trying to update computed fields we *always* use PATCH
+        body = {
+          fields: update_hash,
+          **options
+        }.to_json
+
+        response = client.connection.patch("v0/#{base_key}/#{client.escape(table_name)}/#{id}", body, { 'Content-Type' => 'application/json' })
+        parsed_response = client.parse(response.body)
+
+        if response.success?
+          parsed_response["fields"]
+        else
+          client.handle_error(response.status, parsed_response)
+        end
+      end
+
+
+      def create(fields, options = {})
+        new(fields).tap { |record| record.save(options) }
+      end
+
+      def records(filter: nil, sort: nil, view: nil, offset: nil, paginate: true, fields: nil, max_records: nil, page_size: nil)
+        options = {}
+        options[:filterByFormula] = filter if filter
+
+        if sort
+          options[:sort] = sort.map { |field, direction|
+            { field: field.to_s, direction: direction }
+          }
+        end
+
+        options[:view] = view if view
+        options[:offset] = offset if offset
+        options[:fields] = fields if fields
+        options[:maxRecords] = max_records if max_records
+        options[:pageSize] = page_size if page_size
+
+        path = "v0/#{base_key}/#{client.escape(table_name)}/listRecords"
+        response = client.connection.post(path, options.to_json, { 'Content-Type' => 'application/json' })
+        parsed_response = client.parse(response.body)
+
+        if response.success?
+          records = parsed_response["records"]
+          records = records.map { |record|
+            self.new(record["fields"], id: record["id"], created_at: record["createdTime"])
+          }
+
+          if paginate && parsed_response["offset"]
+            records.concat(records(
+              filter: filter,
+              sort: sort,
+              view: view,
+              paginate: paginate,
+              fields: fields,
+              offset: parsed_response["offset"],
+              max_records: max_records,
+              page_size: page_size,
+            ))
+          end
+
+          records
+        else
+          client.handle_error(response.status, parsed_response)
+        end
+      end
+      alias all records
+    end
+
+    attr_reader :fields, :id, :created_at, :updated_keys
+
+    # This is an awkward definition for Ruby 3 to remain backwards compatible.
+    # It's easier to read by reading the 2.x definition below.
+    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.0.0")
+      def initialize(*one, **two)
+        @id = one.first && two.delete(:id)
+        self.created_at = one.first && two.delete(:created_at)
+        self.fields = one.first || two
+      end
+    else
+      def initialize(fields, id: nil, created_at: nil)
+        @id = id
+        self.created_at = created_at
+        self.fields = fields
+      end
+    end
+
+    def new_record?
+      !id
+    end
+
+    def [](key)
+      validate_key(key)
+      fields[key]
+    end
+
+    def []=(key, value)
+      validate_key(key)
+      return if fields[key] == value # no-op
+
+      @updated_keys << key
+      fields[key] = value
+    end
+
+    def patch(update_hash = {}, options = {})
+      update_hash.reject! { |key, value| @fields[key] == value }
+      return @fields if update_hash.empty? # don't hit AT if we don't have real changes
+      @fields.merge!(self.class.update(self.id, update_hash, options).reject { |key, _| updated_keys.include?(key) })
+    end
+
+    def create(options = {})
+      raise Error, "Record already exists (record has an id)" unless new_record?
+
+      body = {
+        fields: serializable_fields,
+        **options
+      }.to_json
+
+      response = client.connection.post("v0/#{self.class.base_key}/#{client.escape(self.class.table_name)}", body, { 'Content-Type' => 'application/json' })
+      parsed_response = client.parse(response.body)
+
+      if response.success?
+        @id = parsed_response["id"]
+        self.created_at = parsed_response["createdTime"]
+        self.fields = parsed_response["fields"]
+      else
+        client.handle_error(response.status, parsed_response)
+      end
+    end
+
+    def save(options = {})
+      return create(options) if new_record?
+      return true if @updated_keys.empty?
+
+      update_hash = Hash[@updated_keys.map { |key|
+        [key, fields[key]]
+      }]
+
+      self.patch(update_hash, options)
+    end
+
+    def destroy
+      raise Error, "Unable to destroy new record" if new_record?
+
+      response = client.connection.delete("v0/#{self.class.base_key}/#{client.escape(self.class.table_name)}/#{self.id}")
+      parsed_response = client.parse(response.body)
+
+      if response.success?
+        true
+      else
+        client.handle_error(response.status, parsed_response)
+      end
+    end
+
+    def serializable_fields
+      fields
+    end
+
+    def comment(text)
+      response = client.connection.post("v0/#{self.class.base_key}/#{client.escape(self.class.table_name)}/#{self.id}/comments", {text:}.to_json, { 'Content-Type' => 'application/json' })
+      parsed_response = client.parse(response.body)
+
+      if response.success?
+        parsed_response['id']
+      else
+        client.handle_error(response.status, parsed_response)
+      end
+    end
+
+    def airtable_url
+      "https://airtable.com/#{self.class.base_key}/#{self.class.table_name}/#{self.id}"
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        serializable_fields == other.serializable_fields
+    end
+    alias eql? ==
+
+    def hash
+      serializable_fields.hash
+    end
+
+    # ahahahahaha
+    def transaction(&block)
+      txn_updates = {}
+
+      singleton_class.alias_method :original_setter, :[]=
+
+      define_singleton_method(:[]=) do |key, value|
+        txn_updates[key] = value
+      end
+
+      begin
+        result = yield self
+        @updated_keys -= txn_updates.keys
+        if new_record?
+          @fields.merge!(txn_updates)
+          save
+        else
+          self.patch(txn_updates)
+        end
+      rescue => e
+        raise
+      ensure
+        singleton_class.alias_method :[]=, :original_setter
+        singleton_class.remove_method :original_setter
+      end
+      result
+    end
+
+
+    protected
+
+    def fields=(fields)
+      @updated_keys = []
+      @fields = fields
+    end
+
+    def created_at=(created_at)
+      return unless created_at
+
+      @created_at = Time.parse(created_at)
+    end
+
+    def client
+      self.class.client
+    end
+
+    def validate_key(key)
+      return true unless key.is_a?(Symbol)
+
+      raise(Error, [
+        "Airrecord 1.0 dropped support for Symbols as field names.",
+        "Please use the raw field name, a String, instead.",
+        "You might try: record['#{key.to_s.tr('_', ' ')}']"
+      ].join("\n"))
+    end
+  end
+
+  def self.table(api_key, base_key, table_name)
+    Class.new(Table) do |klass|
+      klass.table_name = table_name
+      klass.api_key = api_key
+      klass.base_key = base_key
+    end
+  end
+end

data/lib/norairrecord/version.rb

@@ -0,0 +1,3 @@
+module Norairrecord
+  VERSION = "0.1.2"
+end

data/lib/norairrecord.rb

@@ -0,0 +1,20 @@
+require "json"
+require "faraday"
+require 'faraday/net_http_persistent'
+require "time"
+require "norairrecord/version"
+require "norairrecord/client"
+require "norairrecord/table"
+
+module Norairrecord
+  extend self
+  attr_accessor :api_key, :throttle, :base_url, :user_agent
+
+  Error = Class.new(StandardError)
+
+  def throttle?
+    return true if @throttle.nil?
+
+    @throttle
+  end
+end

data/norairrecord.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'norairrecord/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "norairrecord"
+  spec.version       = Norairrecord::VERSION
+  spec.authors       = ["nora"]
+  spec.email         = ["nora@hcb.pizza"]
+
+  spec.summary       = %q{Airtable client}
+  spec.description   = %q{screwed a cookie to the tabel}
+  spec.homepage      = "https://github.com/24c02/norairrecord"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.2"
+
+  spec.add_dependency "faraday", [">= 1.0", "< 3.0"]
+  spec.add_dependency "net-http-persistent"
+  spec.add_dependency "faraday-net_http_persistent"
+
+  spec.add_development_dependency "bundler", "~> 2"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: norairrecord
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- nora
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http_persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: screwed a cookie to the tabel
+email:
+- nora@hcb.pizza
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/gem-push.yml"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/production-test.rb
+- bin/setup
+- lib/norairrecord.rb
+- lib/norairrecord/client.rb
+- lib/norairrecord/faraday_rate_limiter.rb
+- lib/norairrecord/table.rb
+- lib/norairrecord/version.rb
+- norairrecord.gemspec
+homepage: https://github.com/24c02/norairrecord
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key: 
+specification_version: 4
+summary: Airtable client
+test_files: []