norairrecord 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2413a6757fd7aa66b83507ab161d8305bd233b29739652cc0c05302df835ed0
-  data.tar.gz: 468978e1acae10b550e887affa319a24a6fa4a41ab6200b0193d36866d31364c
+  metadata.gz: 2d6cb01e5b17df2640cfc26b6e719deb69d04b21cbb89eb8f31b4dffc052c998
+  data.tar.gz: 66406d3ffbcda723cdc524447555d646e58578b8ea56b7c25f3170bfb754eb93
 SHA512:
-  metadata.gz: 26ee966a87a85da8c545c9ab8a49c6d654dd2fdb33891e21954b13eedbd1041c9a18e03ba06cf903a7930800166cbb8d7906db3c20ad8ea6dc92d5e250e7f68a
-  data.tar.gz: 696a61147478f307b86e7adceb7464ccbc1a023756a076feadc4240f27e6e2482ea9289c47b38e9995e255df20f66da16b1a675e4599baf41a54e04bc58acb01
+  metadata.gz: 352e8b49946a4b54657140b5736c246f56f9381c8e6225176674bb93438b6d25b9e9f3ba2a60596996760a5adf6be5d8318cf98951102f09cd0d6a19e990cd9a
+  data.tar.gz: 6570f39459f17d523fb963c4274c8d8e3831b9281659e257c44c45d799556d6c3df10c733061ed6ec1dc5dbdbea56733d7f7c9ed85b0c2b2cc686f5821ac2536

data/README.md

@@ -52,4 +52,10 @@ stuff not in the OG:
 * `Norairrecord::RecordNotFoundError`
   * never again wonder if an error is because you goofed up an ID or you're getting ratelimited
 * `where` argument on `has_many` lookups
-* `Table#first`, `Table#first_where`
+* `Table#first`, `Table#first_where`
+* you're not gonna believe it:
+  * `Table.batch_`{update,upsert,create,save}
+  * makes ratelimits much less painful
+* `Util` (those little methods we have to keep writing again and again, now in one place)
+* custom RPS limit
+  * `Norairrecord.rps_limit = 3`

data/lib/norairrecord/client.rb

@@ -23,7 +23,7 @@ module Norairrecord
         },
       ) do |conn|
         if Norairrecord.throttle?
-          conn.request :airrecord_rate_limiter, requests_per_second: AIRTABLE_RPS_LIMIT
+          conn.request :airrecord_rate_limiter, requests_per_second: Norairrecord.rps_limit || AIRTABLE_RPS_LIMIT
         end
         conn.adapter :net_http_persistent
       end

data/lib/norairrecord/table.rb

@@ -2,9 +2,13 @@ require 'rubygems' # For Gem::Version
 
 module Norairrecord
   class Table
+    BATCH_SIZE = 10
+
     class << self
       attr_writer :api_key, :base_key, :table_name
 
+      include Norairrecord::Util
+
       def base_key
         @base_key || (superclass < Table ? superclass.base_key : nil)
       end
@@ -13,6 +17,16 @@ module Norairrecord
         @table_name || (superclass < Table ? superclass.table_name : nil)
       end
 
+
+      # finds the actual parent class of a (possibly) subtype class
+      def responsible_class
+        if @base_key
+          self.class
+        else
+          superclass < Table ? superclass.responsible_class : nil
+        end
+      end
+
       def client
         @@clients ||= {}
         @@clients[api_key] ||= Client.new(api_key)
@@ -64,9 +78,8 @@ module Norairrecord
       def find_many(ids, where: nil, sort: nil)
         return [] if ids.empty?
 
-        or_args = ids.map { |id| "RECORD_ID() = '#{id}'"}.join(',')
-        formula = "OR(#{or_args})"
-        formula = "AND(#{formula},#{where})" if where
+        formula = any_of(ids.map { |id| "RECORD_ID() = '#{id}'" })
+        formula = all_of(formula, where) if where
         records(filter: formula, sort:).sort_by { |record| or_args.index(record.id) }
       end
 
