graphql-armory 0.1.0.pre2 → 0.1.0.pre4

data/lib/graphql/armory/encoder/default.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Armory
+    class Encoder
+      ENV_KEY = "GRAPHQL_ARMORY_KEY"
+      RAILS_PURPOSE = "graphql-armory/ids"
+
+      # An encoder whose key comes from the app, never from the gem: `GRAPHQL_ARMORY_KEY`, or else a key derived
+      # with HKDF from Rails' secret_key_base for this purpose alone. Without either it raises, so the app fails
+      # when the schema loads instead of serving unencrypted IDs.
+      #
+      # It reads `secret_key_base` instead of `Rails.application.key_generator`: that generator is built once per
+      # process with whatever digest Rails has configured at that moment, which changes during boot, so the same
+      # secret could give different IDs in a web server and in a rake task (and calling it early would also fix
+      # Rails' own cookie keys to the wrong digest).
+      def self.default(env: ENV, rails: rails_application)
+        secret = env_key(env)
+        secret = rails_key(rails) if secret.nil? && rails
+        if secret.nil?
+          raise ConfigurationError,
+                "no key for the default encoder: set #{ENV_KEY} (try `ruby -rsecurerandom -e 'puts SecureRandom.hex(32)'`), " \
+                "or run inside a Rails app with a secret_key_base"
+        end
+
+        Class.new(self) { key(secret) }
+      end
+
+      def self.env_key(env)
+        value = env[ENV_KEY].to_s
+        return nil if value.empty?
+        if value.strip != value || value.strip.empty?
+          raise ConfigurationError, "#{ENV_KEY} has leading or trailing whitespace, or only whitespace: remove it"
+        end
+
+        value
+      end
+      private_class_method :env_key
+
+      def self.rails_application
+        ::Rails.application if defined?(::Rails) && ::Rails.respond_to?(:application)
+      end
+      private_class_method :rails_application
+
+      def self.rails_key(rails)
+        secret = begin
+          rails.secret_key_base
+        rescue StandardError => error
+          # Rails' message may come from app code; name only its class so nothing secret is echoed.
+          raise ConfigurationError, "the default encoder could not read Rails' secret_key_base (#{error.class})"
+        end
+        raise ConfigurationError, "this Rails app has no secret_key_base for the default encoder" if secret.to_s.empty?
+
+        OpenSSL::KDF.hkdf(secret.to_s, salt: "graphql-armory", info: RAILS_PURPOSE, length: 32, hash: "SHA256")
+      end
+      private_class_method :rails_key
+    end
+  end
+end

data/lib/graphql/armory/encoder/legacy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module GraphQL
+  module Armory
+    class Encoder
+      # graphql-ruby's default base64, to keep reading the cursors and IDs clients already hold while migrating to
+      # encryption: put it last in `Encoder.versioned`. It reads base64 padded or not, url-safe or standard, and
+      # only when it holds printable text, so a tampered encrypted value never comes back as garbage. It is not
+      # encryption: anyone can forge what it reads. Remove it from the chain once old values have expired.
+      module Legacy
+        PRINTABLE = /\A[[:print:]]*\z/
+
+        def self.encode(text, nonce: false)
+          Base64.urlsafe_encode64(text.to_s, padding: false)
+        end
+
+        def self.decode(text, nonce: false)
+          raise InvalidError unless text.is_a?(String) && !text.empty?
+
+          plain = Base64.urlsafe_decode64(text.tr("+/", "-_").delete_suffix("==").delete_suffix("="))
+          raise InvalidError if plain.empty?
+          plain.force_encoding(Encoding::UTF_8)
+          raise InvalidError unless plain.valid_encoding? && plain.match?(PRINTABLE)
+
+          plain
+        rescue StandardError
+          raise InvalidError
+        end
+      end
+    end
+  end
+end

