carddb 0.2.1 → 0.3.0

data/lib/carddb/resources/decks.rb

@@ -3,11 +3,12 @@
 module CardDB
   module Resources
     # Decks resource for hosted decks and external deck hydration.
+    # rubocop:disable Metrics/ClassLength
     class Decks < Base
       # List decks owned by the current account or API application.
-      def list_mine(first: nil, after: nil, cache: nil)
-        query = QueryBuilder.list_my_decks(first: first, after: after)
-        variables = build_variables(first: first, after: after)
+      def list_mine(first: nil, after: nil, include_archived: nil, cache: nil)
+        query = QueryBuilder.list_my_decks(first: first, after: after, include_archived: include_archived)
+        variables = build_variables(first: first, after: after, includeArchived: include_archived)
         key = cache_key('decks', 'list_mine', **variables)
 
         data = with_cache(key, resource: :decks, cache: cache) do
@@ -17,7 +18,65 @@ module CardDB
         Collection.new(
           data['myDecks'],
           item_class: Deck,
-          next_page_loader: ->(cursor) { list_mine(first: first, after: cursor, cache: cache) },
+          next_page_loader: lambda { |cursor|
+            list_mine(first: first, after: cursor, include_archived: include_archived, cache: cache)
+          },
+          client: client
+        )
+      end
+
+      # List decks owned by the current account or OAuth grant.
+      def list_viewer(filter: nil, first: nil, after: nil, cache: nil)
+        query = QueryBuilder.viewer_decks(filter: filter, first: first, after: after)
+        variables = build_variables(filter: filter, first: first, after: after)
+        key = cache_key('decks', 'list_viewer', **variables)
+
+        data = with_cache(key, resource: :decks, cache: cache) do
+          connection.execute(query, variables)
+        end
+
+        Collection.new(
+          data['viewerDecks'],
+          item_class: Deck,
+          next_page_loader: ->(cursor) { list_viewer(filter: filter, first: first, after: cursor, cache: cache) },
+          client: client
+        )
+      end
+
+      # List app-owned decks for the current secret-key API application.
+      def list_app(filter: nil, first: nil, after: nil, cache: nil)
+        config.require_secret_credential!('decks.list_app')
+
+        query = QueryBuilder.app_decks(filter: filter, first: first, after: after)
+        variables = build_variables(filter: filter, first: first, after: after)
+        key = cache_key('decks', 'list_app', **variables)
+
+        data = with_cache(key, resource: :decks, cache: cache) do
+          connection.execute(query, variables)
+        end
+
+        Collection.new(
+          data['appDecks'],
+          item_class: Deck,
+          next_page_loader: ->(cursor) { list_app(filter: filter, first: first, after: cursor, cache: cache) },
+          client: client
+        )
+      end
+
+      # List published live decks eligible for public discovery.
+      def list_public(filter: nil, first: nil, after: nil, cache: nil)
+        query = QueryBuilder.public_decks(filter: filter, first: first, after: after)
+        variables = build_variables(filter: filter, first: first, after: after)
+        key = cache_key('decks', 'list_public', **variables)
+
+        data = with_cache(key, resource: :decks, cache: cache) do
+          connection.execute(query, variables)
+        end
+
+        Collection.new(
+          data['publicDecks'],
+          item_class: Deck,
+          next_page_loader: ->(cursor) { list_public(filter: filter, first: first, after: cursor, cache: cache) },
           client: client
         )
       end
@@ -31,6 +90,15 @@ module CardDB
         end
       end
 
+      # Fetch by UUID using the ownership-aware deck API.
+      def get(id, cache: nil)
+        key = cache_key('decks', 'get', id: id)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck, { id: id })
+          data['deck'] ? Deck.new(data['deck'], client: client) : nil
+        end
+      end
+
       # Fetch one deck owned by the current account or API application.
       def fetch_mine(id, cache: nil)
         key = cache_key('decks', 'fetch_mine', id: id)
@@ -56,6 +124,22 @@ module CardDB
         end
       end
 