@@ -87,7 +100,6 @@ module Norairrecord
         end
       end
 
-
       def create(fields, options = {})
         new(fields).tap { |record| record.save(options) }
       end
@@ -97,7 +109,7 @@ module Norairrecord
           clazz = self
           st = @subtype_mapping[fields[@subtype_column]]
           raise Norairrecord::UnknownTypeError, "#{fields[@subtype_column]}?????" if @subtype_strict && st.nil?
-          clazz =  Kernel.const_get(st) if st
+          clazz = Kernel.const_get(st) if st
           clazz.new(fields, id:, created_at:)
         else
           self.new(fields, id: id, created_at: created_at)
@@ -125,22 +137,19 @@ module Norairrecord
         parsed_response = client.parse(response.body)
 
         if response.success?
-          records = parsed_response["records"]
-          records.map! { |record|
-            self.new_with_subtype(record["fields"], id: record["id"], created_at: record["createdTime"])
-          }
+          records = map_new parsed_response["records"]
 
           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,
-            ))
+                             filter: filter,
+                             sort: sort,
+                             view: view,
+                             paginate: paginate,
+                             fields: fields,
+                             offset: parsed_response["offset"],
+                             max_records: max_records,
+                             page_size: page_size,
+                           ))
           end
 
           records
@@ -161,10 +170,105 @@ module Norairrecord
         records(**options.merge(filter:))
       end
 
-      alias all records
-    end
+      def map_new(arr)
+        arr.map do |record|
+          self.new_with_subtype(record["fields"], id: record["id"], created_at: record["createdTime"])
+        end
+      end
+
+      def batch_update(recs, options = {})
+        res = []
+        recs.each_slice(BATCH_SIZE) do |chunk|
+          body = {
+            records: chunk.map do |record|
+              {
+                fields: record.update_hash,
+                id: record.id,
+              }
+            end,
+            **options
+          }.to_json
+
+          response = client.connection.patch("v0/#{base_key}/#{client.escape(table_name)}", body, { 'Content-Type' => 'application/json' })
+          parsed_response = client.parse(response.body)
+          if response.success?
+            res.concat(parsed_response["records"])
+          else
+            client.handle_error(response.status, parsed_response)
+          end
+        end
+        map_new res
+      end
+
+      def batch_upsert(recs, merge_fields, options = {}, include_ids: nil, hydrate: false)
+        merge_fields = Array(merge_fields) # allows passing in a single field
+
+        created, updated, records = [], [], []
 
+        recs.each_slice(BATCH_SIZE) do |chunk|
+          body = {
+            records: chunk.map { |rec| { fields: rec.fields, id: (include_ids ? rec.id : nil) }.compact },
+            **options,
+            performUpsert: { fieldsToMergeOn: merge_fields }
+          }.to_json
 
+          response = client.connection.patch("v0/#{base_key}/#{client.escape(table_name)}", body, { 'Content-Type' => 'application/json' })
+          parsed_response = response.success? ? client.parse(response.body) : client.handle_error(response.status, client.parse(response.body))
+
+          if response.success?
+            created.concat(parsed_response.fetch('createdRecords', []))
+            updated.concat(parsed_response.fetch('updatedRecords', []))
+            records.concat(parsed_response.fetch('records', []))
+          else
+            client.handle_error(response.status, parsed_response)
+          end
+        end
+
+        if hydrate && records.any?
+          record_hash = records.map { |record| [record["id"], self.new_with_subtype(record["fields"], id: record["id"], created_at: record["createdTime"])] }.to_h
+
+          created.map! { |id| record_hash[id] }.compact!
+          updated.map! { |id| record_hash[id] }.compact!
+          records = record_hash.values
+        end
+
+        { created:, updated:, records: }
+      end
+
+      def batch_create(recs, options = {})
+        records = []
+        recs.each_slice(BATCH_SIZE) do |chunk|
+          body = {
+            records: chunk.map { |record| { fields: record.serializable_fields } },
+            **options
+          }.to_json
+
+          response = client.connection.post("v0/#{base_key}/#{client.escape(table_name)}", body, { 'Content-Type' => 'application/json' })
+          parsed_response = client.parse(response.body)
+
+          if response.success?
+            records.concat(parsed_response["records"])
+          else
+            client.handle_error(response.status, parsed_response)
+          end
+        end
+        map_new records
+      end
+
+      def upsert(fields, merge_fields, options = {})
+        record = batch_upsert([self.new(fields)], merge_fields, options)&.dig(:records, 0)
+        record ? new(record) : nil
+      end
+
+      def batch_save(records)
+        res = []
+        to_be_created, to_be_updated = records.partition &:new_record?
+        res.concat(batch_create(to_be_created))
+        res.concat(batch_update(to_be_updated))
+      end
+
+      alias all records
+    end
 
     attr_reader :fields, :id, :created_at, :updated_keys
 