data/lib/graphql/armory/encoder/versioned.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Armory
+    class Encoder
+      # A chain of encoders, newest first: encodes with the first, decodes with whichever accepts the value.
+      # Build it with `Encoder.versioned(NewEncoder, OldEncoder, Encoder::Legacy)`.
+      class Versioned
+        attr_reader :encoders
+
+        def initialize(encoders)
+          raise ConfigurationError, "a versioned encoder needs at least one encoder" if encoders.empty?
+
+          encoders.each { |encoder| check(encoder) }
+          @encoders = encoders.freeze
+        end
+
+        def encode(text, nonce: false)
+          encoders.first.encode(text, nonce: nonce)
+        end
+
+        def decode(text, nonce: false)
+          data, encoder = decode_versioned(text, nonce: nonce)
+          raise InvalidError unless encoder
+
+          data
+        end
+
+        # The data and the encoder that decoded it, or `[nil, nil]`, so the app can treat old values differently.
+        def decode_versioned(text, nonce: false)
+          encoders.each do |encoder|
+            data = encoder.decode(text, nonce: nonce)
+            return [data, encoder] if data.is_a?(String)
+          rescue ConfigurationError
+            raise
+          rescue StandardError
+            next
+          end
+          [nil, nil]
+        end
+
+        private
+
+        # Fails at boot for a member that would otherwise refuse every value at request time.
+        def check(encoder)
+          unless %i[encode decode].all? { |name| encoder.respond_to?(name) }
+            raise ConfigurationError, "#{encoder.inspect} cannot be versioned: it must respond to encode and decode"
+          end
+          unless %i[encode decode].all? { |name| accepts_nonce?(encoder.method(name)) }
+            raise ConfigurationError, "#{encoder.inspect} cannot be versioned: encode and decode must accept `nonce:`"
+          end
+          return unless encoder.respond_to?(:key) && encoder.respond_to?(:tag) && encoder.key.nil?
+
+          raise ConfigurationError, "#{encoder.inspect} cannot be versioned: it has no key"
+        end
+
+        def accepts_nonce?(method)
+          method.parameters.any? { |kind, name| kind == :keyrest || (%i[key keyreq].include?(kind) && name == :nonce) }
+        end
+      end
+
+      def self.versioned(*encoders)
+        Versioned.new(encoders)
+      end
+    end
+  end
+end