+      # Fetch by slug using the ownership-aware deckBySlug API.
+      def get_by_slug(slug:, publisher_slug: nil, game_key: nil, cache: nil)
+        resolved_publisher = resolve_publisher(publisher_slug)
+        resolved_game = resolve_game(game_key)
+        validate_access!(resolved_publisher, resolved_game)
+
+        key = cache_key('decks', 'get_by_slug', publisher_slug: resolved_publisher, game_key: resolved_game, slug: slug)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(
+            QueryBuilder.deck_by_slug,
+            { publisherSlug: resolved_publisher, gameKey: resolved_game, slug: slug }
+          )
+          data['deckBySlug'] ? Deck.new(data['deckBySlug'], client: client) : nil
+        end
+      end
+
       # Fetch a hosted deck by external reference for the current API application.
       def fetch_by_external_ref(external_ref:, cache: nil)
         key = cache_key('decks', 'fetch_by_external_ref', external_ref: external_ref)
@@ -65,6 +149,15 @@ module CardDB
         end
       end
 
+      # Fetch by external reference using the ownership-aware deckByExternalRef API.
+      def get_by_external_ref(external_ref:, cache: nil)
+        key = cache_key('decks', 'get_by_external_ref', external_ref: external_ref)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_by_external_ref, { externalRef: external_ref })
+          data['deckByExternalRef'] ? Deck.new(data['deckByExternalRef'], client: client) : nil
+        end
+      end
+
       # Fetch one immutable published deck version.
       def fetch_version(id, cache: nil)
         key = cache_key('decks', 'fetch_version', id: id)
@@ -101,6 +194,96 @@ module CardDB
         end
       end
 
+      # Fetch published embed data using a revocable embed token.
+      def embed(token:, cache: nil)
+        key = cache_key('decks', 'embed', token: token)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_embed, { token: token })
+          data['deckEmbed'] ? Deck.new(data['deckEmbed'], client: client) : nil
+        end
+      end
+
+      # Fetch token-authorized published data using an exchanged access token.
+      def access(token:, cache: nil)
+        key = cache_key('decks', 'access', token: token)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_access, { token: token })
+          data['deckAccess'] ? Deck.new(data['deckAccess'], client: client) : nil
+        end
+      end
+
+      def draft_diff(id:, cache: nil)
+        key = cache_key('decks', 'draft_diff', id: id)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_draft_diff, { id: id })
+          DeckDiff.new(data['deckDraftDiff'], client: client)
+        end
+      end
+
+      def version_diff(from_version_id:, to_version_id:, cache: nil)
+        variables = { fromVersionId: from_version_id, toVersionId: to_version_id }
+        key = cache_key('decks', 'version_diff', **variables)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_version_diff, variables)
+          DeckDiff.new(data['deckVersionDiff'], client: client)
+        end
+      end
+
+      def validate(id:, input: nil, cache: nil)
+        variables = build_variables(id: id, input: input)
+        key = cache_key('decks', 'validate', **variables)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_validate, variables)
+          DeckValidation.new(data['deckValidate'], client: client)
+        end
+      end
+
+      def hydrate_deck_entries(input:, cache: nil)
+        key = cache_key('decks', 'hydrate_deck_entries', input: input)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_hydrate_entries, { input: input })
+          DeckHydrateEntriesPayload.new(data['deckHydrateEntries'], client: client)
+        end
+      end
+
+      def export_deck(id:, format: 'SIMPLE_TEXT', cache: nil)
+        variables = { id: id, format: format }
+        key = cache_key('decks', 'export_deck', **variables)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_export, variables)
+          DeckExportPayload.new(data['deckExport'], client: client)
+        end
+      end
+
+      def section_definitions(
+        publisher_slug: nil,
+        game_key: nil,
+        game_id: nil,
+        ruleset_key: nil,
+        ruleset_version_id: nil,
+        cache: nil
+      )
+        query = QueryBuilder.deck_section_definitions(
+          publisher_slug: publisher_slug,
+          game_key: game_key,
+          game_id: game_id,
+          ruleset_key: ruleset_key,
+          ruleset_version_id: ruleset_version_id
+        )
+        variables = build_variables(
+          publisherSlug: publisher_slug,
+          gameKey: game_key,
+          gameId: game_id,
+          rulesetKey: ruleset_key,
+          rulesetVersionId: ruleset_version_id
+        )
+        key = cache_key('decks', 'section_definitions', **variables)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(query, variables)
+          (data['deckSectionDefinitions'] || []).map { |definition| DeckSectionDefinition.new(definition, client: client) }
+        end
+      end
+
       # List collaborators for a deck.
       def collaborators(deck_id:, cache: nil)
         key = cache_key('decks', 'collaborators', deck_id: deck_id)
