carddb 0.2.0

data/lib/carddb/query_builder.rb

@@ -0,0 +1,658 @@
+# frozen_string_literal: true
+
+module CardDB
+  # Builds GraphQL queries for the CardDB API.
+  # rubocop:disable Metrics/ModuleLength
+  module QueryBuilder
+    # rubocop:disable Metrics/ClassLength
+    class << self
+      # Builds a searchPublishers query
+      def search_publishers(search: nil, first: nil, after: nil)
+        args = build_args({
+                            search: search,
+                            first: first,
+                            after: after
+                          })
+
+        <<~GRAPHQL
+          query SearchPublishers#{args[:definition]} {
+            searchPublishers#{args[:call]} {
+              #{publisher_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchPublisher query (by id or slug)
+      def fetch_publisher_by_id
+        <<~GRAPHQL
+          query FetchPublisher($id: UUID!) {
+            fetchPublisher(id: $id) {
+              #{publisher_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchPublisher query by slug
+      def fetch_publisher_by_slug
+        <<~GRAPHQL
+          query FetchPublisher($slug: String!) {
+            fetchPublisher(slug: $slug) {
+              #{publisher_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchPublishers query
+      def fetch_publishers
+        <<~GRAPHQL
+          query FetchPublishers($slugs: [String!]!) {
+            fetchPublishers(slugs: $slugs) {
+              #{publisher_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a searchGames query
+      def search_games(publisher_slug: nil, search: nil, first: nil, after: nil)
+        args = build_args({
+                            publisherSlug: publisher_slug,
+                            search: search,
+                            first: first,
+                            after: after
+                          })
+
+        <<~GRAPHQL
+          query SearchGames#{args[:definition]} {
+            searchGames#{args[:call]} {
+              #{game_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchGame query by id
+      def fetch_game_by_id
+        <<~GRAPHQL
+          query FetchGame($id: UUID!) {
+            fetchGame(id: $id) {
+              #{game_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchGame query by publisher slug and game key
+      def fetch_game_by_keys
+        <<~GRAPHQL
+          query FetchGame($publisherSlug: String!, $gameKey: String!) {
+            fetchGame(publisherSlug: $publisherSlug, gameKey: $gameKey) {
+              #{game_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchGames batch query
+      def fetch_games
+        <<~GRAPHQL
+          query FetchGames($ids: [UUID!]!) {
+            fetchGames(ids: $ids) {
+              #{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({
+                            publisherSlug: publisher_slug,
+                            gameKey: game_key,
+                            search: search,
+                            purpose: purpose,
+                            first: first,
+                            after: after
+                          })
+
+        <<~GRAPHQL
+          query SearchDatasets#{args[:definition]} {
+            searchDatasets#{args[:call]} {
+              #{dataset_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchDataset query by id
+      def fetch_dataset_by_id
+        <<~GRAPHQL
+          query FetchDataset($id: UUID!) {
+            fetchDataset(id: $id) {
+              #{dataset_fields}
+              #{schema_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchDataset query by keys (includes schema)
+      def fetch_dataset_by_keys
+        <<~GRAPHQL
+          query FetchDataset($publisherSlug: String!, $gameKey: String!, $datasetKey: String!) {
+            fetchDataset(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey) {
+              #{dataset_fields}
+              #{schema_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchDatasets batch query
+      def fetch_datasets
+        <<~GRAPHQL
+          query FetchDatasets($ids: [UUID!]!) {
+            fetchDatasets(ids: $ids) {
+              #{dataset_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a searchRecords query
+      def search_records(
+        publisher_slug:,
+        game_key:,
+        dataset_key:,
+        filter: nil,
+        search: nil,
+        order_by: nil,
+        resolve_links: nil,
+        first: nil,
+        after: nil,
+        validate_schema: nil
+      )
+        args = build_args(
+          {
+            publisherSlug: publisher_slug,
+            gameKey: game_key,
+            datasetKey: dataset_key,
+            filter: filter,
+            search: search,
+            orderBy: order_by,
+            resolveLinks: resolve_links,
+            first: first,
+            after: after,
+            validateSchema: validate_schema
+          },
+          required: %i[publisherSlug gameKey datasetKey]
+        )
+
+        <<~GRAPHQL
+          query SearchRecords#{args[:definition]} {
+            searchRecords#{args[:call]} {
+              #{record_connection_fields(include_resolved_links: resolve_links&.any?)}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchRecordByIdentifier query
+      def fetch_record_by_identifier
+        <<~GRAPHQL
+          query FetchRecordByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifier: String!) {
+            fetchRecordByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifier: $identifier) {
+              #{record_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchRecordsByIdentifier query
+      def fetch_records_by_identifier
+        <<~GRAPHQL
+          query FetchRecordsByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifiers: [String!]!) {
+            fetchRecordsByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifiers: $identifiers) {
+              #{record_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchRecord query
+      def fetch_record
+        <<~GRAPHQL
+          query FetchRecord($id: UUID!) {
+            fetchRecord(id: $id) {
+              #{record_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchRecords query
+      def fetch_records
+        <<~GRAPHQL
+          query FetchRecords($ids: [UUID!]!) {
+            fetchRecords(ids: $ids) {
+              #{record_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a myDecks query
+      def list_my_decks(first: nil, after: nil)
+        args = build_args({ first: first, after: after })
+
+        <<~GRAPHQL
+          query MyDecks#{args[:definition]} {
+            myDecks#{args[:call]} {
+              #{deck_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchDeck query
+      def fetch_deck
+        <<~GRAPHQL
+          query FetchDeck($id: UUID!) {
+            fetchDeck(id: $id) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a fetchDeckByExternalRef query
+      def fetch_deck_by_external_ref
+        <<~GRAPHQL
+          query FetchDeckByExternalRef($externalRef: String!) {
+            fetchDeckByExternalRef(externalRef: $externalRef) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckCreate mutation
+      def create_deck
+        <<~GRAPHQL
+          mutation DeckCreate($input: DeckCreateInput!) {
+            deckCreate(input: $input) {
+              #{deck_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckUpdate mutation
+      def update_deck
+        <<~GRAPHQL
+          mutation DeckUpdate($id: UUID!, $input: DeckUpdateInput!) {
+            deckUpdate(id: $id, input: $input) {
+              #{deck_fields}
+            }
+          }
+        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: [])
+        # 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',
+          validateSchema: 'Boolean',
+          purpose: 'DatasetPurpose',
+          id: 'UUID!',
+          ids: '[UUID!]!'
+        }
+
+        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}" }
+
+        {
+          definition: "(#{definitions.join(', ')})",
+          call: "(#{calls.join(', ')})"
+        }
+      end
+
+      def publisher_fields
+        <<~FIELDS
+          id
+          name
+          slug
+          status
+          description
+          website
+          createdAt
+          updatedAt
+          logoFile {
+            id
+            url
+          }
+          bannerFile {
+            id
+            url
+          }
+        FIELDS
+      end
+
+      def publisher_connection_fields
+        <<~FIELDS
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              #{publisher_fields}
+            }
+          }
+        FIELDS
+      end
+
+      def game_fields
+        <<~FIELDS
+          id
+          publisherId
+          key
+          name
+          description
+          website
+          visibility
+          isArchived
+          createdAt
+          updatedAt
+          publisher {
+            id
+            name
+            slug
+          }
+          logoFile {
+            id
+            url
+          }
+          coverFile {
+            id
+            url
+          }
+        FIELDS
+      end
+
+      def game_connection_fields
+        <<~FIELDS
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              #{game_fields}
+            }
+          }
+        FIELDS
+      end
+
+      def dataset_fields
+        <<~FIELDS
+          id
+          publisherId
+          gameId
+          key
+          name
+          description
+          purpose
+          visibility
+          isArchived
+          createdAt
+          updatedAt
+          publisher {
+            id
+            name
+            slug
+          }
+          game {
+            id
+            key
+            name
+          }
+        FIELDS
+      end
+
+      def schema_fields
+        <<~FIELDS
+          schema {
+            fields {
+              key
+              label
+              description
+              type
+              isRequired
+              filterable
+              searchable
+              isIdentifier
+              itemType
+              displayFormat
+              semanticType
+              allowedValues
+              nestedFields {
+                key
+                label
+                description
+                type
+                isRequired
+                filterable
+                searchable
+                itemType
+                semanticType
+              }
+            }
+            filterableFields
+            searchableFields
+            linkFields {
+              key
+              label
+              targetDatasetKey
+              targetDatasetName
+              targetDatasetId
+            }
+          }
+        FIELDS
+      end
+
+      def dataset_connection_fields
+        <<~FIELDS
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              #{dataset_fields}
+            }
+          }
+        FIELDS
+      end
+
+      def record_fields
+        <<~FIELDS
+          id
+          datasetId
+          data
+          createdAt
+          updatedAt
+          dataset {
+            id
+            key
+            name
+            gameId
+            publisherId
+          }
+        FIELDS
+      end
+
+      def record_connection_fields(include_resolved_links: false)
+        resolved_links_field = if include_resolved_links
+                                 <<~FIELDS
+                                   resolvedLinks {
+                                     field
+                                     linkFieldKey
+                                     values
+                                     records {
+                                       id
+                                       datasetId
+                                       data
+                                     }
+                                   }
+                                 FIELDS
+                               else
+                                 ''
+                               end
+
+        <<~FIELDS
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              #{record_fields}
+              #{resolved_links_field}
+            }
+          }
+        FIELDS
+      end
+
+      def deck_fields
+        <<~FIELDS
+          id
+          accountId
+          apiApplicationId
+          gameId
+          title
+          description
+          formatKey
+          visibility
+          externalRef
+          sourceUrl
+          metadata
+          createdAt
+          updatedAt
+          game {
+            #{game_fields}
+          }
+          entries {
+            id
+            datasetId
+            recordId
+            identifier
+            quantity
+            section
+            sortOrder
+            annotations
+            record {
+              #{record_fields}
+            }
+          }
+        FIELDS
+      end
+
+      def deck_connection_fields
+        <<~FIELDS
+          totalCount
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+          edges {
+            cursor
+            node {
+              #{deck_fields}
+            }
+          }
+        FIELDS
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+  # rubocop:enable Metrics/ModuleLength
+end