data/lib/graphql/armory/encoder.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+
+module GraphQL
+  module Armory
+    # Encrypts and authenticates IDs and cursors with AES-256-GCM. Subclass it and set a key:
+    #
+    #   class AppEncoder < GraphQL::Armory::Encoder
+    #     key ENV.fetch("GRAPHQL_ARMORY_KEY")
+    #   end
+    #
+    # Cursors (`nonce: true`, as graphql-ruby's connections ask) get a random nonce, so the same position
+    # never gives the same cursor. IDs must be stable, so their nonce is derived from the ID itself with an
+    # HMAC: the same ID always encrypts the same way, and two different IDs never share a nonce.
+    # IDs and cursors use separate keys, so one is never accepted as the other.
+    class Encoder
+      # Raised for anything that does not decode: tampered, foreign, malformed. The message never says which.
+      class InvalidError < GraphQL::ExecutionError
+        def initialize(message = "Invalid ID or cursor")
+          super
+        end
+      end
+
+      class ConfigurationError < Armory::Error; end
+
+      # graphql-ruby's default text form for cursors: base64url without padding.
+      module URLSafeBase64
+        def self.encode(bytes)
+          Base64.urlsafe_encode64(bytes, padding: false)
+        end
+
+        def self.decode(text)
+          Base64.urlsafe_decode64(text)
+        end
+      end
+
+      MINIMUM_KEY_BYTES = 32
+      NONCE_BYTES = 12
+      AUTH_TAG_BYTES = 16
+      CIPHER = "aes-256-gcm"
+
+      class << self
+        # The key, at least 32 bytes. With no argument, answers it (inherited from the parent class).
+        def key(*value)
+          return setting(:@key, nil) if value.empty?
+
+          secret = value.first
+          unless secret.is_a?(String) && secret.bytesize >= MINIMUM_KEY_BYTES
+            raise ConfigurationError, "an Encoder key must be a String of at least #{MINIMUM_KEY_BYTES} bytes (try SecureRandom.hex(32))"
+          end
+
+          @key = secret
+        end
+
+        # Authenticated data: an ID made with another tag does not decode. Use it to separate apps or versions.
+        def tag(*value)
+          return setting(:@tag, "") if value.empty?
+          raise ConfigurationError, "an Encoder tag cannot be nil" if value.first.nil?
+
+          @tag = value.first.to_s
+        end
+
+        # Turns the encrypted bytes into text and back. Anything with `encode(bytes)` and `decode(text)`.
+        def codec(*value)
+          return setting(:@codec, URLSafeBase64) if value.empty?
+          raise ConfigurationError, "an Encoder codec must respond to encode and decode" unless %i[encode decode].all? { |name| value.first.respond_to?(name) }
+
+          @codec = value.first
+        end
+
+        def encode(text, nonce: false)
+          purpose = nonce ? :cursor : :id
+          bytes = text.to_s.b
+          iv = nonce ? OpenSSL::Random.random_bytes(NONCE_BYTES) : derived_nonce(bytes)
+          cipher = OpenSSL::Cipher.new(CIPHER).encrypt
+          cipher.key = subkey(purpose, :cipher)
+          cipher.iv = iv
+          cipher.auth_data = tag
+          sealed = cipher.update(bytes) + cipher.final
+          codec.encode(iv + sealed + cipher.auth_tag)
+        end
+
+        def decode(text, nonce: false)
+          purpose = nonce ? :cursor : :id
+          bytes = codec.decode(text.to_s)
+          # One text form only: a base64 variant with other padding bits is not the same ID.
+          raise InvalidError unless codec.encode(bytes) == text.to_s
+          raise InvalidError if bytes.bytesize < NONCE_BYTES + AUTH_TAG_BYTES
+
+          iv = bytes[0, NONCE_BYTES]
+          cipher = OpenSSL::Cipher.new(CIPHER).decrypt
+          cipher.key = subkey(purpose, :cipher)
+          cipher.iv = iv
+          cipher.auth_tag = bytes[-AUTH_TAG_BYTES..]
+          cipher.auth_data = tag
+          plain = cipher.update(bytes[NONCE_BYTES...-AUTH_TAG_BYTES]) + cipher.final
+          # An ID has one valid form only: its nonce must be the one derived from it.
+          raise InvalidError if !nonce && !OpenSSL.fixed_length_secure_compare(iv, derived_nonce(plain))
+
+          plain.force_encoding(Encoding::UTF_8)
+        rescue ConfigurationError
+          raise
+        rescue StandardError
+          # Whatever the codec, OpenSSL or the input raise, the client learns only that it did not decode.
+          raise InvalidError
+        end
+
+        private
+
+        def setting(ivar, default)
+          return instance_variable_get(ivar) if instance_variable_defined?(ivar)
+
+          superclass.respond_to?(:key) ? superclass.send(:setting, ivar, default) : default
+        end
+
+        def derived_nonce(bytes)
+          OpenSSL::HMAC.digest("SHA256", subkey(:id, :nonce), tag.b + "\0".b + bytes)[0, NONCE_BYTES]
+        end
+
+        # Separate keys per purpose and use, derived with HKDF and cached by the secret they come from, so a key
+        # changed later (here or in a parent class) is used at once.
+        def subkey(purpose, use)
+          secret = key or raise ConfigurationError, "#{name || "Encoder"} has no key: call `key` in its class body"
+          @subkeys ||= {}
+          @subkeys[[secret, purpose, use]] ||= OpenSSL::KDF.hkdf(secret, salt: "graphql-armory", info: "#{purpose}/#{use}",
+                                                                         length: 32, hash: "SHA256")
+        end
+      end
+    end
+  end
+end
+
+require "graphql/armory/encoder/versioned"
+require "graphql/armory/encoder/legacy"
+require "graphql/armory/encoder/default"

