carddb 0.2.1 → 0.3.0

data/lib/carddb/query_builder.rb

@@ -165,6 +165,7 @@ module CardDB
       end
 
       # Builds a searchRecords query
+      # rubocop:disable Metrics/ParameterLists
       def search_records(
         publisher_slug:,
         game_key:,
@@ -175,7 +176,8 @@ module CardDB
         resolve_links: nil,
         first: nil,
         after: nil,
-        validate_schema: nil
+        validate_schema: nil,
+        include_pricing: false
       )
         args = build_args(
           {
@@ -196,59 +198,63 @@ module CardDB
         <<~GRAPHQL
           query SearchRecords#{args[:definition]} {
             searchRecords#{args[:call]} {
-              #{record_connection_fields(include_resolved_links: resolve_links&.any?)}
+              #{record_connection_fields(
+                include_resolved_links: resolve_links&.any?,
+                include_pricing: include_pricing
+              )}
             }
           }
         GRAPHQL
       end
+      # rubocop:enable Metrics/ParameterLists
 
       # Builds a fetchRecordByIdentifier query
-      def fetch_record_by_identifier
+      def fetch_record_by_identifier(include_pricing: false)
         <<~GRAPHQL
           query FetchRecordByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifier: String!) {
             fetchRecordByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifier: $identifier) {
-              #{record_fields}
+              #{record_fields(include_pricing: include_pricing)}
             }
           }
         GRAPHQL
       end
 
       # Builds a fetchRecordsByIdentifier query
-      def fetch_records_by_identifier
+      def fetch_records_by_identifier(include_pricing: false)
         <<~GRAPHQL
           query FetchRecordsByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifiers: [String!]!) {
             fetchRecordsByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifiers: $identifiers) {
-              #{record_fields}
+              #{record_fields(include_pricing: include_pricing)}
             }
           }
         GRAPHQL
       end
 
       # Builds a fetchRecord query
-      def fetch_record
+      def fetch_record(include_pricing: false)
         <<~GRAPHQL
           query FetchRecord($id: UUID!) {
             fetchRecord(id: $id) {
-              #{record_fields}
+              #{record_fields(include_pricing: include_pricing)}
             }
           }
         GRAPHQL
       end
 
       # Builds a fetchRecords query
-      def fetch_records
+      def fetch_records(include_pricing: false)
         <<~GRAPHQL
           query FetchRecords($ids: [UUID!]!) {
             fetchRecords(ids: $ids) {
-              #{record_fields}
+              #{record_fields(include_pricing: include_pricing)}
             }
           }
         GRAPHQL
       end
 
       # Builds a myDecks query
-      def list_my_decks(first: nil, after: nil)
-        args = build_args({ first: first, after: after })
+      def list_my_decks(first: nil, after: nil, include_archived: nil)
+        args = build_args({ first: first, after: after, includeArchived: include_archived })
 
         <<~GRAPHQL
           query MyDecks#{args[:definition]} {
@@ -259,6 +265,51 @@ module CardDB
         GRAPHQL
       end
 
+      def viewer_decks(filter: nil, first: nil, after: nil)
+        args = build_args(
+          { filter: filter, first: first, after: after },
+          type_overrides: { filter: 'ViewerDecksFilterInput' }
+        )
+
+        <<~GRAPHQL
+          query ViewerDecks#{args[:definition]} {
+            viewerDecks#{args[:call]} {
+              #{deck_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def app_decks(filter: nil, first: nil, after: nil)
+        args = build_args(
+          { filter: filter, first: first, after: after },
+          type_overrides: { filter: 'AppDecksFilterInput' }
+        )
+
+        <<~GRAPHQL
+          query AppDecks#{args[:definition]} {
+            appDecks#{args[:call]} {
+              #{deck_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def public_decks(filter: nil, first: nil, after: nil)
+        args = build_args(
+          { filter: filter, first: first, after: after },
+          type_overrides: { filter: 'PublicDecksFilterInput' }
+        )
+
+        <<~GRAPHQL
+          query PublicDecks#{args[:definition]} {
+            publicDecks#{args[:call]} {
+              #{deck_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a fetchDeck query
       def fetch_deck
         <<~GRAPHQL
