lighthouse-graphql 0.5.0 → 0.6.0

data/lib/lighthouse/upload_store.rb

@@ -1,32 +1,57 @@
 # frozen_string_literal: true
 
-require 'securerandom'
-
-# Where @upload puts a file, by default: an ActiveStorage blob, on the service
-# `disk` names (the default service without it), its key under `path`. The
-# argument then holds the blob's signed id, which a has_one_attached /
-# has_many_attached attribute attaches, and which ActiveStorage::Blob.find_signed
-# finds. Config.upload_store takes another `call(file, disk:, path:, public:)`.
+# Where @upload puts a file, as PHP Lighthouse's @upload puts it on one of the
+# app's Laravel disks: an ActiveStorage blob on one of the app's services
+# (config/storage.yml). `disk` names the service (config.active_storage.service
+# without it), `path` prefixes the blob's key. ActiveStorage sets visibility per
+# service (`public: true` in storage.yml), not per file, so `public` must agree
+# with the service's: the schema never says a file is private that anyone can
+# read, or public that no one can. The argument then holds the blob's signed id,
+# which a has_one_attached / has_many_attached attribute attaches (where Laravel
+# hands the stored path, for a model to keep). To store files elsewhere, declare
+# an ActiveStorage service for it, as a Laravel app declares a disk.
 module Lighthouse::GraphQL::UploadStore
   module_function
 
-  def call(file, disk: nil, path: nil, public: false) # rubocop:disable Lint/UnusedMethodArgument -- public is the service's setting
+  def call(file, argument:, disk: nil, path: nil, public: nil)
     unless defined?(::ActiveStorage::Blob)
-      raise Lighthouse::DefinitionError,
-            '@upload stores files with ActiveStorage: install it (bin/rails active_storage:install), or set Config.upload_store.'
+      raise Lighthouse::DefinitionError, '@upload stores files with ActiveStorage: install it (bin/rails active_storage:install).'
+    end
+    unless Lighthouse::GraphQL::Upload.file?(file)
+      raise Lighthouse::DefinitionError, "Expected argument `#{argument}` to be an uploaded file (Upload)."
     end
 
-    attributes = { io: file, filename: filename(file), content_type: file.try(:content_type), key: key(path) }
-    attributes[:service_name] = disk if disk
-    ::ActiveStorage::Blob.create_and_upload!(**attributes.compact).signed_id
+    service = service(argument, disk, public == true)
+    file.rewind if file.respond_to?(:rewind) # a @validator, or another argument the multipart map sent it to, may have read it
+    ::ActiveStorage::Blob.create_and_upload!(
+      io: file, filename: filename(file), content_type: file.try(:content_type), key: key(path), service_name: service.name
+    ).signed_id
+  end
+
+  # The service `disk` names, or the default one, checked to be as public as asked.
+  def service(argument, disk, public)
+    service = disk ? ::ActiveStorage::Blob.services.fetch(disk) : ::ActiveStorage::Blob.service
+    return service if (service.public? == true) == public
+
+    raise Lighthouse::DefinitionError, visibility_mismatch(argument, service.name, public)
+  rescue KeyError => e
+    raise Lighthouse::DefinitionError, "@upload on `#{argument}`: #{e.message}"
+  end
+
+  def visibility_mismatch(argument, service_name, public)
+    fix = public ? 'name a public one (public: true in config/storage.yml) with disk:' : 'pass public: true, or name a private one with disk:'
+    "@upload#{'(public: true)' if public} on `#{argument}` stores on the ActiveStorage service `#{service_name}`, " \
+      "which is #{'not ' if public}public: #{fix}."
   end
 
   def filename(file)
     file.respond_to?(:original_filename) ? file.original_filename : File.basename(file.path)
   end
 
+  # `path`'s directory, then a fresh token, as Laravel's `storeAs(path, hashName)`;
+  # under the root ("/", the default), ActiveStorage's own key.
   def key(path)
     prefix = path.to_s.delete_prefix('/').delete_suffix('/')
-    prefix.empty? ? nil : "#{prefix}/#{SecureRandom.base36(28)}"
+    prefix.empty? ? nil : "#{prefix}/#{::ActiveStorage::Blob.generate_unique_secure_token}"
   end
 end

data/sig/lighthouse.rbs

@@ -45,12 +45,6 @@ module Lighthouse
     def decode: (String global_id) -> Array[String]
   end
 
-  # Config.upload_store: stores the file an @upload argument carries, and returns
-  # what the argument holds instead (an ActiveStorage blob's signed id by default).
-  interface _UploadStore
-    def call: (untyped file, ?disk: String?, ?path: String?, ?public: bool?) -> untyped
-  end
-
   # Config.authenticated_user and Config.policy_user: the user of a request.
   interface _UserReader
     def call: (context? context) -> untyped
@@ -112,8 +106,6 @@ module Lighthouse
     def self.directive_map: () -> Hash[untyped, untyped]
 
     # An ActiveSupport::Cache::Store; Rails.cache by default.
-    def self.cache_store: () -> untyped
-    def self.cache_store=: (untyped store) -> untyped
 
     def self.transactional_mutations: () -> bool
     def self.transactional_mutations=: (bool? enabled) -> bool?
@@ -147,8 +139,6 @@ module Lighthouse
     def self.global_id: () -> _GlobalId
     def self.global_id=: (_GlobalId? codec) -> _GlobalId?
 
