carddb 0.4.2 → 0.4.5

data/lib/carddb/resources/decks.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module CardDB
   module Resources
     # Decks resource for hosted decks and external deck hydration.
     # rubocop:disable Metrics/ClassLength
     class Decks < Base
+      JSON_OBJECT_INPUT_KEYS = %w[metadata annotations].freeze
+
       # List decks owned by the current account or API application.
       def list_mine(first: nil, after: nil, include_archived: nil, cache: nil)
         query = QueryBuilder.list_my_decks(first: first, after: after, include_archived: include_archived)
@@ -91,14 +95,23 @@ module CardDB
       end
 
       # Fetch by UUID using the ownership-aware deck API.
-      def get(id, cache: nil)
-        key = cache_key('decks', 'get', id: id)
+      def get(id, read_state:, version: nil, cache: nil)
+        variables = build_variables(id: id, readState: read_state, version: version)
+        key = cache_key('decks', 'get', **variables)
         with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck, { id: id })
+          data = connection.execute(QueryBuilder.deck, variables)
           data['deck'] ? Deck.new(data['deck'], client: client) : nil
         end
       end
 
+      def get_draft(id, cache: nil)
+        get(id, read_state: 'DRAFT', cache: cache)
+      end
+
+      def get_published(id, version: nil, cache: nil)
+        get(id, read_state: 'PUBLISHED', version: version, cache: cache)
+      end
+
       # Fetch one deck owned by the current account or API application.
       def fetch_mine(id, cache: nil)
         key = cache_key('decks', 'fetch_mine', id: id)
@@ -150,14 +163,23 @@ module CardDB
       end
 
       # Fetch by external reference using the ownership-aware deckByExternalRef API.
-      def get_by_external_ref(external_ref:, cache: nil)
-        key = cache_key('decks', 'get_by_external_ref', external_ref: external_ref)
+      def get_by_external_ref(external_ref:, read_state:, version: nil, cache: nil)
+        variables = build_variables(externalRef: external_ref, readState: read_state, version: version)
+        key = cache_key('decks', 'get_by_external_ref', **variables)
         with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_by_external_ref, { externalRef: external_ref })
+          data = connection.execute(QueryBuilder.deck_by_external_ref, variables)
           data['deckByExternalRef'] ? Deck.new(data['deckByExternalRef'], client: client) : nil
         end
       end
 
+      def get_draft_by_external_ref(external_ref:, cache: nil)
+        get_by_external_ref(external_ref: external_ref, read_state: 'DRAFT', cache: cache)
+      end
+
+      def get_published_by_external_ref(external_ref:, version: nil, cache: nil)
+        get_by_external_ref(external_ref: external_ref, read_state: 'PUBLISHED', version: version, cache: cache)
+      end
+
       # Fetch one immutable published deck version.
       def fetch_version(id, cache: nil)
         key = cache_key('decks', 'fetch_version', id: id)
@@ -185,33 +207,6 @@ module CardDB
         )
       end
 
-      # Fetch current draft data using a revocable preview token.
-      def preview(token:, cache: nil)
-        key = cache_key('decks', 'preview', token: token)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_preview, { token: token })
-          data['deckPreview'] ? Deck.new(data['deckPreview'], client: client) : nil
-        end
-      end
-
-      # Fetch published embed data using a revocable embed token.
-      def embed(token:, cache: nil)
-        key = cache_key('decks', 'embed', token: token)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_embed, { token: token })
-          data['deckEmbed'] ? Deck.new(data['deckEmbed'], client: client) : nil
-        end
-      end
-
-      # Fetch token-authorized published data using an exchanged access token.
-      def access(token:, cache: nil)
-        key = cache_key('decks', 'access', token: token)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_access, { token: token })
-          data['deckAccess'] ? Deck.new(data['deckAccess'], client: client) : nil
-        end
-      end
-
       def draft_diff(id:, cache: nil)
         key = cache_key('decks', 'draft_diff', id: id)
         with_cache(key, resource: :decks, cache: cache) do
@@ -239,9 +234,10 @@ module CardDB
       end
 
       def hydrate_deck_entries(input:, cache: nil)
-        key = cache_key('decks', 'hydrate_deck_entries', input: input)
+        normalized_input = normalize_deck_json_input(input)
+        key = cache_key('decks', 'hydrate_deck_entries', input: normalized_input)
         with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_hydrate_entries, { input: input })
+          data = connection.execute(QueryBuilder.deck_hydrate_entries, { input: normalized_input })
           DeckHydrateEntriesPayload.new(data['deckHydrateEntries'], client: client)
         end
       end
@@ -293,31 +289,6 @@ module CardDB
         end
       end
 