@@ -270,6 +321,16 @@ module CardDB
         GRAPHQL
       end
 
+      def deck
+        <<~GRAPHQL
+          query Deck($id: UUID!) {
+            deck(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a myDeck query
       def my_deck
         <<~GRAPHQL
@@ -292,6 +353,16 @@ module CardDB
         GRAPHQL
       end
 
+      def deck_by_slug
+        <<~GRAPHQL
+          query DeckBySlug($publisherSlug: String!, $gameKey: String!, $slug: String!) {
+            deckBySlug(publisherSlug: $publisherSlug, gameKey: $gameKey, slug: $slug) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a fetchDeckByExternalRef query
       def fetch_deck_by_external_ref
         <<~GRAPHQL
@@ -303,6 +374,16 @@ module CardDB
         GRAPHQL
       end
 
+      def deck_by_external_ref
+        <<~GRAPHQL
+          query DeckByExternalRef($externalRef: String!) {
+            deckByExternalRef(externalRef: $externalRef) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a deckVersion query
       def deck_version
         <<~GRAPHQL
@@ -338,6 +419,94 @@ module CardDB
         GRAPHQL
       end
 
+      def deck_embed
+        <<~GRAPHQL
+          query DeckEmbed($token: String!) {
+            deckEmbed(token: $token) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_access
+        <<~GRAPHQL
+          query DeckAccess($token: String!) {
+            deckAccess(token: $token) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_draft_diff
+        <<~GRAPHQL
+          query DeckDraftDiff($id: UUID!) {
+            deckDraftDiff(id: $id) {
+              #{deck_diff_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_version_diff
+        <<~GRAPHQL
+          query DeckVersionDiff($fromVersionId: UUID!, $toVersionId: UUID!) {
+            deckVersionDiff(fromVersionId: $fromVersionId, toVersionId: $toVersionId) {
+              #{deck_diff_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_hydrate_entries
+        <<~GRAPHQL
+          query DeckHydrateEntries($input: DeckHydrateEntriesInput!) {
+            deckHydrateEntries(input: $input) {
+              #{deck_hydrate_entries_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_export
+        <<~GRAPHQL
+          query DeckExport($id: UUID!, $format: DeckExportFormat!) {
+            deckExport(id: $id, format: $format) {
+              #{deck_export_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_validate
+        <<~GRAPHQL
+          query DeckValidate($id: UUID!, $input: DeckValidateInput) {
+            deckValidate(id: $id, input: $input) {
+              #{deck_validation_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_section_definitions(publisher_slug: nil, game_key: nil, game_id: nil, ruleset_key: nil, ruleset_version_id: nil)
+        args = build_args({
+                            publisherSlug: publisher_slug,
+                            gameKey: game_key,
+                            gameId: game_id,
+                            rulesetKey: ruleset_key,
+                            rulesetVersionId: ruleset_version_id
+                          })
+
+        <<~GRAPHQL
+          query DeckSectionDefinitions#{args[:definition]} {
+            deckSectionDefinitions#{args[:call]} {
+              #{deck_section_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a deckCollaborators query
       def deck_collaborators
         <<~GRAPHQL
@@ -360,6 +529,81 @@ module CardDB
         GRAPHQL
       end
 
+      def deck_embed_tokens
+        <<~GRAPHQL
+          query DeckEmbedTokens($deckId: UUID!) {
+            deckEmbedTokens(deckId: $deckId) {
+              #{deck_embed_token_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_access_token_issuers
+        <<~GRAPHQL
+          query DeckAccessTokenIssuers($deckId: UUID!) {
+            deckAccessTokenIssuers(deckId: $deckId) {
+              #{deck_access_token_issuer_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_api_application_accesses
+        <<~GRAPHQL
+          query DeckApiApplicationAccesses($deckId: UUID!, $includeRevoked: Boolean) {
+            deckApiApplicationAccesses(deckId: $deckId, includeRevoked: $includeRevoked) {
+              #{deck_api_application_access_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def my_deck_api_application_accesses
+        <<~GRAPHQL
+          query MyDeckApiApplicationAccesses($applicationId: UUID) {
+            myDeckApiApplicationAccesses(applicationId: $applicationId) {
+              #{deck_api_application_access_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_import_formats(game_id:, include_archived: nil, first: nil, after: nil)
+        args = build_args(
+          { gameId: game_id, includeArchived: include_archived, first: first, after: after },
+          required: [:gameId]
+        )
+
+        <<~GRAPHQL
+          query DeckImportFormats#{args[:definition]} {
+            deckImportFormats#{args[:call]} {
+              #{deck_import_format_definition_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_import_format
+        <<~GRAPHQL
+          query DeckImportFormat($id: UUID!) {
+            deckImportFormat(id: $id) {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def deck_import_format_test
+        <<~GRAPHQL
+          query DeckImportFormatTest($input: DeckImportFormatTestInput!) {
+            deckImportFormatTest(input: $input) {
+              #{deck_import_format_test_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a deckCreate mutation
       def create_deck
         <<~GRAPHQL
@@ -382,139 +626,415 @@ module CardDB
         GRAPHQL
       end
 
-      # Builds a deckPublish mutation
-      def publish_deck
+      def add_deck_entry
         <<~GRAPHQL
-          mutation DeckPublish($id: UUID!, $input: DeckPublishInput!) {
-            deckPublish(id: $id, input: $input) {
-              #{deck_version_fields}
+          mutation DeckEntryAdd($input: DeckEntryAddInput!) {
+            deckEntryAdd(input: $input) {
+              #{deck_entry_mutation_payload_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckCollaboratorUpsert mutation
-      def upsert_deck_collaborator
+      def update_deck_entry
         <<~GRAPHQL
-          mutation DeckCollaboratorUpsert($deckId: UUID!, $accountId: UUID!, $role: DeckCollaboratorRole!) {
-            deckCollaboratorUpsert(deckId: $deckId, accountId: $accountId, role: $role) {
-              #{deck_collaborator_fields}
+          mutation DeckEntryUpdate($id: UUID!, $input: DeckEntryUpdateInput!) {
+            deckEntryUpdate(id: $id, input: $input) {
+              #{deck_entry_mutation_payload_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckCollaboratorRemove mutation
-      def remove_deck_collaborator
+      def remove_deck_entry
         <<~GRAPHQL
-          mutation DeckCollaboratorRemove($deckId: UUID!, $accountId: UUID!) {
-            deckCollaboratorRemove(deckId: $deckId, accountId: $accountId)
+          mutation DeckEntryRemove($id: UUID!, $expectedDraftRevision: Int!) {
+            deckEntryRemove(id: $id, expectedDraftRevision: $expectedDraftRevision) {
+              #{deck_entry_mutation_payload_fields}
+            }
           }
         GRAPHQL
       end
 
-      # Builds a deckPreviewTokenCreate mutation
-      def create_deck_preview_token
+      def reorder_deck_entries
         <<~GRAPHQL
-          mutation DeckPreviewTokenCreate($input: DeckPreviewTokenCreateInput!) {
-            deckPreviewTokenCreate(input: $input) {
-              token
-              previewToken {
-                #{deck_preview_token_fields}
-              }
+          mutation DeckEntryReorder($deckId: UUID!, $input: DeckEntryReorderInput!) {
+            deckEntryReorder(deckId: $deckId, input: $input) {
+              #{deck_entry_reorder_payload_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckPreviewTokenRevoke mutation
-      def revoke_deck_preview_token
+      def replace_deck_entries
         <<~GRAPHQL
-          mutation DeckPreviewTokenRevoke($id: UUID!) {
-            deckPreviewTokenRevoke(id: $id)
+          mutation DeckEntriesReplace($deckId: UUID!, $input: DeckEntriesReplaceInput!) {
+            deckEntriesReplace(deckId: $deckId, input: $input) {
+              #{deck_entry_reorder_payload_fields}
+            }
           }
         GRAPHQL
       end
 
-      # Builds a deckDelete mutation
-      def delete_deck
+      def import_deck
         <<~GRAPHQL
-          mutation DeckDelete($id: UUID!) {
-            deckDelete(id: $id)
+          mutation DeckImport($input: DeckImportInput!) {
+            deckImport(input: $input) {
+              #{deck_import_payload_fields}
+            }
           }
         GRAPHQL
       end
 
-      # Builds a fetchMe query
-      def fetch_me
+      def create_deck_import_format
         <<~GRAPHQL
-          query FetchMe {
-            fetchMe {
-              application {
-                id
-                name
-                description
-                environment
-                apiKeyPrefix
-                allowedOrigins
-                allowedIps
-                createdAt
-                updatedAt
-                lastUsedAt
-              }
-              account {
-                id
-                displayName
-                createdAt
-              }
+          mutation DeckImportFormatCreate($input: DeckImportFormatCreateInput!) {
+            deckImportFormatCreate(input: $input) {
+              #{deck_import_format_definition_fields}
             }
           }
         GRAPHQL
       end
 
-      private
-
-      def build_args(params, required: [])
-        # Filter out nil values
-        params = params.compact
-
-        return { definition: '', call: '' } if params.empty?
-
-        # Map Ruby types to GraphQL types (base types, without !)
-        type_map = {
-          publisherSlug: 'String',
-          gameKey: 'String',
-          datasetKey: 'String',
-          search: 'String',
-          orderBy: 'String',
-          filter: 'JSON',
-          resolveLinks: '[String!]',
-          first: 'Int',
-          after: 'String',
-          externalRef: 'String',
-          deckId: 'UUID!',
-          validateSchema: 'Boolean',
-          purpose: 'DatasetPurpose',
-          id: 'UUID!',
-          ids: '[UUID!]!'
-        }
+      def update_deck_import_format
+        <<~GRAPHQL
+          mutation DeckImportFormatUpdate($id: UUID!, $input: DeckImportFormatUpdateInput!) {
+            deckImportFormatUpdate(id: $id, input: $input) {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
 
-        definitions = params.keys.map do |k|
-          base_type = type_map[k] || 'String'
-          # Add ! for required fields (unless already has !)
-          type = required.include?(k) && !base_type.end_with?('!') ? "#{base_type}!" : base_type
-          "$#{k}: #{type}"
-        end
-        calls = params.keys.map { |k| "#{k}: $#{k}" }
+      def archive_deck_import_format
+        <<~GRAPHQL
+          mutation DeckImportFormatArchive($id: UUID!) {
+            deckImportFormatArchive(id: $id) {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        GRAPHQL
+      end
 
-        {
-          definition: "(#{definitions.join(', ')})",
-          call: "(#{calls.join(', ')})"
-        }
+      def unarchive_deck_import_format
+        <<~GRAPHQL
+          mutation DeckImportFormatUnarchive($id: UUID!) {
+            deckImportFormatUnarchive(id: $id) {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        GRAPHQL
       end
 
-      def publisher_fields
-        <<~FIELDS
+      def upsert_deck_by_external_ref
+        <<~GRAPHQL
+          mutation DeckUpsertByExternalRef($input: DeckUpsertByExternalRefInput!) {
+            deckUpsertByExternalRef(input: $input) {
+              deck {
+                #{deck_fields}
+              }
+              created
+              idempotentReplay
+            }
+          }
+        GRAPHQL
+      end
+
+      def claim_deck
+        <<~GRAPHQL
+          mutation DeckClaim($id: UUID!, $input: DeckClaimInput!) {
+            deckClaim(id: $id, input: $input) {
+              #{deck_ownership_transfer_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def transfer_deck_ownership
+        <<~GRAPHQL
+          mutation DeckTransferOwnership($id: UUID!, $input: DeckTransferOwnershipInput!) {
+            deckTransferOwnership(id: $id, input: $input) {
+              #{deck_ownership_transfer_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def copy_deck
+        <<~GRAPHQL
+          mutation DeckCopy($id: UUID!, $input: DeckCopyInput!) {
+            deckCopy(id: $id, input: $input) {
+              #{deck_copy_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def archive_deck
+        <<~GRAPHQL
+          mutation DeckArchive($id: UUID!) {
+            deckArchive(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def restore_deck
+        <<~GRAPHQL
+          mutation DeckRestore($id: UUID!) {
+            deckRestore(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def unpublish_deck
+        <<~GRAPHQL
+          mutation DeckUnpublish($id: UUID!) {
+            deckUnpublish(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckPublish mutation
+      def publish_deck
+        <<~GRAPHQL
+          mutation DeckPublish($id: UUID!, $input: DeckPublishInput!) {
+            deckPublish(id: $id, input: $input) {
+              #{deck_publish_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def remove_invalid_deck_entries
+        <<~GRAPHQL
+          mutation DeckRemoveInvalidEntries($id: UUID!, $input: DeckRemoveInvalidEntriesInput!) {
+            deckRemoveInvalidEntries(id: $id, input: $input) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckCollaboratorUpsert mutation
+      def upsert_deck_collaborator
+        <<~GRAPHQL
+          mutation DeckCollaboratorUpsert($deckId: UUID!, $accountId: UUID!, $role: DeckCollaboratorRole!) {
+            deckCollaboratorUpsert(deckId: $deckId, accountId: $accountId, role: $role) {
+              #{deck_collaborator_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckCollaboratorRemove mutation
+      def remove_deck_collaborator
+        <<~GRAPHQL
+          mutation DeckCollaboratorRemove($deckId: UUID!, $accountId: UUID!) {
+            deckCollaboratorRemove(deckId: $deckId, accountId: $accountId)
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckPreviewTokenCreate mutation
+      def create_deck_preview_token
+        <<~GRAPHQL
+          mutation DeckPreviewTokenCreate($input: DeckPreviewTokenCreateInput!) {
+            deckPreviewTokenCreate(input: $input) {
+              token
+              previewToken {
+                #{deck_preview_token_fields}
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckPreviewTokenRevoke mutation
+      def revoke_deck_preview_token
+        <<~GRAPHQL
+          mutation DeckPreviewTokenRevoke($id: UUID!) {
+            deckPreviewTokenRevoke(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def create_deck_embed_token
+        <<~GRAPHQL
+          mutation DeckEmbedTokenCreate($input: DeckEmbedTokenCreateInput!) {
+            deckEmbedTokenCreate(input: $input) {
+              token
+              embedToken {
+                #{deck_embed_token_fields}
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_embed_token
+        <<~GRAPHQL
+          mutation DeckEmbedTokenRevoke($id: UUID!) {
+            deckEmbedTokenRevoke(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def create_deck_access_token_issuer
+        <<~GRAPHQL
+          mutation DeckAccessTokenIssuerCreate($input: DeckAccessTokenIssuerCreateInput!) {
+            deckAccessTokenIssuerCreate(input: $input) {
+              #{deck_access_token_issuer_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_access_token_issuer
+        <<~GRAPHQL
+          mutation DeckAccessTokenIssuerRevoke($id: UUID!) {
+            deckAccessTokenIssuerRevoke(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_access_token_issuer_signing_key
+        <<~GRAPHQL
+          mutation DeckAccessTokenIssuerSigningKeyRevoke($id: UUID!) {
+            deckAccessTokenIssuerSigningKeyRevoke(id: $id) {
+              #{deck_access_token_issuer_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def exchange_deck_access_token
+        <<~GRAPHQL
+          mutation DeckAccessTokenExchange($input: DeckAccessTokenExchangeInput!) {
+            deckAccessTokenExchange(input: $input) {
+              token
+              accessToken {
+                #{deck_access_token_fields}
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_access_token
+        <<~GRAPHQL
+          mutation DeckAccessTokenRevoke($id: UUID!) {
+            deckAccessTokenRevoke(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def grant_deck_api_application_access
+        <<~GRAPHQL
+          mutation DeckApiApplicationAccessGrant($input: DeckAPIApplicationAccessGrantInput!) {
+            deckApiApplicationAccessGrant(input: $input) {
+              #{deck_api_application_access_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def revoke_deck_api_application_access
+        <<~GRAPHQL
+          mutation DeckApiApplicationAccessRevoke($deckId: UUID!, $apiApplicationId: UUID!) {
+            deckApiApplicationAccessRevoke(deckId: $deckId, apiApplicationId: $apiApplicationId)
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckDelete mutation
+      def delete_deck
+        <<~GRAPHQL
+          mutation DeckDelete($id: UUID!) {
+            deckDelete(id: $id)
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchMe query
+      def fetch_me
+        <<~GRAPHQL
+          query FetchMe {
+            fetchMe {
+              application {
+                id
+                name
+                description
+                environment
+                apiKeyPrefix
+                allowedOrigins
+                allowedIps
+                createdAt
+                updatedAt
+                lastUsedAt
+              }
+              account {
+                id
+                displayName
+                createdAt
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      private
+
+      def build_args(params, required: [], type_overrides: {})
+        # Filter out nil values
+        params = params.compact
+
+        return { definition: '', call: '' } if params.empty?
+
+        # Map Ruby types to GraphQL types (base types, without !)
+        type_map = {
+          publisherSlug: 'String',
+          gameKey: 'String',
+          datasetKey: 'String',
+          search: 'String',
+          orderBy: 'String',
+          filter: 'JSON',
+          resolveLinks: '[String!]',
+          first: 'Int',
+          after: 'String',
+          includeArchived: 'Boolean',
+          externalRef: 'String',
+          deckId: 'UUID!',
+          gameId: 'UUID',
+          rulesetKey: 'String',
+          rulesetVersionId: 'UUID',
+          validateSchema: 'Boolean',
+          purpose: 'DatasetPurpose',
+          id: 'UUID!',
+          ids: '[UUID!]!'
+        }
+
+        definitions = params.keys.map do |k|
+          base_type = type_overrides[k] || type_map[k] || 'String'
+          # Add ! for required fields (unless already has !)
+          type = required.include?(k) && !base_type.end_with?('!') ? "#{base_type}!" : base_type
+          "$#{k}: #{type}"
+        end
+        calls = params.keys.map { |k| "#{k}: $#{k}" }
+
+        {
+          definition: "(#{definitions.join(', ')})",
+          call: "(#{calls.join(', ')})"
+        }
+      end
+
+      def publisher_fields
+        <<~FIELDS
           id
           name
           slug
@@ -607,6 +1127,7 @@ module CardDB
           name
           description
           purpose
+          tcgplayerProductIdFieldKey
           visibility
           isArchived
           createdAt
@@ -687,11 +1208,14 @@ module CardDB
         FIELDS
       end
 
-      def record_fields
+      def record_fields(include_pricing: false)
+        pricing_fields = include_pricing ? tcgplayer_pricing_fields : ''
+
         <<~FIELDS
           id
           datasetId
           data
+          #{pricing_fields}
           createdAt
           updatedAt
           dataset {
@@ -704,7 +1228,23 @@ module CardDB
         FIELDS
       end
 
-      def record_connection_fields(include_resolved_links: false)
+      def tcgplayer_pricing_fields
+        <<~FIELDS
+          pricing {
+            productId
+            prices {
+              subTypeName
+              lowPrice
+              midPrice
+              highPrice
+              marketPrice
+              directLowPrice
+            }
+          }
+        FIELDS
+      end
+
+      def record_connection_fields(include_resolved_links: false, include_pricing: false)
         resolved_links_field = if include_resolved_links
                                  <<~FIELDS
                                    resolvedLinks {
@@ -733,16 +1273,116 @@ module CardDB
           edges {
             cursor
             node {
-              #{record_fields}
+              #{record_fields(include_pricing: include_pricing)}
               #{resolved_links_field}
             }
           }
         FIELDS
       end
 
+      def deck_section_definition_fields
+        <<~FIELDS
+          key
+          label
+          description
+          order
+          default
+          aliases
+          minCards
+          maxCards
+          excludedFromDeckSize
+          legalCardTypes
+          metadata
+        FIELDS
+      end
+
+      def deck_entry_fields
+        <<~FIELDS
+          id
+          datasetId
+          recordId
+          identifier
+          quantity
+          section
+          sortOrder
+          annotations
+          display
+          record {
+            #{record_fields}
+          }
+        FIELDS
+      end
+
+      def deck_validated_against_fields
+        <<~FIELDS
+          rulesetId
+          rulesetVersionId
+          rulesetVersionLabel
+          cardDatasetId
+          cardDatasetVersionId
+          validatedAt
+          validationResultSummary
+        FIELDS
+      end
+
+      def deck_validation_issue_fields
+        <<~FIELDS
+          code
+          severity
+          message
+          entryIds
+          section
+          datasetId
+          identifier
+          metadata
+        FIELDS
+      end
+
+      def deck_validation_fields
+        <<~FIELDS
+          deckId
+          valid
+          blockers {
+            #{deck_validation_issue_fields}
+          }
+          warnings {
+            #{deck_validation_issue_fields}
+          }
+          affectedEntries {
+            entryId
+            datasetId
+            recordId
+            identifier
+            section
+            quantity
+          }
+          validatedAgainst {
+            #{deck_validated_against_fields}
+          }
+          checkedAt
+        FIELDS
+      end
+
+      def deck_diff_fields
+        <<~FIELDS
+          deckId
+          fromVersionId
+          toVersionId
+          toDraftRevision
+          hasChanges
+          diff
+        FIELDS
+      end
+
       def deck_fields
         <<~FIELDS
           id
+          ownerType
+          ownerAccountId
+          ownerApiApplicationId
+          environment
+          createdByAccountId
+          createdByApiApplicationId
           accountId
           apiApplicationId
           gameId
@@ -752,13 +1392,29 @@ module CardDB
           description
           formatKey
           visibility
+          accessMode
+          discoverability
+          state
+          archivedAt
+          deletedAt
+          unpublishedAt
+          externalRefApiApplicationId
           externalRef
+          externalSubjectRef
+          rulesetId
           sourceUrl
           metadata
+          sectionDefinitions {
+            #{deck_section_definition_fields}
+          }
           latestPublishedVersion {
             #{deck_version_fields}
           }
           publishedAt
+          draftRevision
+          draftUpdatedAt
+          draftUpdatedByAccountId
+          draftUpdatedByApiApplicationId
           hasUnpublishedChanges
           createdAt
           updatedAt
@@ -766,18 +1422,58 @@ module CardDB
             #{game_fields}
           }
           entries {
-            id
-            datasetId
-            recordId
-            identifier
-            quantity
-            section
-            sortOrder
-            annotations
-            record {
-              #{record_fields}
-            }
+            #{deck_entry_fields}
+          }
+        FIELDS
+      end
+
+      def deck_ownership_transfer_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
+          retainedAppAccess
+        FIELDS
+      end
+
+      def deck_copy_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
           }
+          copiedFromDeckId
+          retainedAppAccess
+        FIELDS
+      end
+
+      def deck_access_application_fields
+        <<~FIELDS
+          id
+          name
+          description
+          revokedAt
+        FIELDS
+      end
+
+      def deck_api_application_access_fields
+        <<~FIELDS
+          id
+          deckId
+          deck {
+            #{deck_fields}
+          }
+          apiApplicationId
+          apiApplication {
+            #{deck_access_application_fields}
+          }
+          role
+          grantSource
+          externalRef
+          createdByAccountId
+          createdByApiApplicationId
+          revokedAt
+          createdAt
+          updatedAt
         FIELDS
       end
 
@@ -795,23 +1491,67 @@ module CardDB
           externalRef
           sourceUrl
           metadata
+          entries {
+            #{deck_entry_fields}
+          }
           publishNote
           computedDiff
+          rulesetId
+          rulesetVersionId
+          cardDatasetId
+          cardDatasetVersionId
+          validatedAt
+          validationSummary
+          validatedAgainst {
+            #{deck_validated_against_fields}
+          }
+          sectionDefinitions {
+            #{deck_section_definition_fields}
+          }
           publishedByAccountId
           publishedByApiApplicationId
           createdAt
+        FIELDS
+      end
+
+      def deck_publish_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
+          version {
+            #{deck_version_fields}
+          }
+          validation {
+            #{deck_validation_fields}
+          }
+          blockers {
+            #{deck_validation_issue_fields}
+          }
+          warnings {
+            #{deck_validation_issue_fields}
+          }
+        FIELDS
+      end
+
+      def deck_entry_mutation_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
+          entry {
+            #{deck_entry_fields}
+          }
+        FIELDS
+      end
+
+      def deck_entry_reorder_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
           entries {
-            id
-            datasetId
-            recordId
-            identifier
-            quantity
-            section
-            sortOrder
-            annotations
-            record {
-              #{record_fields}
-            }
+            #{deck_entry_fields}
           }
         FIELDS
       end
@@ -859,6 +1599,217 @@ module CardDB
         FIELDS
       end
 
+      def deck_embed_token_fields
+        <<~FIELDS
+          id
+          deckId
+          apiApplicationId
+          label
+          readMode
+          allowedOrigins
+          externalSubject
+          expiresAt
+          revokedAt
+          lastUsedAt
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def deck_access_token_issuer_fields
+        <<~FIELDS
+          id
+          deckId
+          apiApplicationId
+          label
+          readModes
+          maxTokenLifetimeSeconds
+          directSigningAlg
+          directSigningKeyId
+          directSigningPublicKey
+          directSigningKeyRevokedAt
+          revokedAt
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def deck_access_token_fields
+        <<~FIELDS
+          id
+          deckId
+          apiApplicationId
+          issuerId
+          readMode
+          externalSubject
+          expiresAt
+          revokedAt
+          lastUsedAt
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def deck_import_entry_fields
+        <<~FIELDS
+          lineNumber
+          raw
+          datasetKey
+          datasetId
+          recordId
+          identifier
+          quantity
+          section
+          sortOrder
+          display
+          record {
+            #{record_fields}
+          }
+        FIELDS
+      end
+
+      def deck_import_issue_fields
+        <<~FIELDS
+          lineNumber
+          raw
+          code
+          message
+        FIELDS
+      end
+
+      def deck_import_unmatched_fields
+        <<~FIELDS
+          lineNumber
+          raw
+          datasetKey
+          identifier
+          quantity
+          section
+          code
+          message
+        FIELDS
+      end
+
+      def deck_import_ambiguous_fields
+        <<~FIELDS
+          lineNumber
+          raw
+          datasetKey
+          identifier
+          quantity
+          section
+          candidates {
+            recordId
+            identifier
+            display
+          }
+        FIELDS
+      end
+
+      def deck_import_format_definition_fields
+        <<~FIELDS
+          id
+          gameId
+          key
+          name
+          description
+          enabled
+          priority
+          datasetKey
+          config
+          archivedAt
+          isArchived
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def deck_import_format_detection_fields
+        <<~FIELDS
+          formatId
+          key
+          name
+          confidence
+          reason
+        FIELDS
+      end
+
+      def deck_import_format_test_payload_fields
+        <<~FIELDS
+          detection {
+            #{deck_import_format_detection_fields}
+          }
+          entries {
+            #{deck_import_entry_fields}
+          }
+          parseErrors {
+            #{deck_import_issue_fields}
+          }
+          unmatched {
+            #{deck_import_unmatched_fields}
+          }
+          ambiguous {
+            #{deck_import_ambiguous_fields}
+          }
+        FIELDS
+      end
+
+      def deck_hydrate_entries_payload_fields
+        <<~FIELDS
+          entries {
+            #{deck_import_entry_fields}
+          }
+          unmatched {
+            #{deck_import_unmatched_fields}
+          }
+          ambiguous {
+            #{deck_import_ambiguous_fields}
+          }
+        FIELDS
+      end
+
+      def deck_import_payload_fields
+        <<~FIELDS
+          deck {
+            #{deck_fields}
+          }
+          applied
+          dryRun
+          replace
+          format
+          importFormat {
+            #{deck_import_format_definition_fields}
+          }
+          detection {
+            #{deck_import_format_detection_fields}
+          }
+          entries {
+            #{deck_import_entry_fields}
+          }
+          parseErrors {
+            #{deck_import_issue_fields}
+          }
+          unmatched {
+            #{deck_import_unmatched_fields}
+          }
+          ambiguous {
+            #{deck_import_ambiguous_fields}
+          }
+          validation {
+            #{deck_validation_fields}
+          }
+        FIELDS
+      end
+
+      def deck_export_payload_fields
+        <<~FIELDS
+          deckId
+          format
+          text
+          entryCount
+        FIELDS
+      end
+
       def deck_connection_fields
         <<~FIELDS
           totalCount
@@ -876,6 +1827,24 @@ module CardDB
           }
         FIELDS
       end
+
+      def deck_import_format_definition_connection_fields
+        <<~FIELDS
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              #{deck_import_format_definition_fields}
+            }
+          }
+        FIELDS
+      end
     end
     # rubocop:enable Metrics/ClassLength
   end