data/lib/graphql/armory/ids.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Armory
+    # Encrypted global IDs in one line:
+    #
+    #   class AppSchema < GraphQL::Schema
+    #     use GraphQL::Armory::IDs                         # the default encoder
+    #     use GraphQL::Armory::IDs, encoder: AppEncoder    # or your own
+    #   end
+    #
+    # Defines `id_from_object` (the type name and the record's id, encrypted) and `object_from_id`, which only
+    # honours visible object types that implement Node. A type that
+    # includes the authorization module's Base is looked up inside the user's scope; any other type only through
+    # `find: ->(type, key, context) { ... }`. Every ID that cannot be honoured answers nil, like a missing record.
+    module IDs
+      SEPARATOR = "/"
+
+      def self.use(schema, encoder: nil, find: nil)
+        lookup = Lookup.new(encoder: encoder || Encoder.default, find: find)
+        schema.define_singleton_method(:id_from_object) { |object, type, _context| lookup.id_for(object, type) }
+        schema.define_singleton_method(:object_from_id) { |id, context| lookup.object_for(id, context) }
+      end
+
+      # Turns records into IDs and IDs back into records.
+      class Lookup
+        attr_reader :encoder, :find
+
+        def initialize(encoder:, find: nil)
+          @encoder = encoder
+          @find = find
+        end
+
+        def id_for(object, type)
+          key = object.id
+          raise Encoder::ConfigurationError, "#{type.graphql_name} object has no id to build a global ID from" if key.nil?
+
+          encoder.encode("#{type.graphql_name}#{SEPARATOR}#{key}")
+        end
+
+        def object_for(id, context)
+          type_name, key = encoder.decode(id).split(SEPARATOR, 2)
+          return nil if key.nil? || key.empty?
+
+          type = visible_type(type_name, context)
+          return nil unless node_type?(type)
+
+          load(type, key, context)
+        rescue Encoder::InvalidError
+          nil
+        end
+
+        private
+
+        # Through the query's own view of the schema: `Schema.get_type(name, context)` does not apply `visible?`
+        # when graphql-ruby runs without `Schema::Visibility`, `context.types` does in both modes.
+        def visible_type(type_name, context)
+          context.respond_to?(:types) ? context.types.type(type_name) : context.schema.get_type(type_name, context)
+        end
+
+        # Only object types that implement Node can have handed out an ID: root types, payloads and introspection
+        # types never did, so an ID naming them is not honoured (and their model is never looked up).
+        def node_type?(type)
+          type.respond_to?(:kind) && type.kind.object? &&
+            type.interfaces.any? { |interface| interface.graphql_name == "Node" }
+        end
+
+        def load(type, key, context)
+          return Authorization::Integration.find(type, nil, key, context) if type.respond_to?(:armory_model)
+
+          find&.call(type, key, context)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/armory/persisted_queries/manifest.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module GraphQL
+  module Armory
+    module PersistedQueries
+      # The operations a client build produced, loaded from Apollo's persisted query manifest or Relay's
+      # persisted output. Every id must be the digest of its query, so an edited manifest cannot put another
+      # query behind an id; every query is parsed once, here. Any problem raises at boot, and no message
+      # quotes the manifest's values: they may hold query text.
+      class Manifest
+        DIGESTS = { sha256: Digest::SHA256, sha1: Digest::SHA1, md5: Digest::MD5 }.freeze
+        APOLLO_FORMAT = "apollo-persisted-query-manifest"
+        ID_LIKE = /\A[A-Za-z0-9_.:-]{1,128}\z/
+
+        Operation = Struct.new(:id, :name, :body, :document, keyword_init: true)
+
+        def self.load(path, digest: :sha256)
+          data = begin
+            JSON.parse(File.read(path, mode: "r:bom|utf-8"))
+          rescue JSON::ParserError
+            # Not the parser's message: it quotes the file's content.
+            raise ConfigurationError, "#{path} is not valid JSON"
+          rescue SystemCallError => error
+            raise ConfigurationError, "#{path} cannot be read (#{error.class})"
+          end
+          new(data, digest: digest)
+        end
+
+        # `digest:` is how ids were made: :sha256 (Apollo), :md5 or :sha1 (Relay's options), or false for ids
+        # that are not digests (then nothing proves an id belongs to its query).
+        def initialize(data, digest: :sha256)
+          unless digest == false || DIGESTS.key?(digest)
+            raise ConfigurationError, "unknown digest #{digest.inspect}: use #{DIGESTS.keys.map(&:inspect).join(", ")} or false"
+          end
+
+          @digest = digest && DIGESTS.fetch(digest)
+          @operations = entries(data).each_with_index.with_object({}) do |((id, name, body), index), operations|
+            operation = operation(index, id, name, body)
+            raise ConfigurationError, "operation #{label(index, id)} appears twice in the manifest" if operations.key?(id)
+
+            operations[id] = operation
+          end.freeze
+          raise ConfigurationError, "the manifest holds no operations: is it the right file?" if @operations.empty?
+        end
+
+        def fetch(id)
+          @operations[id]
+        end
+
+        def size
+          @operations.size
+        end
+
+        private
+
+        # [id, name, body] triples from either format. A Relay map may have an operation keyed "format", so a
+        # Hash is Apollo's when its format says so, or when it has both "format" and "operations".
+        def entries(data)
+          raise ConfigurationError, unknown_format unless data.is_a?(Hash)
+          return apollo_entries(data) if data["format"] == APOLLO_FORMAT || (data.key?("format") && data.key?("operations"))
+
+          data.map { |id, body| [id, nil, body] }
+        end
+
+        def apollo_entries(data)
+          raise ConfigurationError, "unknown manifest format: expected #{APOLLO_FORMAT}" unless data["format"] == APOLLO_FORMAT
+          raise ConfigurationError, "unsupported manifest version: expected 1" unless data["version"].eql?(1)
+          raise ConfigurationError, "the manifest's operations must be an array" unless data["operations"].is_a?(Array)
+
+          data["operations"].each_with_index.map do |entry, index|
+            raise ConfigurationError, "manifest entry #{index} is not an object" unless entry.is_a?(Hash)
+
+            entry.values_at("id", "name", "body")
+          end
+        end
+
+        def operation(index, id, name, body)
+          unless id.is_a?(String) && body.is_a?(String) && (name.nil? || name.is_a?(String))
+            raise ConfigurationError, "manifest entry #{index} needs a String id, a String body and a String name or none"
+          end
+          if @digest && @digest.hexdigest(body) != id
+            raise ConfigurationError, "operation #{label(index, id)} is not the digest of its query: the manifest was edited, or `digest:` is wrong"
+          end
+
+          # Copies, so neither the caller's data nor a fetched operation can change what a later fetch returns.
+          Operation.new(id: id.dup.freeze, name: name&.dup&.freeze, body: body.dup.freeze, document: parse(label(index, id), body)).freeze
+        end
+
+        def parse(label, body)
+          GraphQL.parse(body)
+        rescue GraphQL::ParseError
+          raise ConfigurationError, "operation #{label} does not parse"
+        end
+
+        # The id names the operation in errors only when it looks like an id; otherwise it may be query text.
+        def label(index, id)
+          id.match?(ID_LIKE) ? id : "at entry #{index}"
+        end
+
+        def unknown_format
+          "unknown manifest format: expected Apollo's persisted query manifest or Relay's persisted output"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/armory/persisted_queries.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "json"
+
+module GraphQL
+  module Armory
+    # Persisted queries: clients send the id of an operation their build produced, and the server runs the
+    # stored query. With strict mode on, it refuses queries it does not hold.
+    #
+    #   class AppSchema < GraphQL::Schema
+    #     use GraphQL::Armory::PersistedQueries, store: Manifest.load("persisted-queries.json"), strict: true
+    #   end
+    #
+    #   AppSchema.execute(params[:query], context: { operation_id: PersistedQueries.operation_id(params) })
+    #
+    # Hooks only `Schema.query_class`: the stored document goes to the query as `document:`, so it is parsed once,
+    # at boot, and runs the same on both engines.
+    module PersistedQueries
+      class ConfigurationError < Armory::Error; end
+
+      UNKNOWN_OPERATION = "Unknown operation id"
+      MISMATCH = "The operation id and the query do not match"
+      RAW_QUERY_REFUSED = "Only persisted operations are allowed: send an operation id"
+
+      # What a refused request holds: nothing to run.
+      EMPTY_DOCUMENT = GraphQL::Language::Nodes::Document.new(definitions: [])
+
+      # Validates nothing and answers the refusal, through the query's public `static_validator:` option.
+      class Refusal < GraphQL::StaticValidation::Validator
+        def initialize(schema, message)
+          super(schema: schema)
+          @message = message
+        end
+
+        def validate(_query, **)
+          { errors: [GraphQL::StaticValidation::Error.new(@message)], remaining_timeout: nil }
+        end
+      end
+
+      # `store:` answers `fetch(id)` with an operation (`body` and `document`) or nil: a Manifest, or your own.
+      # `strict: true` refuses raw queries unless the context holds `armory_allow_raw_query: true`.
+      def self.use(schema, store:, strict: false)
+        if store.is_a?(Hash) || !store.respond_to?(:fetch)
+          raise ConfigurationError, "store: must answer fetch(id) with an operation or nil, like a Manifest"
+        end
+        raise ConfigurationError, "strict: must be true or false, got #{strict.inspect}" unless strict == true || strict == false
+
+        if schema.singleton_class.include?(Guard)
+          raise ConfigurationError, "#{schema} already uses PersistedQueries (here or in a parent schema): use it once"
+        end
+
+        schema.instance_variable_set(:@armory_persisted_queries, [store, strict].freeze)
+        schema.singleton_class.prepend(Guard)
+        schema.query_class(schema.query_class)
+      end
+
+      # Keeps the lookup in every query class the schema uses, including one set after `use` or by a child schema.
+      module Guard
+        UNSET = Object.new.freeze
+
+        def query_class(new_query_class = UNSET)
+          return super() if UNSET.equal?(new_query_class)
+          return super(new_query_class) if new_query_class.include?(Lookup)
+
+          super(Class.new(new_query_class) { include Lookup })
+        end
+
+        def armory_persisted_queries
+          @armory_persisted_queries || superclass.armory_persisted_queries
+        end
+      end
+
+      # The operation id a request sent, from Rack or Rails params: `operationId`, `extensions.operationId` or
+      # Apollo's `extensions.persistedQuery.sha256Hash` (`extensions` may arrive as a JSON string on GET).
+      # Answers nil when there is none, or when it is not a non-empty String.
+      def self.operation_id(params)
+        params = plain(params)
+        extensions = params["extensions"]
+        extensions = parse_json(extensions) if extensions.is_a?(String)
+        extensions = plain(extensions)
+        persisted_query = plain(extensions["persistedQuery"])
+
+        [params["operationId"], extensions["operationId"], persisted_query["sha256Hash"]].find do |candidate|
+          candidate.is_a?(String) && !candidate.empty?
+        end
+      end
+
+      def self.plain(value)
+        value = value.to_unsafe_h if value.respond_to?(:to_unsafe_h)
+        value.is_a?(Hash) ? value : {}
+      end
+      private_class_method :plain
+
+      def self.parse_json(text)
+        JSON.parse(text)
+      rescue JSON::ParserError
+        nil
+      end
+      private_class_method :parse_json
+
+      # Swaps the request's query for the stored document, or for nothing with an error when it is refused.
+      module Lookup
+        def initialize(schema, query_string = nil, **options)
+          store, strict = schema.armory_persisted_queries
+          context = options[:context]
+          operation_id = context[:operation_id] if context.respond_to?(:[])
+          text = query_string || options[:query]
+          text = nil if text == ""
+
+          refusal, document =
+            if !operation_id.nil?
+              operation = operation_id.is_a?(String) ? store.fetch(operation_id) : nil
+              if operation.nil?
+                UNKNOWN_OPERATION
+              elsif options[:document] || (text && !same_query?(text, operation))
+                MISMATCH
+              else
+                [nil, operation.document]
+              end
+            elsif strict && !(context.respond_to?(:[]) && context[:armory_allow_raw_query] == true)
+              RAW_QUERY_REFUSED
+            end
+
+          return super if refusal.nil? && document.nil?
+          return super(schema, nil, **options, query: nil, document: document) if refusal.nil?
+
+          # A refused request fails validation with the refusal as its only error, so neither engine runs it. Its
+          # text is never parsed; a document the app built itself is kept, for `Schema.validate`, which validates it
+          # with its own validator.
+          super(schema, nil, **options, query: nil, document: options[:document] || EMPTY_DOCUMENT, validate: true, static_validator: Refusal.new(schema, refusal))
+        end
+
+        private
+
+        # Apollo's clients may send the query with its id; graphql-ruby's subscriptions resend it printed.
+        def same_query?(text, operation)
+          text == operation.body || text == operation.document.to_query_string
+        end
+      end
+    end
+  end
+end
+
+require "graphql/armory/persisted_queries/manifest"

