airtable-orm 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 970cedc7b68168b8add9fa80225982de0e902758bfb0dbfb7b3d04184c292871
-  data.tar.gz: 9e45c6326f0daa9b07eee7f6aa81601217437f40022ca05a34c85d0fd17714f1
+  metadata.gz: be3a4c1ecff6395abd45d69731ac804de74bf2fdd06127c2c4b5a9d3c9417c6b
+  data.tar.gz: 8dbb4c9e8a0c087a09d64685e7c974a044c0cea9b3f4eb554a952492065181ff
 SHA512:
-  metadata.gz: 3812676e76a07ae378a285030f30c8175fc9bb23670d626d2103e44611894785f962554d3cd9737c9c88f2ba6aaf9b8d80c8d5ee6e9401ca0a5da6b413ba7dcd
-  data.tar.gz: 0bc1ea55739db84a90a92b8389d3df1c37121e496838388ec863621e3e8fb13adc6cbb54ee19e9f09f2c0eeebf8b20dd70521a6e827b6b6d384dca4230f9f35d
+  metadata.gz: c09d85ccb058caa27c77d568c82c8e72eed4950a610e358278994eed7c0456ef45798f125ee6729a65a903b865ae167e7180a5b1a26db1107c79e0c549beceb9
+  data.tar.gz: 6727276b68304892c7df6e896bcb1117efbc0a4266da3fe40e5ce9f0b4c46f8327e964f3ada9537b6093ea92fbe4ed4485c3abccaa94aa4af38093c335e7cde2

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 ## [Unreleased]
 
+## [0.2.2] - 2026-09-24
+
+### Fixed
+
+- `find` raises `RecordNotFound` for a deleted/nonexistent record ID. Airtable answers such a
+  GET with `403 INVALID_PERMISSIONS_OR_MODEL_NOT_FOUND`, not 404, so it used to surface as a
+  plain `ApiError`. Because a revoked token or lost table permission returns the same 403, `find`
+  now disambiguates with one probe of the table (a one-record, no-fields list request): readable
+  → `RecordNotFound`, otherwise the original `ApiError` is re-raised; a `ConnectionError` during
+  the probe propagates. The 404 mapping is unchanged. `reload` and `belongs_to` (which reads a
+  stale link as `nil`) benefit accordingly.
+- `ApiError` is raised (instead of a `TypeError`) for Airtable's bare string error body such as
+  `{"error": "NOT_FOUND"}`, which previously broke the 404 → `RecordNotFound` mapping in `find`.
+
+## [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/http/client.rb

@@ -66,11 +66,13 @@ module Airtable
           ERB::Util.url_encode(string)
         end
 
-        # Parse an Airtable API error response and raise an ApiError.
+        # Parse an Airtable API error response and raise an ApiError. Airtable sends either
+        # {"error" => {"type", "message"}} or a bare {"error" => "NOT_FOUND"} (e.g. on 404).
         def self.raise_api_error(status, error)
-          type = (error.is_a?(Hash) && error.dig("error", "type")) || "Communication error"
+          detail = error.is_a?(Hash) ? error["error"] : nil
+          type = (detail.is_a?(Hash) ? detail["type"] : detail) || "Communication error"
           msg = case error
-                when Hash then error.dig("error", "message")
+                when Hash then detail.is_a?(Hash) ? detail["message"] : nil
                 when String then error
                 when NilClass then "invalid or empty response body (not valid JSON)"
                 else error.inspect

data/lib/airtable/orm/persistence.rb

@@ -74,7 +74,9 @@ module Airtable
             Airtable::ORM::Http::Client.raise_api_error(response.status, parsed_response)
           end
         rescue Airtable::ORM::ApiError => e
-          raise Airtable::ORM::RecordNotFound, "Couldn't find record with id=#{id}" if e.status == 404
+          if e.status == 404 || (missing_record_forbidden?(e) && table_readable?)
+            raise Airtable::ORM::RecordNotFound, "Couldn't find record with id=#{id}"
+          end
 
           raise
         end
@@ -111,21 +113,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)
@@ -138,6 +147,22 @@ module Airtable
 
         private
 
+        # Airtable answers a GET for a nonexistent (e.g. deleted) record ID with this 403, not
+        # 404 — the same response a token without access to the table/base gets.
+        def missing_record_forbidden?(error)
+          error.status == 403 && error.response.is_a?(Hash) &&
+            error.response.dig("error", "type") == "INVALID_PERMISSIONS_OR_MODEL_NOT_FOUND"
+        end
+
+        # Disambiguates that 403 with one cheap list request (one record, no fields): readable
+        # table → the record is gone. Never map the 403 blindly — a revoked token or lost
+        # permission would then look like "every record deleted" to the host. A ConnectionError
+        # still propagates (retryable, not evidence either way).
+        def table_readable?
+          response = client.connection.post(api_path("listRecords"), { maxRecords: 1, fields: [] })
+          response.success?
+        end
+
         # Send a single batch PATCH request to Airtable.
         def send_batch_update(batch, result)
           body = {
@@ -148,9 +173,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 +187,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 +336,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.2"
   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.2
 platform: ruby
 authors:
 - Roman Sklenar