carddb 0.4.2 → 0.4.6

data/lib/carddb/query_builder.rb

@@ -968,8 +968,8 @@ module CardDB
 
       def deck
         <<~GRAPHQL
-          query Deck($id: UUID!) {
-            deck(id: $id) {
+          query Deck($id: UUID!, $readState: DeckReadState!, $version: DeckPublishedVersionSelector) {
+            deck(id: $id, readState: $readState, version: $version) {
               #{deck_fields}
             }
           }
@@ -1021,8 +1021,8 @@ module CardDB
 
       def deck_by_external_ref
         <<~GRAPHQL
-          query DeckByExternalRef($externalRef: String!) {
-            deckByExternalRef(externalRef: $externalRef) {
+          query DeckByExternalRef($externalRef: String!, $readState: DeckReadState!, $version: DeckPublishedVersionSelector) {
+            deckByExternalRef(externalRef: $externalRef, readState: $readState, version: $version) {
               #{deck_fields}
             }
           }
@@ -1053,37 +1053,6 @@ module CardDB
         GRAPHQL
       end
 
-      # Builds a deckPreview query
-      def deck_preview
-        <<~GRAPHQL
-          query DeckPreview($token: String!) {
-            deckPreview(token: $token) {
-              #{deck_fields}
-            }
-          }
-        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!) {
@@ -1152,43 +1121,188 @@ module CardDB
         GRAPHQL
       end
 
-      # Builds a deckCollaborators query
-      def deck_collaborators
+      def rulesets(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 DeckCollaborators($deckId: UUID!) {
-            deckCollaborators(deckId: $deckId) {
-              #{deck_collaborator_fields}
+          query Rulesets#{args[:definition]} {
+            rulesets#{args[:call]} {
+              #{ruleset_connection_fields}
             }
           }
         GRAPHQL
       end
 
-      # Builds a deckPreviewTokens query
-      def deck_preview_tokens
+      def public_rulesets(game_id:, first: nil, after: nil)
+        args = build_args({ gameId: game_id, first: first, after: after }, required: [:gameId])
+
         <<~GRAPHQL
-          query DeckPreviewTokens($deckId: UUID!) {
-            deckPreviewTokens(deckId: $deckId) {
-              #{deck_preview_token_fields}
+          query PublicRulesets#{args[:definition]} {
+            publicRulesets#{args[:call]} {
+              #{ruleset_connection_fields}
             }
           }
         GRAPHQL
       end
 
-      def deck_embed_tokens
+      def ruleset
         <<~GRAPHQL
-          query DeckEmbedTokens($deckId: UUID!) {
-            deckEmbedTokens(deckId: $deckId) {
-              #{deck_embed_token_fields}
+          query Ruleset($id: UUID, $gameId: UUID, $key: String) {
+            ruleset(id: $id, gameId: $gameId, key: $key) {
+              #{ruleset_fields}
             }
           }
         GRAPHQL
       end
 
-      def deck_access_token_issuers
+      def ruleset_versions(ruleset_id:, status: nil, first: nil, after: nil)
+        args = build_args(
+          { rulesetId: ruleset_id, status: status, first: first, after: after },
+          required: [:rulesetId],
+          type_overrides: { status: 'RulesetVersionStatus' }
+        )
+
         <<~GRAPHQL
-          query DeckAccessTokenIssuers($deckId: UUID!) {
-            deckAccessTokenIssuers(deckId: $deckId) {
-              #{deck_access_token_issuer_fields}
+          query RulesetVersions#{args[:definition]} {
+            rulesetVersions#{args[:call]} {
+              #{ruleset_version_connection_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def ruleset_version
+        <<~GRAPHQL
+          query RulesetVersion($id: UUID!) {
+            rulesetVersion(id: $id) {
+              #{ruleset_version_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def ruleset_validation_rules
+        <<~GRAPHQL
+          query RulesetValidationRules($gameId: UUID!, $rulesetKey: String!, $rulesetVersionId: UUID) {
+            rulesetValidationRules(gameId: $gameId, rulesetKey: $rulesetKey, rulesetVersionId: $rulesetVersionId)
+          }
+        GRAPHQL
+      end
+
+      def deck_validation_rules
+        <<~GRAPHQL
+          query DeckValidationRules($gameId: UUID!, $rulesetKey: String!, $rulesetVersionId: UUID) {
+            deckValidationRules(gameId: $gameId, rulesetKey: $rulesetKey, rulesetVersionId: $rulesetVersionId) {
+              #{deck_validation_rules_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def ruleset_version_draft_import_preview
+        <<~GRAPHQL
+          query RulesetVersionDraftImportPreview($rulesetId: UUID!, $input: RulesetVersionDraftImportFromDatasetRecordInput!) {
+            rulesetVersionDraftImportPreview(rulesetId: $rulesetId, input: $input) {
+              #{ruleset_version_draft_import_preview_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def ruleset_validation_impact(ruleset_version_id:, first: nil)
+        args = build_args(
+          { rulesetVersionId: ruleset_version_id, first: first },
+          required: [:rulesetVersionId]
+        )
+
+        <<~GRAPHQL
+          query RulesetValidationImpact#{args[:definition]} {
+            rulesetValidationImpact#{args[:call]} {
+              #{ruleset_validation_impact_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def create_ruleset
+        <<~GRAPHQL
+          mutation RulesetCreate($input: RulesetCreateInput!) {
+            rulesetCreate(input: $input) {
+              #{ruleset_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def update_ruleset
+        <<~GRAPHQL
+          mutation RulesetUpdate($id: UUID!, $input: RulesetUpdateInput!) {
+            rulesetUpdate(id: $id, input: $input) {
+              #{ruleset_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def create_ruleset_version_draft
+        <<~GRAPHQL
+          mutation RulesetVersionDraftCreate($rulesetId: UUID!, $input: RulesetVersionDraftCreateInput!) {
+            rulesetVersionDraftCreate(rulesetId: $rulesetId, input: $input) {
+              #{ruleset_version_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def import_ruleset_version_draft_from_dataset_record
+        <<~GRAPHQL
+          mutation RulesetVersionDraftImportFromDatasetRecord($rulesetId: UUID!, $input: RulesetVersionDraftImportFromDatasetRecordInput!) {
+            rulesetVersionDraftImportFromDatasetRecord(rulesetId: $rulesetId, input: $input) {
+              #{ruleset_version_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def update_ruleset_version_draft
+        <<~GRAPHQL
+          mutation RulesetVersionDraftUpdate($id: UUID!, $input: RulesetVersionDraftUpdateInput!) {
+            rulesetVersionDraftUpdate(id: $id, input: $input) {
+              #{ruleset_version_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def publish_ruleset_version
+        <<~GRAPHQL
+          mutation RulesetVersionPublish($id: UUID!, $input: RulesetVersionPublishInput) {
+            rulesetVersionPublish(id: $id, input: $input) {
+              #{ruleset_version_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      def activate_ruleset_version
+        <<~GRAPHQL
+          mutation RulesetVersionActivate($id: UUID!) {
+            rulesetVersionActivate(id: $id) {
+              #{ruleset_version_fields}
+            }
+          }
+        GRAPHQL
+      end
+
+      # Builds a deckCollaborators query
+      def deck_collaborators
+        <<~GRAPHQL
+          query DeckCollaborators($deckId: UUID!) {
+            deckCollaborators(deckId: $deckId) {
+              #{deck_collaborator_fields}
             }
           }
         GRAPHQL
@@ -1485,119 +1599,51 @@ module CardDB
         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
+      def create_deck_token_issuer
         <<~GRAPHQL
-          mutation DeckEmbedTokenCreate($input: DeckEmbedTokenCreateInput!) {
-            deckEmbedTokenCreate(input: $input) {
-              token
-              embedToken {
-                #{deck_embed_token_fields}
-              }
+          mutation DeckTokenIssuerCreate($input: DeckTokenIssuerCreateInput!) {
+            deckTokenIssuerCreate(input: $input) {
+              #{deck_token_issuer_fields}
             }
           }
         GRAPHQL
       end
 
-      def revoke_deck_embed_token
+      def revoke_deck_token_issuer
         <<~GRAPHQL
-          mutation DeckEmbedTokenRevoke($id: UUID!) {
-            deckEmbedTokenRevoke(id: $id)
+          mutation DeckTokenIssuerRevoke($id: UUID!) {
+            deckTokenIssuerRevoke(id: $id)
           }
         GRAPHQL
       end
 
-      def create_deck_access_token_issuer
+      def revoke_deck_token_issuer_signing_key
         <<~GRAPHQL
-          mutation DeckAccessTokenIssuerCreate($input: DeckAccessTokenIssuerCreateInput!) {
-            deckAccessTokenIssuerCreate(input: $input) {
-              #{deck_access_token_issuer_fields}
+          mutation DeckTokenIssuerSigningKeyRevoke($id: UUID!) {
+            deckTokenIssuerSigningKeyRevoke(id: $id) {
+              #{deck_token_issuer_fields}
             }
           }
         GRAPHQL
       end
 
-      def revoke_deck_access_token_issuer
+      def exchange_deck_token
         <<~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) {
+          mutation DeckTokenExchange($input: DeckTokenExchangeInput!) {
+            deckTokenExchange(input: $input) {
               token
-              accessToken {
-                #{deck_access_token_fields}
+              deckToken {
+                #{deck_token_fields}
               }
             }
           }
         GRAPHQL
       end
 
-      def exchange_deck_session_token
+      def revoke_deck_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!) {
-            deckAccessTokenRevoke(id: $id)
+          mutation DeckTokenRevoke($id: UUID!) {
+            deckTokenRevoke(id: $id)
           }
         GRAPHQL
       end
@@ -1687,6 +1733,7 @@ module CardDB
           externalRef: 'String',
           deckId: 'UUID!',
           gameId: 'UUID',
+          rulesetId: 'UUID',
           rulesetKey: 'String',
           rulesetVersionId: 'UUID',
           validateSchema: 'Boolean',
@@ -2715,6 +2762,121 @@ module CardDB
         FIELDS
       end
 
+      def ruleset_version_fields
+        <<~FIELDS
+          id
+          rulesetId
+          versionLabel
+          status
+          rules
+          sectionDefinitions {
+            #{deck_section_definition_fields}
+          }
+          cardDatasetId
+          cardDatasetVersionId
+          sourceDatasetId
+          sourceDatasetVersionId
+          sourceDatasetRecordId
+          sourceRecordIdentifier
+          rulesFingerprint
+          effectiveAt
+          changelog
+          createdByAccountId
+          publishedByAccountId
+          publishedAt
+          supersededAt
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def ruleset_fields
+        <<~FIELDS
+          id
+          gameId
+          game {
+            id
+            key
+            name
+          }
+          key
+          name
+          description
+          tags
+          sortOrder
+          currentVersionId
+          currentVersion {
+            #{ruleset_version_fields}
+          }
+          archivedAt
+          isArchived
+          createdAt
+          updatedAt
+        FIELDS
+      end
+
+      def deck_validation_rules_fields
+        <<~FIELDS
+          rulesetId
+          rulesetVersionId
+          rulesetKey
+          rulesetVersionLabel
+          rules
+          sections {
+            #{deck_section_definition_fields}
+          }
+        FIELDS
+      end
+
+      def ruleset_validation_impact_deck_fields
+        <<~FIELDS
+          deckId
+          title
+          slug
+          state
+          hasUnpublishedChanges
+          valid
+          blockerCount
+          warningCount
+          affectedEntryCount
+          issues {
+            #{deck_validation_issue_fields}
+          }
+        FIELDS
+      end
+
+      def ruleset_validation_impact_fields
+        <<~FIELDS
+          rulesetId
+          rulesetVersionId
+          checkedAt
+          affectedDeckCount
+          invalidDeckCount
+          blockerCount
+          warningCount
+          results {
+            #{ruleset_validation_impact_deck_fields}
+          }
+        FIELDS
+      end
+
+      def ruleset_version_draft_import_preview_fields
+        <<~FIELDS
+          sourceDatasetId
+          sourceDatasetVersionId
+          sourceDatasetRecordId
+          sourceRecordIdentifier
+          rules
+          sectionDefinitions {
+            #{deck_section_definition_fields}
+          }
+          rulesFingerprint
+          summary
+          sectionCount
+          copyLimitCount
+        FIELDS
+      end
+
       def deck_diff_fields
         <<~FIELDS
           deckId
@@ -2926,55 +3088,33 @@ module CardDB
         FIELDS
       end
 
-      def deck_collaborator_fields
-        <<~FIELDS
-          id
-          deckId
-          accountId
-          role
-          createdByAccountId
-          createdAt
-          updatedAt
-        FIELDS
+      def ruleset_connection_fields
+        connection_fields(ruleset_fields)
       end
 
-      def deck_preview_token_fields
-        <<~FIELDS
-          id
-          deckId
-          label
-          expiresAt
-          revokedAt
-          lastUsedAt
-          createdAt
-          updatedAt
-        FIELDS
+      def ruleset_version_connection_fields
+        connection_fields(ruleset_version_fields)
       end
 
-      def deck_embed_token_fields
+      def deck_collaborator_fields
         <<~FIELDS
           id
           deckId
-          apiApplicationId
-          label
-          readMode
-          allowedOrigins
-          externalSubject
-          expiresAt
-          revokedAt
-          lastUsedAt
+          accountId
+          role
+          createdByAccountId
           createdAt
           updatedAt
         FIELDS
       end
 
-      def deck_access_token_issuer_fields
+      def deck_token_issuer_fields
         <<~FIELDS
           id
-          deckId
           apiApplicationId
           label
-          readModes
+          allowedScopes
+          allowedRepresentations
           maxTokenLifetimeSeconds
           directSigningAlg
           directSigningKeyId
@@ -2986,14 +3126,16 @@ module CardDB
         FIELDS
       end
 
-      def deck_access_token_fields
+      def deck_token_fields
         <<~FIELDS
           id
-          deckId
           apiApplicationId
           issuerId
-          readMode
+          deckId
+          gameId
           externalSubject
+          scopes
+          representation
           expiresAt
           revokedAt
           lastUsedAt