-      # List draft preview tokens for a deck.
-      def preview_tokens(deck_id:, cache: nil)
-        key = cache_key('decks', 'preview_tokens', deck_id: deck_id)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_preview_tokens, { deckId: deck_id })
-          (data['deckPreviewTokens'] || []).map { |token| DeckPreviewToken.new(token, client: client) }
-        end
-      end
-
-      def embed_tokens(deck_id:, cache: nil)
-        key = cache_key('decks', 'embed_tokens', deck_id: deck_id)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_embed_tokens, { deckId: deck_id })
-          (data['deckEmbedTokens'] || []).map { |token| DeckEmbedToken.new(token, client: client) }
-        end
-      end
-
-      def access_token_issuers(deck_id:, cache: nil)
-        key = cache_key('decks', 'access_token_issuers', deck_id: deck_id)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_access_token_issuers, { deckId: deck_id })
-          (data['deckAccessTokenIssuers'] || []).map { |issuer| DeckAccessTokenIssuer.new(issuer, client: client) }
-        end
-      end
-
       def api_application_accesses(deck_id:, include_revoked: nil, cache: nil)
         variables = build_variables(deckId: deck_id, includeRevoked: include_revoked)
         key = cache_key('decks', 'api_application_accesses', **variables)
@@ -342,13 +313,13 @@ module CardDB
 
       # Create a hosted deck.
       def create(input:)
-        data = connection.execute(QueryBuilder.create_deck, { input: input })
+        data = connection.execute(QueryBuilder.create_deck, { input: normalize_deck_json_input(input) })
         Deck.new(data['deckCreate'], client: client)
       end
 
       # Update a hosted deck.
       def update(id:, input:)
-        data = connection.execute(QueryBuilder.update_deck, { id: id, input: input })
+        data = connection.execute(QueryBuilder.update_deck, { id: id, input: normalize_deck_json_input(input) })
         Deck.new(data['deckUpdate'], client: client)
       end
 
@@ -360,7 +331,7 @@ module CardDB
       def upsert_by_external_ref(input:)
         config.require_secret_credential!('decks.upsert_by_external_ref')
 
-        data = connection.execute(QueryBuilder.upsert_deck_by_external_ref, { input: input })
+        data = connection.execute(QueryBuilder.upsert_deck_by_external_ref, { input: normalize_deck_json_input(input) })
         DeckUpsertByExternalRefPayload.new(data['deckUpsertByExternalRef'], client: client)
       end
 
@@ -380,12 +351,12 @@ module CardDB
       end
 
       def add_entry(input:)
-        data = connection.execute(QueryBuilder.add_deck_entry, { input: input })
+        data = connection.execute(QueryBuilder.add_deck_entry, { input: normalize_deck_json_input(input) })
         DeckEntryMutationPayload.new(data['deckEntryAdd'], client: client)
       end
 
       def update_entry(id:, input:)
-        data = connection.execute(QueryBuilder.update_deck_entry, { id: id, input: input })
+        data = connection.execute(QueryBuilder.update_deck_entry, { id: id, input: normalize_deck_json_input(input) })
         DeckEntryMutationPayload.new(data['deckEntryUpdate'], client: client)
       end
 
@@ -403,7 +374,7 @@ module CardDB
       end
 
       def replace_entries(deck_id:, input:)
-        data = connection.execute(QueryBuilder.replace_deck_entries, { deckId: deck_id, input: input })
+        data = connection.execute(QueryBuilder.replace_deck_entries, { deckId: deck_id, input: normalize_deck_json_input(input) })
         DeckEntriesReplacePayload.new(data['deckEntriesReplace'], client: client)
       end
 
@@ -522,47 +493,27 @@ module CardDB
       end
       # rubocop:enable Naming/PredicateMethod
 
-      # Create a revocable draft preview token.
-      def create_preview_token(input:)
-        data = connection.execute(QueryBuilder.create_deck_preview_token, { input: input })
-        DeckPreviewTokenCreatePayload.new(data['deckPreviewTokenCreate'], client: client)
-      end
+      def create_token_issuer(input:)
+        config.require_secret_credential!('decks.create_token_issuer')
 
-      # Revoke a draft preview token.
-      # rubocop:disable Naming/PredicateMethod
-      def revoke_preview_token(id:)
-        data = connection.execute(QueryBuilder.revoke_deck_preview_token, { id: id })
-        !!data['deckPreviewTokenRevoke']
-      end
-      # rubocop:enable Naming/PredicateMethod
-
-      def create_embed_token(input:)
-        data = connection.execute(QueryBuilder.create_deck_embed_token, { input: input })
-        DeckEmbedTokenCreatePayload.new(data['deckEmbedTokenCreate'], client: client)
+        data = connection.execute(QueryBuilder.create_deck_token_issuer, { input: input })
+        DeckTokenIssuer.new(data['deckTokenIssuerCreate'], client: client)
       end
 
       # rubocop:disable Naming/PredicateMethod
