airtable-orm 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 970cedc7b68168b8add9fa80225982de0e902758bfb0dbfb7b3d04184c292871
-  data.tar.gz: 9e45c6326f0daa9b07eee7f6aa81601217437f40022ca05a34c85d0fd17714f1
+  metadata.gz: dc3056cbf98026ea8a89b01d99c632ad01da304d85841544552b44565f897793
+  data.tar.gz: cf839f12c5812c4834604dc46c716fdb671c47110d94829fa863d82f5d56e489
 SHA512:
-  metadata.gz: 3812676e76a07ae378a285030f30c8175fc9bb23670d626d2103e44611894785f962554d3cd9737c9c88f2ba6aaf9b8d80c8d5ee6e9401ca0a5da6b413ba7dcd
-  data.tar.gz: 0bc1ea55739db84a90a92b8389d3df1c37121e496838388ec863621e3e8fb13adc6cbb54ee19e9f09f2c0eeebf8b20dd70521a6e827b6b6d384dca4230f9f35d
+  metadata.gz: dfcd829b2a0df28d151770f30c0f51e98680bc6ab0c6f8fd5f0ff9fd2fd6ffefdef4f3c30fbe7dbcb3f3afa08689d6dffb6fc234d28a4403c3ec56f004f0abfa
+  data.tar.gz: 6c31d239c24e6c86e6303cc5eb7fdd34a5916c914c27999625c6b0c945178f9d7def6386855ba77cc13493054d14dc8abf1f087ca27474b8ff6a21f1e34f2e57

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.2.1] - 2026-07-15
+
+### Fixed
+
+- The schema cache stores the full base schema instead of only the tables configured at fetch
+  time — a table added to `config.tables` after the cache warmed up (24 h expiry, shared store
+  in Rails hosts) now resolves immediately instead of raising `ConfigurationError` until expiry.
+
+### Changed
+
+- Record payloads are parsed by string keys directly instead of deep-converting every record
+  with `with_indifferent_access` — one avoided deep copy per record on `where`/`all`/`find`,
+  two per record on batch updates. The (undocumented) `instantiate_from_api_response` and
+  `apply_response_fields` now expect string-keyed parsed payloads; `createdTime` parsing lives
+  in the single `Persistence.parse_created_time` helper.
+
 ## [0.2.0] - 2026-07-14
 
 Hardening release from a deep code review of the whole gem. Minor (not patch) because a few

data/lib/airtable/orm/persistence.rb

@@ -111,21 +111,28 @@ module Airtable
           record
         end
 
-        # Instantiate a record from API response
+        # Instantiate a record from a parsed API payload. Expects string keys (the shape the
+        # JSON middleware produces) — this runs once per record on every where/all/find, so no
+        # per-record deep conversion here.
         def instantiate_from_api_response(response)
-          data = response.with_indifferent_access
-          symbol_attrs = fields_to_symbol_attributes(data[:fields])
-
-          record = new(**symbol_attrs)
+          record = new(**fields_to_symbol_attributes(response["fields"]))
           record.send(:assign_persistence_state,
-                      id: data[:id],
-                      created_at: data[:createdTime] ? Time.iso8601(data[:createdTime].to_s) : nil,
+                      id: response["id"],
+                      created_at: parse_created_time(response),
                       persisted: true)
           record.clear_changes_information
 
           record
         end
 
+        # @api private — createdTime is ISO-8601 UTC, parsed with Time.iso8601 (Time.zone
+        # doesn't exist outside Rails); nil-guarded. The single parse site for both
+        # instantiate_from_api_response and #apply_response_fields.
+        def parse_created_time(data)
+          created_time = data["createdTime"]
+          created_time ? Time.iso8601(created_time.to_s) : nil
+        end
+
         # Convert API field IDs to symbol attributes.
         # field_mapping already contains only declared attributes.
         def fields_to_symbol_attributes(fields)
@@ -148,9 +155,8 @@ module Airtable
           parsed = response.body
 
           if response.success?
-            parsed = parsed.with_indifferent_access if parsed.is_a?(Hash)
-            response_records = parsed[:records] || []
-            response_by_id = response_records.index_by { |r| r[:id] }
+            response_records = (parsed.is_a?(Hash) && parsed["records"]) || []
+            response_by_id = response_records.index_by { |r| r["id"] }
 
             batch.each do |record|
               record_data = response_by_id[record.id]
@@ -163,7 +169,7 @@ module Airtable
             end
           else
             batch.each { |record| result.failed << record }
-            error_message = parsed.is_a?(Hash) ? parsed.with_indifferent_access.dig(:error, :message) : parsed
+            error_message = parsed.is_a?(Hash) ? parsed.dig("error", "message") : parsed
             ORM.config.logger.error(
               "Airtable batch update failed: HTTP #{response.status}: #{error_message.to_s.truncate(200)}"
             )
@@ -312,13 +318,12 @@ module Airtable
       def apply_response_fields(data)
         @previously_new_record = new_record?
 
-        data = data.with_indifferent_access
-        symbol_attrs = self.class.fields_to_symbol_attributes(data[:fields])
+        symbol_attrs = self.class.fields_to_symbol_attributes(data["fields"])
         symbol_attrs.each { |key, value| write_raw_attribute(key, value) }
 
         assign_persistence_state(
-          id: data[:id],
-          created_at: data[:createdTime] ? Time.iso8601(data[:createdTime].to_s) : nil,
+          id: data["id"],
+          created_at: self.class.parse_created_time(data),
           persisted: true
         )
         changes_applied

data/lib/airtable/orm/schema.rb

@@ -19,10 +19,6 @@ module Airtable
 
         private
 
-        def required_table_ids
-          ORM.config.table_ids
-        end
-
         def fetch_from_api(base_id)
           response = client.connection.get("/v0/meta/bases/#{base_id}/tables")
           parsed_response = response.body
@@ -34,12 +30,13 @@ module Airtable
           end
         end
 
+        # Index the FULL base schema — no filtering by the tables configured at fetch time.
+        # The cached payload outlives the config (24h, shared store in Rails hosts), so a
+        # fetch-time filter would hide tables added to config after the cache warmed up.
+        # Reads are keyed lookups (fetch(base_id)[table_id]), so no read-time filter is needed.
         def indexed_schema(parsed_response)
           tables = parsed_response.deep_symbolize_keys[:tables]
 
-          # Filter only required tables
-          tables.select! { |table| required_table_ids.include?(table[:id]) }
-
           # Transform fields into hash indexed by field id
           tables.each do |table|
             table[:fields] = table[:fields].index_by { |field| field[:id] }

data/lib/airtable/orm/version.rb

@@ -2,6 +2,6 @@
 
 module Airtable
   module ORM
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: airtable-orm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Roman Sklenar