data/lib/graphql/armory/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Armory
-    VERSION = "0.1.0.pre2"
+    VERSION = "0.1.0.pre4"
   end
 end

data/lib/graphql/armory.rb

@@ -10,4 +10,7 @@ module GraphQL
   end
 end
 
+require "graphql/armory/encoder"
 require "graphql/armory/authorization"
+require "graphql/armory/ids"
+require "graphql/armory/persisted_queries"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql-armory
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre2
+  version: 0.1.0.pre4
 platform: ruby
 authors:
 - Israel
@@ -41,6 +41,9 @@ files:
 - LICENSE
 - MIGRATING.md
 - README.md
+- docs/authorization.md
+- docs/encrypted-ids.md
+- docs/persisted-queries.md
 - lib/graphql-armory.rb
 - lib/graphql/armory.rb
 - lib/graphql/armory/authorization.rb
@@ -72,6 +75,13 @@ files:
 - lib/graphql/armory/authorization/rule.rb
 - lib/graphql/armory/authorization/scope.rb
 - lib/graphql/armory/authorization/telemetry.rb
+- lib/graphql/armory/encoder.rb
+- lib/graphql/armory/encoder/default.rb
+- lib/graphql/armory/encoder/legacy.rb
+- lib/graphql/armory/encoder/versioned.rb
+- lib/graphql/armory/ids.rb
+- lib/graphql/armory/persisted_queries.rb
+- lib/graphql/armory/persisted_queries/manifest.rb
 - lib/graphql/armory/version.rb
 - lib/tasks/graphql_armory.rake
 homepage: https://github.com/israelb/graphql-armory