-      def revoke_embed_token(id:)
-        data = connection.execute(QueryBuilder.revoke_deck_embed_token, { id: id })
-        !!data['deckEmbedTokenRevoke']
-      end
-      # rubocop:enable Naming/PredicateMethod
+      def revoke_token_issuer(id:)
+        config.require_secret_credential!('decks.revoke_token_issuer')
 
-      def create_access_token_issuer(input:)
-        data = connection.execute(QueryBuilder.create_deck_access_token_issuer, { input: input })
-        DeckAccessTokenIssuer.new(data['deckAccessTokenIssuerCreate'], client: client)
-      end
-
-      # rubocop:disable Naming/PredicateMethod
-      def revoke_access_token_issuer(id:)
-        data = connection.execute(QueryBuilder.revoke_deck_access_token_issuer, { id: id })
-        !!data['deckAccessTokenIssuerRevoke']
+        data = connection.execute(QueryBuilder.revoke_deck_token_issuer, { id: id })
+        !!data['deckTokenIssuerRevoke']
       end
       # rubocop:enable Naming/PredicateMethod
 
-      def revoke_access_token_issuer_signing_key(id:)
-        data = connection.execute(QueryBuilder.revoke_deck_access_token_issuer_signing_key, { id: id })
-        DeckAccessTokenIssuer.new(data['deckAccessTokenIssuerSigningKeyRevoke'], client: client)
+      def revoke_token_issuer_signing_key(id:)
+        config.require_secret_credential!('decks.revoke_token_issuer_signing_key')
+
+        data = connection.execute(QueryBuilder.revoke_deck_token_issuer_signing_key, { id: id })
+        DeckTokenIssuer.new(data['deckTokenIssuerSigningKeyRevoke'], client: client)
       end
 
       def grant_api_application_access(input:)
@@ -580,27 +531,19 @@ module CardDB
       end
       # rubocop:enable Naming/PredicateMethod
 
-      def exchange_access_token(input:)
-        config.require_secret_credential!('decks.exchange_access_token')
+      def exchange_token(input:)
+        config.require_secret_credential!('decks.exchange_token')
 
-        data = connection.execute(QueryBuilder.exchange_deck_access_token, { input: input })
-        DeckAccessTokenExchangePayload.new(data['deckAccessTokenExchange'], client: client)
-      end
-
-      # Exchange the current secret API application credential for an app-owned deck session token.
-      def exchange_session_token(input:)
-        config.require_secret_credential!('decks.exchange_session_token')
-
-        data = connection.execute(QueryBuilder.exchange_deck_session_token, { input: input })
-        DeckSessionTokenExchangePayload.new(data['deckSessionTokenExchange'], client: client)
+        data = connection.execute(QueryBuilder.exchange_deck_token, { input: input })
+        DeckTokenExchangePayload.new(data['deckTokenExchange'], client: client)
       end
 
       # rubocop:disable Naming/PredicateMethod
-      def revoke_access_token(id:)
-        config.require_secret_credential!('decks.revoke_access_token')
+      def revoke_token(id:)
+        config.require_secret_credential!('decks.revoke_token')
 
-        data = connection.execute(QueryBuilder.revoke_deck_access_token, { id: id })
-        !!data['deckAccessTokenRevoke']
+        data = connection.execute(QueryBuilder.revoke_deck_token, { id: id })
+        !!data['deckTokenRevoke']
       end
       # rubocop:enable Naming/PredicateMethod
 
@@ -650,6 +593,42 @@ module CardDB
 
       private
 
+      def normalize_deck_json_input(input)
+        normalize_deck_json_value(input, path: 'input')
+      end
+
+      def normalize_deck_json_value(value, path:)
+        return value unless value.is_a?(Hash)
+
+        value.each_with_object({}) do |(key, child), normalized|
+          key_name = key.to_s
+          child_path = "#{path}.#{key_name}"
+
+          normalized[key] = if JSON_OBJECT_INPUT_KEYS.include?(key_name)
+                              normalize_json_object(child, child_path)
+                            elsif key_name == 'entries' && child.is_a?(Array)
+                              child.each_with_index.map do |entry, index|
+                                normalize_deck_json_value(entry, path: "#{child_path}[#{index}]")
+                              end
+                            else
+                              child
+                            end
+        end
+      end
+
+      def normalize_json_object(value, path)
+        return value if value.nil? || value.is_a?(Hash)
+
+        if value.is_a?(String)
+          parsed = JSON.parse(value)
+          return parsed if parsed.is_a?(Hash)
+        end
+
+        raise ValidationError, "#{path} must be a JSON object"
+      rescue JSON::ParserError
+        raise ValidationError, "#{path} must be a JSON object"
+      end
+
       def entry_identifier(entry)
         entry[:identifier] || entry['identifier'] || raise(ArgumentError, 'entry identifier is required')
       end

data/lib/carddb/version.rb

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

metadata

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