@@ -119,6 +302,44 @@ module CardDB
         end
       end
 
+      def embed_tokens(deck_id:, cache: nil)
+        key = cache_key('decks', 'embed_tokens', deck_id: deck_id)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_embed_tokens, { deckId: deck_id })
+          (data['deckEmbedTokens'] || []).map { |token| DeckEmbedToken.new(token, client: client) }
+        end
+      end
+
+      def access_token_issuers(deck_id:, cache: nil)
+        key = cache_key('decks', 'access_token_issuers', deck_id: deck_id)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_access_token_issuers, { deckId: deck_id })
+          (data['deckAccessTokenIssuers'] || []).map { |issuer| DeckAccessTokenIssuer.new(issuer, client: client) }
+        end
+      end
+
+      def api_application_accesses(deck_id:, include_revoked: nil, cache: nil)
+        variables = build_variables(deckId: deck_id, includeRevoked: include_revoked)
+        key = cache_key('decks', 'api_application_accesses', **variables)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_api_application_accesses, variables)
+          (data['deckApiApplicationAccesses'] || []).map do |access|
+            DeckAPIApplicationAccess.new(access, client: client)
+          end
+        end
+      end
+
+      def my_api_application_accesses(application_id: nil, cache: nil)
+        variables = build_variables(applicationId: application_id)
+        key = cache_key('decks', 'my_api_application_accesses', **variables)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.my_deck_api_application_accesses, variables)
+          (data['myDeckApiApplicationAccesses'] || []).map do |access|
+            DeckAPIApplicationAccess.new(access, client: client)
+          end
+        end
+      end
+
       # Create a hosted deck.
       def create(input:)
         data = connection.execute(QueryBuilder.create_deck, { input: input })
@@ -131,10 +352,154 @@ module CardDB
         Deck.new(data['deckUpdate'], client: client)
       end
 
