carddb 0.3.0 → 0.3.10

data/lib/carddb/query_builder.rb

@@ -109,6 +109,61 @@ module CardDB
         GRAPHQL
       end
 
+      def list_games(publisher_id:, first: nil, after: nil, include_archived: nil)
+        args = build_args(
+          { publisherId: publisher_id, first: first, after: after, includeArchived: include_archived },
+          required: [:publisherId]
+        )
+
+        <<~GRAPHQL
+          query Games#{args[:definition]} {
+            games#{args[:call]} {
+              #{game_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def game(id: nil, publisher_id: nil, publisher_slug: nil, game_key: nil, game_slug: nil)
+        args = build_args(
+          {
+            id: id,
+            publisherId: publisher_id,
+            publisherSlug: publisher_slug,
+            gameKey: game_key,
+            gameSlug: game_slug
+          }
+        )
+
+        <<~GRAPHQL
+          query Game#{args[:definition]} {
+            game#{args[:call]} {
+              #{game_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def create_game
+        <<~GRAPHQL
+          mutation GameCreate($input: GameCreateInput!) {
+            gameCreate(input: $input) {
+              #{game_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def update_game
+        <<~GRAPHQL
+          mutation GameUpdate($id: UUID!, $input: GameUpdateInput!) {
+            gameUpdate(id: $id, input: $input) {
+              #{game_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a searchDatasets query
       def search_datasets(publisher_slug: nil, game_key: nil, search: nil, purpose: nil, first: nil, after: nil)
         args = build_args({
@@ -164,6 +219,55 @@ module CardDB
         GRAPHQL
       end
 
+      def list_datasets(
+        publisher_id:,
+        game_id: nil,
+        purpose: nil,
+        first: nil,
+        after: nil,
+        include_archived: nil
+      )
+        args = build_args(
+          {
+            publisherId: publisher_id,
+            gameId: game_id,
+            purpose: purpose,
+            first: first,
+            after: after,
+            includeArchived: include_archived
+          },
+          required: [:publisherId]
+        )
+
+        <<~GRAPHQL
+          query Datasets#{args[:definition]} {
+            datasets#{args[:call]} {
+              #{dataset_connection_fields(include_schema: true)}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset(id: nil, publisher_id: nil, game_id: nil, dataset_key: nil)
+        args = build_args(
+          {
+            id: id,
+            publisherId: publisher_id,
+            gameId: game_id,
+            datasetKey: dataset_key
+          }
+        )
+
+        <<~GRAPHQL
+          query Dataset#{args[:definition]} {
+            dataset#{args[:call]} {
+              #{dataset_fields}
+              #{schema_fields}
+            }
+          }
+        GRAPHQL
+      end
+
       # Builds a searchRecords query
       # rubocop:disable Metrics/ParameterLists
       def search_records(
@@ -219,34 +323,421 @@ module CardDB
         GRAPHQL
       end
 
-      # Builds a fetchRecordsByIdentifier query
-      def fetch_records_by_identifier(include_pricing: false)
+      # Builds a fetchRecordsByIdentifier query
+      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(include_pricing: include_pricing)}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchRecord query
+      def fetch_record(include_pricing: false)
+        <<~GRAPHQL
+          query FetchRecord($id: UUID!) {
+            fetchRecord(id: $id) {
+              #{record_fields(include_pricing: include_pricing)}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchRecords query
+      def fetch_records(include_pricing: false)
+        <<~GRAPHQL
+          query FetchRecords($ids: [UUID!]!) {
+            fetchRecords(ids: $ids) {
+              #{record_fields(include_pricing: include_pricing)}
+            }
+          }
+        GRAPHQL
+      end
+
+      def list_dataset_records(
+        dataset_id:,
+        filter: nil,
+        order_by: nil,
+        first: nil,
+        after: nil,
+        last: nil,
+        before: nil,
+        validate_schema: nil
+      )
+        args = build_args(
+          {
+            datasetId: dataset_id,
+            filter: filter,
+            orderBy: order_by,
+            first: first,
+            after: after,
+            last: last,
+            before: before,
+            validateSchema: validate_schema
+          },
+          required: [:datasetId],
+          type_overrides: { orderBy: 'DatasetRecordOrderByInput' }
+        )
+
+        <<~GRAPHQL
+          query DatasetRecords#{args[:definition]} {
+            datasetRecords#{args[:call]} {
+              #{record_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_record(**params)
+        args = build_args(
+          {
+            id: params[:id],
+            datasetId: params[:dataset_id],
+            identifier: params[:identifier],
+            publisherSlug: params[:publisher_slug],
+            gameKey: params[:game_key],
+            datasetKey: params[:dataset_key],
+            recordId: params[:record_id],
+            resolveLinks: params[:resolve_links],
+            validateSchema: params[:validate_schema]
+          }
+        )
+        include_links = params[:resolve_links]&.any?
+        links_fields = resolved_links_fields if include_links
+
+        <<~GRAPHQL
+          query DatasetRecord#{args[:definition]} {
+            datasetRecord#{args[:call]} {
+              #{record_fields(include_pricing: params.fetch(:include_pricing, false))}
+              #{links_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def upsert_dataset_records
+        <<~GRAPHQL
+          mutation DatasetRecordsUpsert($input: DatasetRecordsUpsertInput!) {
+            datasetRecordsUpsert(input: $input) {
+              #{dataset_records_upsert_payload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def delete_dataset_records
+        <<~GRAPHQL
+          mutation DatasetRecordsDelete($input: DatasetRecordsDeleteInput!) {
+            datasetRecordsDelete(input: $input) {
+              #{dataset_record_delete_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_record_delete_job
+        <<~GRAPHQL
+          query DatasetRecordDeleteJob($id: UUID!) {
+            datasetRecordDeleteJob(id: $id) {
+              #{dataset_record_delete_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_record_delete_jobs(publisher_id:, dataset_id: nil, status: nil, first: nil, after: nil)
+        args = build_args(
+          { publisherId: publisher_id, datasetId: dataset_id, status: status, first: first, after: after },
+          required: [:publisherId],
+          type_overrides: { status: 'DatasetRecordDeleteJobStatus' }
+        )
+
+        <<~GRAPHQL
+          query DatasetRecordDeleteJobs#{args[:definition]} {
+            datasetRecordDeleteJobs#{args[:call]} {
+              #{dataset_record_delete_job_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_import_preview
+        <<~GRAPHQL
+          query DatasetImportPreview($input: DatasetImportPreviewInput!) {
+            datasetImportPreview(input: $input) {
+              #{dataset_import_preview_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_import_validate
+        <<~GRAPHQL
+          query DatasetImportValidate($input: DatasetImportValidateInput!) {
+            datasetImportValidate(input: $input) {
+              #{bulk_import_result_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_import_from_file
+        <<~GRAPHQL
+          mutation DatasetImportFromFile($input: DatasetImportFromFileInput!) {
+            datasetImportFromFile(input: $input) {
+              #{import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_import_from_payload
+        <<~GRAPHQL
+          mutation DatasetImportFromPayload($input: DatasetImportFromPayloadInput!) {
+            datasetImportFromPayload(input: $input) {
+              #{import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_import_from_url
+        <<~GRAPHQL
+          mutation DatasetImportFromUrl($input: DatasetImportFromUrlInput!) {
+            datasetImportFromUrl(input: $input) {
+              #{import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def import_job
+        <<~GRAPHQL
+          query ImportJob($id: UUID!) {
+            importJob(id: $id) {
+              #{import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def import_jobs(publisher_id:, dataset_id: nil, status: nil, first: nil, after: nil)
+        args = build_args(
+          { publisherId: publisher_id, datasetId: dataset_id, status: status, first: first, after: after },
+          required: [:publisherId],
+          type_overrides: { status: 'ImportJobStatus' }
+        )
+
+        <<~GRAPHQL
+          query ImportJobs#{args[:definition]} {
+            importJobs#{args[:call]} {
+              #{import_job_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def import_job_cancel
+        <<~GRAPHQL
+          mutation ImportJobCancel($id: UUID!) {
+            importJobCancel(id: $id) {
+              #{import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def import_job_logs(level: nil, dataset_key: nil, first: nil, after: nil)
+        log_args = build_args(
+          { level: level, datasetKey: dataset_key, first: first, after: after },
+          type_overrides: { level: 'ImportLogLevel' }
+        )
+
+        <<~GRAPHQL
+          query ImportJobLogs($importJobId: UUID!#{log_args[:definition].sub('(', ', ').sub(')', '')}) {
+            importJob(id: $importJobId) {
+              logs#{log_args[:call]} {
+                #{import_job_log_connection_fields}
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def game_import_preview
+        <<~GRAPHQL
+          query GameImportPreview($input: GameImportPreviewInput!) {
+            gameImportPreview(input: $input) {
+              #{game_import_preview_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def game_import_from_file
+        <<~GRAPHQL
+          mutation GameImportFromFile($input: GameImportFromFileInput!) {
+            gameImportFromFile(input: $input) {
+              #{game_import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def game_import_from_payload
+        <<~GRAPHQL
+          mutation GameImportFromPayload($input: GameImportFromPayloadInput!) {
+            gameImportFromPayload(input: $input) {
+              #{game_import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def game_import_from_url
+        <<~GRAPHQL
+          mutation GameImportFromUrl($input: GameImportFromUrlInput!) {
+            gameImportFromUrl(input: $input) {
+              #{game_import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def game_import_job
+        <<~GRAPHQL
+          query GameImportJob($id: UUID!) {
+            gameImportJob(id: $id) {
+              #{game_import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def game_import_jobs(game_id:, status: nil, first: nil, after: nil)
+        args = build_args(
+          { gameId: game_id, status: status, first: first, after: after },
+          required: [:gameId],
+          type_overrides: { status: 'ImportJobStatus' }
+        )
+
+        <<~GRAPHQL
+          query GameImportJobs#{args[:definition]} {
+            gameImportJobs#{args[:call]} {
+              #{game_import_job_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def game_import_job_cancel
+        <<~GRAPHQL
+          mutation GameImportJobCancel($id: UUID!) {
+            gameImportJobCancel(id: $id) {
+              #{game_import_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def file
+        <<~GRAPHQL
+          query File($id: UUID!) {
+            file(id: $id) {
+              #{file_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def file_upload_request
+        <<~GRAPHQL
+          mutation FileUploadRequest($input: FileUploadInput!) {
+            fileUploadRequest(input: $input) {
+              #{presigned_upload_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def file_upload_confirm
+        <<~GRAPHQL
+          mutation FileUploadConfirm($id: UUID!) {
+            fileUploadConfirm(id: $id) {
+              #{file_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def file_delete
+        <<~GRAPHQL
+          mutation FileDelete($id: UUID!) {
+            fileDelete(id: $id)
+          }
+        GRAPHQL
+      end
+
+      def export_job
+        <<~GRAPHQL
+          query ExportJob($id: UUID!) {
+            exportJob(id: $id) {
+              #{export_job_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def export_jobs(publisher_id:, game_id: nil, dataset_id: nil, status: nil, first: nil, after: nil)
+        args = build_args(
+          {
+            publisherId: publisher_id,
+            gameId: game_id,
+            datasetId: dataset_id,
+            status: status,
+            first: first,
+            after: after
+          },
+          required: [:publisherId],
+          type_overrides: { status: 'ExportJobStatus' }
+        )
+
+        <<~GRAPHQL
+          query ExportJobs#{args[:definition]} {
+            exportJobs#{args[:call]} {
+              #{export_job_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def dataset_export
         <<~GRAPHQL
-          query FetchRecordsByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifiers: [String!]!) {
-            fetchRecordsByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifiers: $identifiers) {
-              #{record_fields(include_pricing: include_pricing)}
+          mutation DatasetExport($input: DatasetExportInput!) {
+            datasetExport(input: $input) {
+              #{export_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a fetchRecord query
-      def fetch_record(include_pricing: false)
+      def export_job_cancel
         <<~GRAPHQL
-          query FetchRecord($id: UUID!) {
-            fetchRecord(id: $id) {
-              #{record_fields(include_pricing: include_pricing)}
+          mutation ExportJobCancel($id: UUID!) {
+            exportJobCancel(id: $id) {
+              #{export_job_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a fetchRecords query
-      def fetch_records(include_pricing: false)
+      def export_job_refresh_url
         <<~GRAPHQL
-          query FetchRecords($ids: [UUID!]!) {
-            fetchRecords(ids: $ids) {
-              #{record_fields(include_pricing: include_pricing)}
+          mutation ExportJobRefreshUrl($id: UUID!) {
+            exportJobRefreshUrl(id: $id) {
+              #{export_job_fields}
             }
           }
         GRAPHQL
@@ -569,10 +1060,9 @@ module CardDB
         GRAPHQL
       end
 
-      def deck_import_formats(game_id:, include_archived: nil, first: nil, after: nil)
+      def deck_import_formats(publisher_id: nil, game_id: nil, include_archived: nil, first: nil, after: nil)
         args = build_args(
-          { gameId: game_id, includeArchived: include_archived, first: first, after: after },
-          required: [:gameId]
+          { publisherId: publisher_id, gameId: game_id, includeArchived: include_archived, first: first, after: after }
         )
 
         <<~GRAPHQL
@@ -586,8 +1076,8 @@ module CardDB
 
       def deck_import_format
         <<~GRAPHQL
-          query DeckImportFormat($id: UUID!) {
-            deckImportFormat(id: $id) {
+          query DeckImportFormat($id: UUID, $gameId: UUID, $key: String) {
+            deckImportFormat(id: $id, gameId: $gameId, key: $key) {
               #{deck_import_format_definition_fields}
             }
           }
@@ -926,6 +1416,30 @@ module CardDB
         GRAPHQL
       end
 
+      def exchange_deck_session_token
+        <<~GRAPHQL
+          mutation DeckSessionTokenExchange($input: DeckSessionTokenExchangeInput!) {
+            deckSessionTokenExchange(input: $input) {
+              token
+              sessionToken {
+                id
+                accountId
+                apiApplicationId
+                gameId
+                environment
+                externalSubject
+                scopes
+                expiresAt
+                revokedAt
+                lastUsedAt
+                createdAt
+                updatedAt
+              }
+            }
+          }
+        GRAPHQL
+      end
+
       def revoke_deck_access_token
         <<~GRAPHQL
           mutation DeckAccessTokenRevoke($id: UUID!) {
@@ -990,6 +1504,7 @@ module CardDB
 
       private
 
+      # rubocop:disable Metrics/MethodLength
       def build_args(params, required: [], type_overrides: {})
         # Filter out nil values
         params = params.compact
@@ -999,14 +1514,21 @@ module CardDB
         # Map Ruby types to GraphQL types (base types, without !)
         type_map = {
           publisherSlug: 'String',
+          publisherId: 'UUID',
           gameKey: 'String',
+          gameSlug: 'String',
           datasetKey: 'String',
+          datasetId: 'UUID',
+          recordId: 'UUID',
+          identifier: 'String',
           search: 'String',
           orderBy: 'String',
           filter: 'JSON',
           resolveLinks: '[String!]',
           first: 'Int',
           after: 'String',
+          last: 'Int',
+          before: 'String',
           includeArchived: 'Boolean',
           externalRef: 'String',
           deckId: 'UUID!',
@@ -1015,6 +1537,9 @@ module CardDB
           rulesetVersionId: 'UUID',
           validateSchema: 'Boolean',
           purpose: 'DatasetPurpose',
+          status: 'String',
+          level: 'String',
+          key: 'String',
           id: 'UUID!',
           ids: '[UUID!]!'
         }
@@ -1032,6 +1557,34 @@ module CardDB
           call: "(#{calls.join(', ')})"
         }
       end
+      # rubocop:enable Metrics/MethodLength
+
+      def file_fields
+        <<~FIELDS
+          id
+          createdAt
+          updatedAt
+          key
+          filename
+          contentType
+          size
+          status
+          isPublic
+          entityType
+          entityId
+          url
+        FIELDS
+      end
+
+      def presigned_upload_fields
+        <<~FIELDS
+          file {
+            #{file_fields}
+          }
+          uploadUrl
+          expiresAt
+        FIELDS
+      end
 
       def publisher_fields
         <<~FIELDS
@@ -1079,8 +1632,11 @@ module CardDB
           key
           name
           description
+          metafyGameUuid
+          metafyGameSlug
           website
           visibility
+          archivedAt
           isArchived
           createdAt
           updatedAt
@@ -1127,8 +1683,13 @@ module CardDB
           name
           description
           purpose
+          activeVersionId
           tcgplayerProductIdFieldKey
           visibility
+          posX
+          posY
+          sortOrder
+          archivedAt
           isArchived
           createdAt
           updatedAt
@@ -1159,11 +1720,16 @@ module CardDB
               targetDatasetKey
               targetDatasetName
               targetDatasetId
+              targetFieldKey
+              linkAlias
+              linkDirection
+              isArray
             }
           }
         FIELDS
       end
 
+      # rubocop:disable Metrics/MethodLength
       def field_info_fields(depth:)
         nested_fields = if depth.positive?
                           <<~FIELDS
@@ -1182,15 +1748,36 @@ module CardDB
           filterable
           searchable
           isIdentifier
+          sortOrder
           itemType
+          linkDatasetId
+          linkDatasetKey
+          linkDatasetName
+          linkFieldKey
+          linkAlias
+          linkDirection
           displayFormat
           semanticType
+          placeholder
+          isHidden
+          isComputed
+          isSystemField
+          defaultValue
           allowedValues
+          minLength
+          maxLength
+          minValue
+          maxValue
+          pattern
+          isUnique
           #{nested_fields}
         FIELDS
       end
+      # rubocop:enable Metrics/MethodLength
+
+      def dataset_connection_fields(include_schema: false)
+        node_fields = include_schema ? "#{dataset_fields}\n#{schema_fields}" : dataset_fields
 
-      def dataset_connection_fields
         <<~FIELDS
           totalCount
           pageInfo {
@@ -1202,7 +1789,7 @@ module CardDB
           edges {
             cursor
             node {
-              #{dataset_fields}
+              #{node_fields}
             }
           }
         FIELDS
@@ -1245,22 +1832,7 @@ module CardDB
       end
 
       def record_connection_fields(include_resolved_links: false, include_pricing: false)
-        resolved_links_field = if include_resolved_links
-                                 <<~FIELDS
-                                   resolvedLinks {
-                                     field
-                                     linkFieldKey
-                                     values
-                                     records {
-                                       id
-                                       datasetId
-                                       data
-                                     }
-                                   }
-                                 FIELDS
-                               else
-                                 ''
-                               end
+        resolved_links_field = include_resolved_links ? resolved_links_fields : ''
 
         <<~FIELDS
           totalCount
@@ -1280,6 +1852,444 @@ module CardDB
         FIELDS
       end
 
+      def resolved_links_fields
+        <<~FIELDS
+          resolvedLinks {
+            field
+            linkFieldKey
+            values
+            records {
+              id
+              datasetId
+              data
+            }
+          }
+        FIELDS
+      end
+
+      def object_field_fields
+        <<~FIELDS
+          id
+          objectTypeId
+          key
+          label
+          dataType
+          isRequired
+          isFilterable
+          isSearchable
+          isIdentifier
+          sortOrder
+          description
+          placeholder
+          displayFormat
+          semanticType
+          isHidden
+          isComputed
+          isSystemField
+          defaultValue
+          allowedValues
+          minLength
+          maxLength
+          minValue
+          maxValue
+          pattern
+          isUnique
+          itemType
+          linkDatasetId
+          linkFieldKey
+          linkAlias
+          linkDirection
+          parentFieldId
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def bulk_record_error_fields
+        <<~FIELDS
+          datasetKey
+          index
+          errors {
+            field
+            message
+            details
+          }
+        FIELDS
+      end
+
+      def import_stats_fields
+        <<~FIELDS
+          total
+          inserted
+          updated
+          skipped
+          failed
+        FIELDS
+      end
+
+      def bulk_import_result_fields
+        <<~FIELDS
+          inserted {
+            #{record_fields}
+          }
+          updated {
+            #{record_fields}
+          }
+          skipped
+          errors {
+            #{bulk_record_error_fields}
+          }
+          createdFields {
+            #{object_field_fields}
+          }
+          stats {
+            #{import_stats_fields}
+          }
+        FIELDS
+      end
+
+      def import_job_asset_fields
+        <<~FIELDS
+          fileId
+          filename
+          file {
+            #{file_fields}
+          }
+        FIELDS
+      end
+
+      def import_job_fields
+        <<~FIELDS
+          id
+          publisherId
+          publisher {
+            #{publisher_fields}
+          }
+          datasetId
+          dataset {
+            #{dataset_fields}
+            #{schema_fields}
+          }
+          accountId
+          status
+          mode
+          onConflict
+          format
+          fileId
+          progress
+          totalRecords
+          processedRecords
+          insertedCount
+          updatedCount
+          skippedCount
+          failedCount
+          createdFields {
+            #{object_field_fields}
+          }
+          errors {
+            #{bulk_record_error_fields}
+          }
+          errorMessage
+          assets {
+            #{import_job_asset_fields}
+          }
+          startedAt
+          completedAt
+          createdAt
+          updatedAt
+          lastCheckpointIndex
+          isResumed
+          imagesPending
+          imagesCompleted
+          imagesFailed
+        FIELDS
+      end
+
+      def import_job_log_fields
+        <<~FIELDS
+          id
+          importJobId
+          level
+          message
+          datasetKey
+          recordIndex
+          fieldKey
+          details
+          createdAt
+        FIELDS
+      end
+
+      def dataset_records_upsert_payload_fields
+        <<~FIELDS
+          job {
+            #{import_job_fields}
+          }
+          dryRunResult {
+            #{bulk_import_result_fields}
+          }
+        FIELDS
+      end
+
+      def dataset_record_delete_job_result_fields
+        <<~FIELDS
+          target
+          recordId
+          identifier
+          status
+          message
+        FIELDS
+      end
+
+      def dataset_record_delete_job_fields
+        <<~FIELDS
+          id
+          publisherId
+          publisher {
+            #{publisher_fields}
+          }
+          datasetId
+          dataset {
+            #{dataset_fields}
+          }
+          accountId
+          status
+          targetType
+          dryRun
+          targets
+          progress
+          totalTargets
+          processedTargets
+          matchedCount
+          deletedCount
+          missingCount
+          blockedCount
+          failedCount
+          results {
+            #{dataset_record_delete_job_result_fields}
+          }
+          errorMessage
+          startedAt
+          completedAt
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def field_mapping_fields
+        <<~FIELDS
+          sourceField
+          targetField
+          targetFieldLabel
+          inferredType
+          inferredItemType
+          inferredChildren {
+            key
+            label
+            type
+            required
+            itemType
+            children {
+              key
+              label
+              type
+              required
+              itemType
+            }
+          }
+          inferredLinkDataset
+          inferredLinkFieldKey
+          inferredLinkDirection
+          targetFieldType
+          sampleValues
+          status
+        FIELDS
+      end
+
+      def import_warning_fields
+        <<~FIELDS
+          datasetKey
+          field
+          message
+          severity
+        FIELDS
+      end
+
+      def dataset_import_preview_fields
+        <<~FIELDS
+          datasetKey
+          datasetName
+          datasetId
+          exists
+          recordCount
+          fieldMappings {
+            #{field_mapping_fields}
+          }
+          warnings {
+            #{import_warning_fields}
+          }
+          canProceed
+          sampleRecords
+          availableDatasets {
+            #{dataset_fields}
+            #{schema_fields}
+          }
+        FIELDS
+      end
+
+      def game_import_preview_fields
+        <<~FIELDS
+          datasets {
+            datasetKey
+            datasetName
+            datasetId
+            exists
+            recordCount
+            fieldMappings {
+              #{field_mapping_fields}
+            }
+            warnings {
+              #{import_warning_fields}
+            }
+            sampleRecords
+          }
+          importOrder
+          warnings {
+            #{import_warning_fields}
+          }
+          canProceed
+        FIELDS
+      end
+
+      def game_import_dataset_status_fields
+        <<~FIELDS
+          datasetKey
+          datasetId
+          datasetName
+          status
+          recordCount
+          insertedCount
+          updatedCount
+          skippedCount
+          failedCount
+          errorMessage
+        FIELDS
+      end
+
+      def game_import_job_fields
+        <<~FIELDS
+          id
+          publisherId
+          publisher {
+            #{publisher_fields}
+          }
+          gameId
+          game {
+            #{game_fields}
+          }
+          accountId
+          status
+          mode
+          onConflict
+          fileId
+          assets {
+            #{import_job_asset_fields}
+          }
+          totalDatasets
+          completedDatasets
+          progress
+          importOrder
+          datasetStatuses {
+            #{game_import_dataset_status_fields}
+          }
+          errorMessage
+          startedAt
+          completedAt
+          createdAt
+          updatedAt
+          completedDatasetKeys
+          currentDatasetKey
+          lastCheckpointIndex
+          isResumed
+          imagesPending
+          imagesCompleted
+          imagesFailed
+          phase
+          linkBuildingDataset
+          linkBuildingTotalDatasets
+          linkBuildingCompletedDatasets
+          linkBuildingProcessedRecords
+          linkBuildingTotalRecords
+        FIELDS
+      end
+
+      def export_job_fields
+        <<~FIELDS
+          id
+          publisherId
+          publisher {
+            #{publisher_fields}
+          }
+          datasetId
+          dataset {
+            #{dataset_fields}
+          }
+          accountId
+          status
+          format
+          filter
+          totalRecords
+          processedRecords
+          progress
+          fileId
+          downloadUrl
+          downloadExpiresAt
+          errorMessage
+          startedAt
+          completedAt
+          createdAt
+          updatedAt
+          lastCheckpointIndex
+        FIELDS
+      end
+
+      def import_job_connection_fields
+        connection_fields(import_job_fields)
+      end
+
+      def import_job_log_connection_fields
+        connection_fields(import_job_log_fields)
+      end
+
+      def game_import_job_connection_fields
+        connection_fields(game_import_job_fields)
+      end
+
+      def dataset_record_delete_job_connection_fields
+        connection_fields(dataset_record_delete_job_fields)
+      end
+
+      def export_job_connection_fields
+        connection_fields(export_job_fields)
+      end
+
+      def connection_fields(node_fields)
+        <<~FIELDS
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              #{node_fields}
+            }
+          }
+        FIELDS
+      end
+
       def deck_section_definition_fields
         <<~FIELDS
           key