@@ -201,10 +305,10 @@ module Norairrecord
       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) })
+    def patch(updates = {}, options = {})
+      updates.reject! { |key, value| @fields[key] == value }
+      return @fields if updates.empty? # don't hit AT if we don't have real changes
+      @fields.merge!(self.class.update(self.id, updates, options).reject { |key, _| updated_keys.include?(key) })
     end
 
     def create(options = {})
@@ -230,11 +334,13 @@ module Norairrecord
     def save(options = {})
       return create(options) if new_record?
       return true if @updated_keys.empty?
+      self.fields = self.class.update(self.id, self.update_hash, options)
+    end
 
-      update_hash = Hash[@updated_keys.map { |key|
+    def update_hash
+      Hash[@updated_keys.map { |key|
         [key, fields[key]]
       }]
-      self.fields = self.class.update(self.id, update_hash, options)
     end
 
     def destroy
@@ -255,7 +361,7 @@ module Norairrecord
     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' })
+      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?
@@ -273,6 +379,7 @@ module Norairrecord
       self.class == other.class &&
         serializable_fields == other.serializable_fields
     end
+
     alias eql? ==
 
     def hash
@@ -307,7 +414,6 @@ module Norairrecord
       result
     end
 
-
     protected
 
     def fields=(fields)

data/lib/norairrecord/util.rb

@@ -0,0 +1,24 @@
+module Norairrecord
+  module Util
+    class << self
+      def all_of(*args)
+        "AND(#{args.join(',')})"
+      end
+      def any_of(*args)
+        "OR(#{args.join(',')})"
+      end
+      def none_of(*args)
+        "NOT(#{all_of(*args)})"
+      end
+      def field_is_any(field, *args)
+        any_of(*args.map { |arg| "#{field}='#{sanitize(arg)}'"})
+      end
+      def sanitize(arg)
+        arg.gsub(/['"]/, '\\\\\0')
+      end
+      def mass_sanitize(*args)
+        args.map { |arg| sanitize(arg) }
+      end
+    end
+  end
+end

data/lib/norairrecord/version.rb

@@ -1,3 +1,3 @@
 module Norairrecord
-  VERSION = "0.2.1"
+  VERSION = "0.4.0"
 end

data/lib/norairrecord.rb

@@ -2,13 +2,14 @@ require "json"
 require "faraday"
 require 'faraday/net_http_persistent'
 require "time"
+require "norairrecord/util"
 require "norairrecord/version"
 require "norairrecord/client"
 require "norairrecord/table"
 
 module Norairrecord
   extend self
-  attr_accessor :api_key, :throttle, :base_url, :user_agent
+  attr_accessor :api_key, :throttle, :base_url, :user_agent, :rps_limit
 
   Error = Class.new(StandardError)
   UnknownTypeError = Class.new(Error)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: norairrecord
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - nora
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-03 00:00:00.000000000 Z
+date: 2025-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -107,6 +107,7 @@ files:
 - lib/norairrecord/client.rb
 - lib/norairrecord/faraday_rate_limiter.rb
 - lib/norairrecord/table.rb
+- lib/norairrecord/util.rb
 - lib/norairrecord/version.rb
 - norairrecord.gemspec
 homepage: https://github.com/24c02/norairrecord