+      # Update deck-level metadata without mutating entries.
+      def update_metadata(id:, input:)
+        update(id: id, input: input)
+      end
+
+      def upsert_by_external_ref(input:)
+        config.require_secret_credential!('decks.upsert_by_external_ref')
+
+        data = connection.execute(QueryBuilder.upsert_deck_by_external_ref, { input: input })
+        DeckUpsertByExternalRefPayload.new(data['deckUpsertByExternalRef'], client: client)
+      end
+
+      def claim(id:, input:)
+        data = connection.execute(QueryBuilder.claim_deck, { id: id, input: input })
+        DeckOwnershipTransferPayload.new(data['deckClaim'], client: client)
+      end
+
+      def transfer_ownership(id:, input:)
+        data = connection.execute(QueryBuilder.transfer_deck_ownership, { id: id, input: input })
+        DeckOwnershipTransferPayload.new(data['deckTransferOwnership'], client: client)
+      end
+
+      def copy(id:, input:)
+        data = connection.execute(QueryBuilder.copy_deck, { id: id, input: input })
+        DeckCopyPayload.new(data['deckCopy'], client: client)
+      end
+
+      def add_entry(input:)
+        data = connection.execute(QueryBuilder.add_deck_entry, { input: input })
+        DeckEntryMutationPayload.new(data['deckEntryAdd'], client: client)
+      end
+
+      def update_entry(id:, input:)
+        data = connection.execute(QueryBuilder.update_deck_entry, { id: id, input: input })
+        DeckEntryMutationPayload.new(data['deckEntryUpdate'], client: client)
+      end
+
+      def remove_entry(id:, expected_draft_revision:)
+        data = connection.execute(
+          QueryBuilder.remove_deck_entry,
+          { id: id, expectedDraftRevision: expected_draft_revision }
+        )
+        DeckEntryMutationPayload.new(data['deckEntryRemove'], client: client)
+      end
+
+      def reorder_entries(deck_id:, input:)
+        data = connection.execute(QueryBuilder.reorder_deck_entries, { deckId: deck_id, input: input })
+        DeckEntryReorderPayload.new(data['deckEntryReorder'], client: client)
+      end
+
+      def replace_entries(deck_id:, input:)
+        data = connection.execute(QueryBuilder.replace_deck_entries, { deckId: deck_id, input: input })
+        DeckEntriesReplacePayload.new(data['deckEntriesReplace'], client: client)
+      end
+
+      # Import a decklist into an existing deck or dry-run resolution.
+      def import_deck(input:)
+        data = connection.execute(QueryBuilder.import_deck, { input: input })
+        DeckImportPayload.new(data['deckImport'], client: client)
+      end
+
+      def import_formats(game_id:, include_archived: nil, first: nil, after: nil, cache: nil)
+        query = QueryBuilder.deck_import_formats(
+          game_id: game_id,
+          include_archived: include_archived,
+          first: first,
+          after: after
+        )
+        variables = build_variables(gameId: game_id, includeArchived: include_archived, first: first, after: after)
+        key = cache_key('decks', 'import_formats', **variables)
+
+        data = with_cache(key, resource: :decks, cache: cache) do
+          connection.execute(query, variables)
+        end
+
+        Collection.new(
+          data['deckImportFormats'],
+          item_class: DeckImportFormatDefinition,
+          next_page_loader: lambda { |cursor|
+            import_formats(
+              game_id: game_id,
+              include_archived: include_archived,
+              first: first,
+              after: cursor,
+              cache: cache
+            )
+          },
+          client: client
+        )
+      end
+
+      def fetch_import_format(id, cache: nil)
+        key = cache_key('decks', 'fetch_import_format', id: id)
+        with_cache(key, resource: :decks, cache: cache) do
+          data = connection.execute(QueryBuilder.deck_import_format, { id: id })
+          data['deckImportFormat'] ? DeckImportFormatDefinition.new(data['deckImportFormat'], client: client) : nil
+        end
+      end
+
+      def test_import_format(input:)
+        data = connection.execute(QueryBuilder.deck_import_format_test, { input: input })
+        DeckImportFormatTestPayload.new(data['deckImportFormatTest'], client: client)
+      end
+
+      def create_import_format(input:)
+        data = connection.execute(QueryBuilder.create_deck_import_format, { input: input })
+        DeckImportFormatDefinition.new(data['deckImportFormatCreate'], client: client)
+      end
+
+      def update_import_format(id:, input:)
+        data = connection.execute(QueryBuilder.update_deck_import_format, { id: id, input: input })
+        DeckImportFormatDefinition.new(data['deckImportFormatUpdate'], client: client)
+      end
+
+      def archive_import_format(id:)
+        data = connection.execute(QueryBuilder.archive_deck_import_format, { id: id })
+        DeckImportFormatDefinition.new(data['deckImportFormatArchive'], client: client)
+      end
+
+      def unarchive_import_format(id:)
+        data = connection.execute(QueryBuilder.unarchive_deck_import_format, { id: id })
+        DeckImportFormatDefinition.new(data['deckImportFormatUnarchive'], client: client)
+      end
+
       # Publish the current draft as an immutable deck version.
-      def publish(id:, input: {})
+      def publish(id:, input:)
         data = connection.execute(QueryBuilder.publish_deck, { id: id, input: input })
-        DeckVersion.new(data['deckPublish'], client: client)
+        DeckPublishPayload.new(data['deckPublish'], client: client)
+      end
+
+      def remove_invalid_entries(id:, input:)
+        data = connection.execute(QueryBuilder.remove_invalid_deck_entries, { id: id, input: input })
+        Deck.new(data['deckRemoveInvalidEntries'], client: client)
+      end
+
+      def archive(id:)
+        data = connection.execute(QueryBuilder.archive_deck, { id: id })
+        Deck.new(data['deckArchive'], client: client)
+      end
+
+      def restore(id:)
+        data = connection.execute(QueryBuilder.restore_deck, { id: id })
+        Deck.new(data['deckRestore'], client: client)
+      end
+
+      def unpublish(id:)
+        data = connection.execute(QueryBuilder.unpublish_deck, { id: id })
+        Deck.new(data['deckUnpublish'], client: client)
       end
 
       # Create or update a deck collaborator.
@@ -171,6 +536,66 @@ module CardDB
       end
       # rubocop:enable Naming/PredicateMethod
 