-    def self.upload_store: () -> _UploadStore
-    def self.upload_store=: (_UploadStore? store) -> _UploadStore?
 
     # Whether @broadcast triggers in an ActiveJob (Lighthouse::GraphQL::BroadcastJob)
     # unless the directive says shouldQueue; and the job's queue (nil: ActiveJob's default).

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lighthouse-graphql
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Vaz Innovation
@@ -78,14 +78,12 @@ files:
 - lib/generators/lighthouse/base_classes.rb
 - lib/generators/lighthouse/builder_generator.rb
 - lib/generators/lighthouse/class_generator.rb
+- lib/generators/lighthouse/install/graphql_ruby_install.rb
 - lib/generators/lighthouse/install/install_generator.rb
 - lib/generators/lighthouse/install/templates/graphql.config.yml.tt
 - lib/generators/lighthouse/install/templates/graphql_controller.rb.tt
 - lib/generators/lighthouse/install/templates/initializer.rb.tt
 - lib/generators/lighthouse/install/templates/schema.graphql.tt
-- lib/generators/lighthouse/install/templates/schema.rb.tt
-- lib/generators/lighthouse/mutation_generator.rb
-- lib/generators/lighthouse/query_generator.rb
 - lib/generators/lighthouse/subscription_generator.rb
 - lib/generators/lighthouse/validator_generator.rb
 - lib/lighthouse-graphql.rb
@@ -197,6 +195,7 @@ files:
 - lib/lighthouse/resolve_info.rb
 - lib/lighthouse/resolver_bases.rb
 - lib/lighthouse/resolver_dispatch.rb
+- lib/lighthouse/root_types.rb
 - lib/lighthouse/scalar_coercion.rb
 - lib/lighthouse/schema_cache.rb
 - lib/lighthouse/schema_factory.rb

data/lib/generators/lighthouse/install/templates/schema.rb.tt

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-# Executable schema built by Lighthouse from the SDL in <%= sdl_folder %>/. The
-# Dataloader batches relationship loads (@hasMany, @belongsTo, ...) to avoid N+1.
-# base_types names the base classes: every class a Query, Mutation or Subscription
-# field resolves to must inherit from its kind's, and a Subscription field with no
-# class of its own resolves with the subscription one. graphql-ruby builds the
-# SDL's types from the others (written by `rails g graphql:install`), and type
-# classes (Types::PostType, Types::DateTimeType, ...) inherit from them.
-<%= schema_name %> = Lighthouse::GraphQL::RbLightHouse.get_schema(
-  options: {
-    using: { GraphQL::Dataloader => {} },
-    base_types: {
-      resolver: <%= base_class_constant(:queries) %>,
-      mutation: <%= base_class_constant(:mutations) %>,
-      subscription: <%= base_class_constant(:subscriptions) %>,
-      object: Types::BaseObject,
-      interface: Types::BaseInterface,
-      union: Types::BaseUnion,
-      scalar: Types::BaseScalar,
-      enum: Types::BaseEnum,
-      input_object: Types::BaseInputObject
-    }
-  }
-)
-
-# Refuse expensive queries before they run (see the gem's docs/security.md):
-# <%= schema_name %>.max_complexity(300)
-# <%= schema_name %>.max_depth(12)

data/lib/generators/lighthouse/mutation_generator.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'class_generator'
-
-# `rails generate lighthouse:mutation PublishPost` — the class (a
-# Mutations::BaseMutation, so a GraphQL::Schema::Mutation) that `Mutation.publishPost`
-# resolves to by convention.
-class Lighthouse::Generators::MutationGenerator < Lighthouse::Generators::ClassGenerator
-  desc 'Generate the class of a Mutation field (a Mutations::BaseMutation) in app/graphql/mutations.'
-
-  private
-
-  def kind = :mutations
-
-  def body
-    <<~RUBY
-      # Resolves Mutation.#{class_basename.camelize(:lower)}. Keyword arguments are the field's
-      # arguments in snake_case; `object` and `context` are available. Raise
-      # GraphQL::ExecutionError for failures the client should see.
-      class #{class_basename} < #{superclass_name}
-        def resolve(**args)
-          raise NotImplementedError
-        end
-      end
-    RUBY
-  end
-
-  def usage
-    "Mutation.#{class_basename.camelize(:lower)} resolves to #{full_class_name} — add the field to your SDL without a resolving directive."
-  end
-end

data/lib/generators/lighthouse/query_generator.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'class_generator'
-
-# `rails generate lighthouse:query LatestPosts` — the resolver (a
-# Resolvers::BaseResolver, so a GraphQL::Schema::Resolver) that `Query.latestPosts`
-# resolves to by convention.
-class Lighthouse::Generators::QueryGenerator < Lighthouse::Generators::ClassGenerator
-  desc 'Generate the resolver of a Query field (a Resolvers::BaseResolver) in app/graphql/resolvers.'
-
-  private
-
-  def kind = :queries
-
-  def body
-    <<~RUBY
-      # Resolves Query.#{class_basename.camelize(:lower)}. Keyword arguments are the field's
-      # arguments in snake_case; `object` and `context` are available.
-      class #{class_basename} < #{superclass_name}
-        def resolve(**args)
-          raise NotImplementedError
-        end
-      end
-    RUBY
-  end
-
-  def usage
-    "Query.#{class_basename.camelize(:lower)} resolves to #{full_class_name} — add the field to your SDL without a resolving directive."
-  end
-end