+      def create_embed_token(input:)
+        data = connection.execute(QueryBuilder.create_deck_embed_token, { input: input })
+        DeckEmbedTokenCreatePayload.new(data['deckEmbedTokenCreate'], client: client)
+      end
+
+      # rubocop:disable Naming/PredicateMethod
+      def revoke_embed_token(id:)
+        data = connection.execute(QueryBuilder.revoke_deck_embed_token, { id: id })
+        !!data['deckEmbedTokenRevoke']
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      def create_access_token_issuer(input:)
+        data = connection.execute(QueryBuilder.create_deck_access_token_issuer, { input: input })
+        DeckAccessTokenIssuer.new(data['deckAccessTokenIssuerCreate'], client: client)
+      end
+
+      # rubocop:disable Naming/PredicateMethod
+      def revoke_access_token_issuer(id:)
+        data = connection.execute(QueryBuilder.revoke_deck_access_token_issuer, { id: id })
+        !!data['deckAccessTokenIssuerRevoke']
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      def revoke_access_token_issuer_signing_key(id:)
+        data = connection.execute(QueryBuilder.revoke_deck_access_token_issuer_signing_key, { id: id })
+        DeckAccessTokenIssuer.new(data['deckAccessTokenIssuerSigningKeyRevoke'], client: client)
+      end
+
+      def grant_api_application_access(input:)
+        data = connection.execute(QueryBuilder.grant_deck_api_application_access, { input: input })
+        DeckAPIApplicationAccess.new(data['deckApiApplicationAccessGrant'], client: client)
+      end
+
+      # rubocop:disable Naming/PredicateMethod
+      def revoke_api_application_access(deck_id:, api_application_id:)
+        data = connection.execute(
+          QueryBuilder.revoke_deck_api_application_access,
+          { deckId: deck_id, apiApplicationId: api_application_id }
+        )
+        !!data['deckApiApplicationAccessRevoke']
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      def exchange_access_token(input:)
+        config.require_secret_credential!('decks.exchange_access_token')
+
+        data = connection.execute(QueryBuilder.exchange_deck_access_token, { input: input })
+        DeckAccessTokenExchangePayload.new(data['deckAccessTokenExchange'], client: client)
+      end
+
+      # rubocop:disable Naming/PredicateMethod
+      def revoke_access_token(id:)
+        config.require_secret_credential!('decks.revoke_access_token')
+
+        data = connection.execute(QueryBuilder.revoke_deck_access_token, { id: id })
+        !!data['deckAccessTokenRevoke']
+      end
+      # rubocop:enable Naming/PredicateMethod
+
       # Delete a hosted deck.
       # rubocop:disable Naming/PredicateMethod
       def delete(id:)
@@ -240,5 +665,6 @@ module CardDB
         record.record_data&.values&.find { |value| remaining[value.to_s] }
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/carddb/resources/records.rb

@@ -18,6 +18,7 @@ module CardDB
       # @param first [Integer, nil] Maximum number of results
       # @param after [String, nil] Cursor for pagination
       # @param validate_schema [Boolean, nil] Whether to validate against schema
+      # @param include_pricing [Boolean] Include live TCGPlayer pricing when configured
       # @yield [FilterBuilder] Optional block for filter DSL
       # @return [Collection<Record>] Collection of records
       #
@@ -35,7 +36,7 @@ module CardDB
       #     dataset_key: "cards",
       #     filter: { "type" => "creature" }
       #   )
-      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
       def search(
         dataset_key:,
         publisher_slug: nil,
@@ -47,6 +48,7 @@ module CardDB
         first: nil,
         after: nil,
         validate_schema: nil,
+        include_pricing: false,
         &block
       )
         resolved_publisher = resolve_publisher(publisher_slug)
@@ -71,7 +73,8 @@ module CardDB
           resolve_links: resolve_links,
           first: first,
           after: after,
-          validate_schema: validate_schema
+          validate_schema: validate_schema,
+          include_pricing: include_pricing
         )
 
         variables = build_variables(
@@ -99,7 +102,8 @@ module CardDB
           order_by: order_by,
           resolve_links: resolve_links,
           first: first,
-          validate_schema: validate_schema
+          validate_schema: validate_schema,
+          include_pricing: include_pricing
         }
 
         next_page_loader = lambda do |cursor|
@@ -113,17 +117,18 @@ module CardDB
           client: client
         )
       end
-      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
 
       # Fetch a single record by ID
       #
       # @param id [String] The record UUID
       # @param cache [Boolean, nil] Whether to cache (nil = use config setting)
+      # @param include_pricing [Boolean] Include live TCGPlayer pricing when configured
       # @return [Record, nil] The record or nil if not found
-      def fetch(id, cache: nil)
-        key = cache_key('records', 'fetch', id: id)
+      def fetch(id, cache: nil, include_pricing: false)
+        key = cache_key('records', 'fetch', id: id, include_pricing: include_pricing)
         with_cache(key, resource: :records, cache: cache) do
-          query = QueryBuilder.fetch_record
+          query = QueryBuilder.fetch_record(include_pricing: include_pricing)
           data = connection.execute(query, { id: id })
 
           return nil unless data['fetchRecord']
@@ -142,20 +147,29 @@ module CardDB
       # @param publisher_slug [String, nil] Publisher slug (uses default if not provided)
       # @param game_key [String, nil] Game key (uses default if not provided)
       # @param cache [Boolean, nil] Whether to cache (nil = use config setting)
+      # @param include_pricing [Boolean] Include live TCGPlayer pricing when configured
       # @return [Record, nil] The record or nil if not found
       #
       # @example
       #   record = client.records.get(identifier: "xy1-1", dataset_key: "cards")
-      def get(identifier:, dataset_key:, publisher_slug: nil, game_key: nil, cache: nil)
+      def get(
+        identifier:,
+        dataset_key:,
+        publisher_slug: nil,
+        game_key: nil,
+        cache: nil,
+        include_pricing: false
+      )
         resolved_publisher = resolve_publisher(publisher_slug)
         resolved_game = resolve_game(game_key)
 
         validate_access!(resolved_publisher, resolved_game)
 
         key = cache_key('records', 'get', publisher_slug: resolved_publisher, game_key: resolved_game,
-                                          dataset_key: dataset_key, identifier: identifier)
+                                          dataset_key: dataset_key, identifier: identifier,
+                                          include_pricing: include_pricing)
         with_cache(key, resource: :records, cache: cache) do
-          query = QueryBuilder.fetch_record_by_identifier
+          query = QueryBuilder.fetch_record_by_identifier(include_pricing: include_pricing)
           variables = {
             publisherSlug: resolved_publisher,
             gameKey: resolved_game,
@@ -181,6 +195,7 @@ module CardDB
       # @param publisher_slug [String, nil] Publisher slug (uses default if not provided)
       # @param game_key [String, nil] Game key (uses default if not provided)
       # @param cache [Boolean, nil] Whether to cache (nil = use config setting)
+      # @param include_pricing [Boolean] Include live TCGPlayer pricing when configured
       # @return [Array<Record>] Matching records
       # @raise [ArgumentError] If more than 1000 identifiers are provided
       #
@@ -189,7 +204,14 @@ module CardDB
       #     identifiers: ["xy1-1", "xy1-2"],
       #     dataset_key: "cards"
       #   )
-      def get_many(identifiers:, dataset_key:, publisher_slug: nil, game_key: nil, cache: nil)
+      def get_many(
+        identifiers:,
+        dataset_key:,
+        publisher_slug: nil,
+        game_key: nil,
+        cache: nil,
+        include_pricing: false
+      )
         raise ArgumentError, 'Maximum 1000 identifiers allowed' if identifiers.length > 1000
         return [] if identifiers.empty?
 
@@ -204,10 +226,11 @@ module CardDB
           publisher_slug: resolved_publisher,
           game_key: resolved_game,
           dataset_key: dataset_key,
-          identifiers: identifiers
+          identifiers: identifiers,
+          include_pricing: include_pricing
         )
         with_cache(key, resource: :records, cache: cache) do
-          query = QueryBuilder.fetch_records_by_identifier
+          query = QueryBuilder.fetch_records_by_identifier(include_pricing: include_pricing)
           variables = {
             publisherSlug: resolved_publisher,
             gameKey: resolved_game,
@@ -224,12 +247,13 @@ module CardDB
       # Fetch multiple records by IDs
       #
       # @param ids [Array<String>] Array of record UUIDs (max 1000)
+      # @param include_pricing [Boolean] Include live TCGPlayer pricing when configured
       # @return [Array<Record>] Array of records
       # @raise [ArgumentError] If more than 1000 IDs provided
-      def fetch_many(ids)
+      def fetch_many(ids, include_pricing: false)
         raise ArgumentError, 'Maximum 1000 IDs allowed' if ids.length > 1000
 
-        query = QueryBuilder.fetch_records
+        query = QueryBuilder.fetch_records(include_pricing: include_pricing)
         data = connection.execute(query, { ids: ids })
 
         (data['fetchRecords'] || []).map { |r| Record.new(r, client: client) }

data/lib/carddb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CardDB
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carddb
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - CardDB Team