capsium 0.3.0 → 0.6.0

data/lib/capsium/package/validator.rb

@@ -26,6 +26,7 @@ module Capsium
 
       def run
         Dir.mktmpdir do |dir|
+          @workdir = dir
           @package_path = prepare(dir)
           [metadata_check, manifest_check, routes_check,
            storage_check, security_check, content_check]
@@ -113,15 +114,39 @@ module Capsium
 
       # The merged content view (ARCHITECTURE.md section 5a) over the
       # package being validated; layered and tombstoned resources resolve
-      # the same way the reactor resolves them.
+      # the same way the reactor resolves them. For encapsulated
+      # packages the bundled dependencies (packages/, recursively) act
+      # as read-only exported layers exactly as at activation, so
+      # fallthrough routes referencing dependency content validate.
       def merged_view
         @merged_view ||= MergedView.new(
           @package_path,
           storage: Storage.new(metadata_path(STORAGE_FILE)),
-          manifest: Manifest.new(metadata_path(MANIFEST_FILE))
+          manifest: Manifest.new(metadata_path(MANIFEST_FILE)),
+          dependency_views: dependency_views(@package_path)
         )
       end
 
+      # The [guid, exported MergedView] layers of the dependencies
+      # bundled under the package directory's packages/ (empty when the
+      # package embeds no bundle).
+      def dependency_views(package_path)
+        bundle = Bundle.new(package_path)
+        return [] unless bundle.present?
+
+        bundle.entries.map do |guid, entry|
+          dependency_dir = File.join(@workdir, "bundles", guid.gsub(/[^A-Za-z0-9.-]/, "_"))
+          Packager.new.unpack(entry.file, dependency_dir)
+          [guid, MergedView.new(
+            dependency_dir,
+            storage: Storage.new(File.join(dependency_dir, STORAGE_FILE)),
+            manifest: Manifest.new(File.join(dependency_dir, MANIFEST_FILE)),
+            dependency_views: dependency_views(dependency_dir),
+            exported_only: true
+          )]
+        end
+      end
+
       def security_check
         security = Security.new(metadata_path(SECURITY_FILE))
         return result("security", []) unless security.present?

data/lib/capsium/package/verification.rb

@@ -19,13 +19,15 @@ module Capsium
       # Whether security.json declares a digital signature for this package.
       def signed? = @security.signed?
 
-      # Verifies the declared digital signature (RSA-SHA256) against the
-      # checksum-covered payload. True when the package is unsigned (nothing
-      # declared) or the signature verifies; false on mismatch.
-      def verify_signature = !signed? || Signer.new(@path).verify
+      # Verifies the declared digital signature against the
+      # checksum-covered payload, through the signer matching the
+      # declared certificateType (OpenPgpSigner for OpenPGP, the
+      # RSA-SHA256 Signer otherwise). True when the package is unsigned
+      # (nothing declared) or the signature verifies; false on mismatch.
+      def verify_signature = !signed? || Signer.signer_class_for(@path).new(@path).verify
 
       def verify_signature!
-        Signer.new(@path).verify! if signed?
+        Signer.signer_class_for(@path).new(@path).verify! if signed?
       end
     end
   end

data/lib/capsium/package.rb

@@ -13,6 +13,7 @@ module Capsium
     autoload :AuthenticationConfig, "capsium/package/authentication_config"
     autoload :AuthenticationData, "capsium/package/authentication_config"
     autoload :BasicAuthConfig, "capsium/package/authentication_config"
+    autoload :Bundle, "capsium/package/bundle"
     autoload :Dataset, "capsium/package/dataset"
     autoload :DatasetConfig, "capsium/package/storage_config"
     autoload :DependencyError, "capsium/package/dependency_resolver"
@@ -30,6 +31,9 @@ module Capsium
     autoload :Metadata, "capsium/package/metadata"
     autoload :MetadataData, "capsium/package/metadata_config"
     autoload :OAuth2Config, "capsium/package/authentication_config"
+    autoload :OpenPgp, "capsium/package/open_pgp"
+    autoload :OpenPgpCipher, "capsium/package/open_pgp_cipher"
+    autoload :OpenPgpSigner, "capsium/package/open_pgp_signer"
     autoload :Preparation, "capsium/package/preparation"
     autoload :Repository, "capsium/package/metadata_config"
     autoload :ResolvedDependency, "capsium/package/dependency_resolver"
@@ -73,10 +77,16 @@ module Capsium
     # Loads a package directory or .cap file. Composite packages
     # (metadata.dependencies, ARCHITECTURE.md section 4a) resolve against
     # the package store given as `store` (directory path or Store) or via
-    # CAPSIUM_STORE. `dependency_chain` is internal: the ancestor GUIDs
-    # used for circular-dependency detection during recursive resolution.
+    # CAPSIUM_STORE, falling back to the registry given as `registry`
+    # (Capsium::Registry or reference) or via CAPSIUM_REGISTRY when the
+    # store has no package for a dependency GUID. Dependencies bundled
+    # under packages/ (encapsulated packages, Capsium::Package::Bundle)
+    # resolve first, without any store or registry. `dependency_chain`
+    # is internal: the ancestor GUIDs used for circular-dependency
+    # detection during recursive resolution. `bundle` is internal too:
+    # the ancestor bundle serving re-declared transitive dependencies.
     def initialize(path, load_type: nil, decryption_key: nil, store: nil,
-                   dependency_chain: [])
+                   registry: nil, dependency_chain: [], bundle: nil)
       @decryption_key = decryption_key
       @original_path = Pathname.new(path).expand_path
       @path = prepare_package(@original_path).to_s
@@ -84,7 +94,7 @@ module Capsium
       create_package_structure
       load_package
       @name = metadata.name
-      @resolved_dependencies = resolve_dependencies(store, dependency_chain)
+      @resolved_dependencies = resolve_dependencies(store, registry, dependency_chain, bundle)
       validate_dependency_references!
       verify_integrity!
       verify_signature!
@@ -119,7 +129,16 @@ module Capsium
     # The merged content view across the storage layers (ARCHITECTURE.md
     # section 5a); exported_only gives the dependent-package view (section 4a).
     # Resolved dependencies act as read-only layers below all own layers.
-    def merged_view(exported_only: false)
+    # extra_layers stack above everything (the reactor's writable overlay);
+    # views with extra layers are built fresh, not memoized.
+    def merged_view(exported_only: false, extra_layers: [])
+      unless extra_layers.empty?
+        return MergedView.new(@path, storage: @storage, manifest: @manifest,
+                                     dependency_views: dependency_views,
+                                     exported_only: exported_only,
+                                     extra_layers: extra_layers)
+      end
+
       @merged_views ||= {}
       @merged_views[exported_only] ||=
         MergedView.new(@path, storage: @storage, manifest: @manifest,

data/lib/capsium/packager.rb

@@ -16,31 +16,16 @@ module Capsium
     class UnsafeEntryError < Capsium::Error; end
 
     DRIVE_LETTER_PATTERN = %r{\A[A-Za-z]:[/\\]}
+    DOT_ENTRIES = [".", ".."].freeze
 
     def pack(package, options = {})
-      directory = package.path
       output_file_name = "#{package.metadata.name}-#{package.metadata.version}.cap"
-      output_directory = File.dirname(directory)
-      cap_file_path = File.join(output_directory, output_file_name)
-
-      if File.exist?(cap_file_path) && !options[:force]
-        raise FileAlreadyExistsError,
-              "Package target already exists, aborting: `#{relative_path_current(cap_file_path)}`"
-      elsif File.exist?(cap_file_path)
-        puts "Package target already exists, overwriting: `#{relative_path_current(cap_file_path)}`"
-        FileUtils.rm_f(cap_file_path)
-      end
+      cap_file_path = File.join(File.dirname(package.path), output_file_name)
+      check_target(cap_file_path, options)
 
       Dir.mktmpdir do |dir|
-        FileUtils.cp_r("#{directory}/.", dir)
-        strip_security_artifacts(dir)
-        new_package = Package.new(dir)
-        new_package.solidify
-        generate_security(new_package)
-        new_cap_file_path = File.join(dir, output_file_name)
-        compress_package(new_package, new_cap_file_path)
-        puts "Package built at: #{new_cap_file_path}"
-        FileUtils.mv(new_cap_file_path, cap_file_path)
+        build_cap(package, dir, output_file_name, options)
+        FileUtils.mv(File.join(dir, output_file_name), cap_file_path)
         puts "Package created: #{relative_path_current(cap_file_path)}"
         return cap_file_path
       end
@@ -58,8 +43,9 @@ module Capsium
     end
 
     def compress_package(package, cap_file)
-      entries = Dir[File.join(package.path, "**", "**")].reject do |file|
-        File.expand_path(file) == File.expand_path(cap_file)
+      entries = Dir.glob(File.join(package.path, "**", "**"), File::FNM_DOTMATCH).reject do |file|
+        File.expand_path(file) == File.expand_path(cap_file) ||
+          DOT_ENTRIES.include?(File.basename(file))
       end
       Zip::File.open(cap_file, create: true) do |zipfile|
         entries.each do |file|
@@ -99,6 +85,62 @@ module Capsium
 
     private
 
+    # Guards the pack target: without :force an existing .cap aborts,
+    # with :force it is removed first.
+    def check_target(cap_file_path, options)
+      if File.exist?(cap_file_path) && !options[:force]
+        raise FileAlreadyExistsError,
+              "Package target already exists, aborting: `#{relative_path_current(cap_file_path)}`"
+      end
+      return unless File.exist?(cap_file_path)
+
+      puts "Package target already exists, overwriting: `#{relative_path_current(cap_file_path)}`"
+      FileUtils.rm_f(cap_file_path)
+    end
+
+    # Builds the .cap inside the temporary directory: copy, optional
+    # dependency bundling, solidify, security.json, compress.
+    def build_cap(package, directory, output_file_name, options)
+      FileUtils.cp_r("#{package.path}/.", directory)
+      strip_security_artifacts(directory)
+      bundle_dependencies(directory, options) if options[:bundle_deps]
+      new_package = load_packed_package(directory, options)
+      new_package.solidify
+      generate_security(new_package)
+      built_path = File.join(directory, output_file_name)
+      compress_package(new_package, built_path)
+      puts "Package built at: #{built_path}"
+    end
+
+    # Loads the copied package directory for solidification, with the
+    # pack-time store/registry available for dependency resolution.
+    def load_packed_package(directory, options)
+      Package.new(directory, store: options[:store], registry: options[:registry])
+    end
+
+    # Encapsulated packing (`pack --bundle-deps`): resolves every
+    # declared dependency through the store -> registry chain and embeds
+    # the resolved .cap files under packages/ (Capsium::Package::Bundle),
+    # so the packed package activates with no store or registry. Only
+    # the declared dependencies are bundled — the one-level policy: the
+    # parent's metadata.dependencies must list the transitive closure.
+    # Typed dependency errors (DependencyNotFoundError,
+    # UnsatisfiableDependencyError) propagate for unresolvable
+    # dependencies.
+    def bundle_dependencies(directory, options)
+      metadata = Package::Metadata.new(File.join(directory, Package::METADATA_FILE))
+      declared = metadata.dependencies
+      return if declared.empty?
+
+      resolver = Package::DependencyResolver.new(
+        options[:store] || Package::Store.default, registry: options[:registry]
+      )
+      resolutions = declared.map do |guid, range|
+        [guid, resolver.resolve_path(guid, range, chain: [metadata.guid])]
+      end
+      Package::Bundle.write(directory, resolutions)
+    end
+
     # Resolves an entry name against the destination and returns the
     # absolute target path, raising UnsafeEntryError when the entry would
     # escape the destination (zip-slip).

data/lib/capsium/reactor/content_api.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Capsium
+  class Reactor
+    # Content writes over the mount's overlay (ARCHITECTURE.md section
+    # 5a): PUT creates/overwrites a content file (creating its route on
+    # demand), DELETE records a tombstone so the path 404s even when a
+    # lower layer holds the file. The immutable package never changes
+    # on disk. Text bodies only for v1.
+    class ContentApi
+      include Responses
+
+      WRITE_METHODS = %w[PUT DELETE].freeze
+      CONTENT_PREFIX = "#{Package::CONTENT_DIR}/".freeze
+
+      def self.write_method?(method)
+        WRITE_METHODS.include?(method)
+      end
+
+      def initialize(mount)
+        @mount = mount
+      end
+
+      def handle(inner_path, request, response)
+        return read_only(response) unless @mount.writable?
+
+        route = @mount.routes.resolve(inner_path)
+        return guard_route(route, inner_path, response) if route && !writable_route?(route)
+
+        case request.request_method
+        when "PUT" then put_content(inner_path, route, request, response)
+        when "DELETE" then delete_content(inner_path, route, response)
+        else respond_method_not_allowed(response)
+        end
+      end
+
+      private
+
+      # A route is writable when it is a plain resource route (or no
+      # route at all): dataset paths are the DataApi's, handler routes
+      # are not writable, dependency content stays immutable.
+      def writable_route?(route)
+        route.kind == :resource && !route.dependency_reference?
+      end
+
+      def guard_route(route, inner_path, response)
+        return respond_method_not_allowed(response) if route.kind == :dataset
+
+        respond_error(response, 400, "cannot write #{route.kind} content: #{inner_path}")
+      end
+
+      def put_content(inner_path, route, request, response)
+        relative = content_relative(resource_path(inner_path, route))
+        return unsafe_path(inner_path, response) if relative.nil?
+
+        @mount.overlay.write_content(relative, request.body.to_s)
+        resource = "#{Package::CONTENT_DIR}/#{relative}"
+        @mount.package.routes.add_route(inner_path, resource) unless route
+        respond_json(response, 200, { path: inner_path, resource: resource })
+      rescue Overlay::Error => e
+        respond_error(response, 400, e.message)
+      end
+
+      # Tombstones the served resource: 404 when the path is already
+      # tombstoned or nothing (here or in a lower layer) serves it.
+      def delete_content(inner_path, route, response)
+        relative = content_relative(resource_path(inner_path, route))
+        return unsafe_path(inner_path, response) if relative.nil?
+        return respond_not_found(response) if @mount.overlay.tombstones.include?(relative)
+        unless @mount.merged_view.resolve("#{Package::CONTENT_DIR}/#{relative}")
+          return respond_not_found(response)
+        end
+
+        @mount.overlay.delete_content(relative)
+        response.status = 204
+      rescue Overlay::Error => e
+        respond_error(response, 400, e.message)
+      end
+
+      def unsafe_path(inner_path, response)
+        respond_error(response, 400, "unsafe content path: #{inner_path}")
+      end
+
+      def read_only(response)
+        respond_error(response, 403, "package #{@mount.package.name} is read-only")
+      end
+
+      # The package resource a write addresses: the existing route's
+      # resource (overwrite what GET serves), else a content file
+      # derived from the URL path (created on demand).
+      def resource_path(inner_path, route)
+        route ? route.resource : "#{Package::CONTENT_DIR}/#{inner_path.delete_prefix('/')}"
+      end
+
+      # The content/-relative path for a package resource, nil for
+      # unsafe paths (outside content/, dot segments).
+      def content_relative(resource_path)
+        return nil unless resource_path.start_with?(CONTENT_PREFIX)
+
+        relative = resource_path.delete_prefix(CONTENT_PREFIX)
+        segments = relative.split("/")
+        return nil if segments.empty? || segments.any? { |s| s.empty? || s == ".." }
+
+        relative
+      end
+    end
+  end
+end

data/lib/capsium/reactor/data_api.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Capsium
+  class Reactor
+    # REST CRUD over a mount's datasets (ARCHITECTURE.md sections 5 and
+    # 5a): JSON item append/read/replace/delete against the overlay-
+    # merged collection. Writes go only to the mount's writable overlay;
+    # the immutable package never changes on disk.
+    class DataApi
+      include Responses
+
+      PREFIX = "/api/v1/data/"
+      COLLECTION_PATTERN = %r{\A/api/v1/data/(?<dataset>[^/]+)\z}
+      ITEM_PATTERN = %r{\A/api/v1/data/(?<dataset>[^/]+)/(?<id>[^/]+)\z}
+
+      def self.path?(inner_path)
+        inner_path.start_with?(PREFIX)
+      end
+
+      def initialize(mount)
+        @mount = mount
+      end
+
+      # The declared dataset route a data path addresses (the collection
+      # route, also for item paths), or nil when the package does not
+      # route this dataset — undeclared datasets are not served.
+      def route_for(inner_path)
+        match = COLLECTION_PATTERN.match(inner_path) || ITEM_PATTERN.match(inner_path)
+        return nil unless match
+
+        route = @mount.routes.resolve("#{PREFIX}#{match[:dataset]}")
+        route if route&.dataset == match[:dataset]
+      end
+
+      def handle(inner_path, request, response)
+        route = route_for(inner_path)
+        return respond_not_found(response) unless route
+
+        dataset = @mount.package.storage.dataset(route.dataset)
+        return respond_not_found(response) unless dataset
+
+        collection = COLLECTION_PATTERN.match(inner_path)
+        if collection
+          handle_collection(dataset, request, response)
+        else
+          handle_item(dataset, ITEM_PATTERN.match(inner_path)[:id], request, response)
+        end
+      end
+
+      private
+
+      def handle_collection(dataset, request, response)
+        case request.request_method
+        when "GET" then respond_json(response, 200, @mount.dataset_data(dataset))
+        when "POST" then append_item(dataset, request, response)
+        else respond_method_not_allowed(response)
+        end
+      end
+
+      def handle_item(dataset, id, request, response)
+        case request.request_method
+        when "GET" then read_item(dataset, id, response)
+        when "PUT" then replace_item(dataset, id, request, response)
+        when "DELETE" then delete_item(dataset, id, response)
+        else respond_method_not_allowed(response)
+        end
+      end
+
+      def append_item(dataset, request, response)
+        return unless writable?(dataset, response)
+
+        item = parse_body(request, response)
+        return if item.nil?
+
+        id = @mount.overlay.append_item(dataset, item)
+        response["Location"] = "#{request.path}/#{id}"
+        respond_json(response, 201, item)
+      rescue Overlay::Error => e
+        respond_overlay_error(response, e)
+      end
+
+      def read_item(dataset, id, response)
+        respond_json(response, 200, @mount.overlay.item(dataset, id))
+      rescue Overlay::ItemNotFoundError
+        respond_not_found(response)
+      end
+
+      def replace_item(dataset, id, request, response)
+        return unless writable?(dataset, response)
+
+        item = parse_body(request, response)
+        return if item.nil?
+
+        @mount.overlay.replace_item(dataset, id, item)
+        respond_json(response, 200, item)
+      rescue Overlay::ItemNotFoundError
+        respond_not_found(response)
+      rescue Overlay::Error => e
+        respond_overlay_error(response, e)
+      end
+
+      def delete_item(dataset, id, response)
+        return unless writable?(dataset, response)
+
+        @mount.overlay.delete_item(dataset, id)
+        response.status = 204
+      rescue Overlay::ItemNotFoundError
+        respond_not_found(response)
+      end
+
+      # Write guards: 403 for a read-only mount, 501 for a SQLite
+      # dataset (not file-backed JSON/YAML).
+      def writable?(dataset, response)
+        unless @mount.writable?
+          respond_error(response, 403, "package #{@mount.package.name} is read-only")
+          return false
+        end
+        if dataset.config.sqlite?
+          respond_error(response, 501,
+                        "dataset #{dataset.name} is SQLite; writes are not supported")
+          return false
+        end
+        true
+      end
+
+      # The JSON request body, or nil after answering 400 (invalid JSON)
+      # or 422 (a null body cannot be an item).
+      def parse_body(request, response)
+        body = JSON.parse(request.body.to_s)
+        if body.nil?
+          respond_error(response, 422, "request body must not be null")
+          return nil
+        end
+
+        body
+      rescue JSON::ParserError => e
+        respond_error(response, 400, "invalid JSON body: #{e.message}")
+        nil
+      end
+
+      def respond_overlay_error(response, error)
+        case error
+        when Overlay::ConflictError then respond_error(response, 409, error.message)
+        when Overlay::SchemaViolationError
+          respond_error(response, 422, "schema validation failed",
+                        messages: error.messages)
+        else respond_error(response, 422, error.message)
+        end
+      end
+    end
+  end
+end

data/lib/capsium/reactor/endpoints.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Capsium
+  class Reactor
+    # Serving of the reactor-level endpoints (introspection reports,
+    # per-package save), mixed into Reactor.
+    module Endpoints
+      include Responses
+
+      private
+
+      def serve_introspection(request, response)
+        return respond_method_not_allowed(response) unless request.request_method == "GET"
+
+        report = @introspection.report_for(request.path, params: request.query)
+        return respond_not_found(response) if report.nil?
+
+        respond_json(response, 200, report)
+      end
+
+      # POST /package/<name>/save: folds the mounted package's base plus
+      # its overlay into a new versioned .cap in the workdir.
+      def serve_package_save(request, response)
+        return respond_method_not_allowed(response) unless request.request_method == "POST"
+
+        name = PACKAGE_SAVE_PATTERN.match(request.path)[:name]
+        mount = @mounts.find { |candidate| candidate.package.name == name }
+        return respond_not_found(response) unless mount
+        return respond_error(response, 403, "package #{name} is read-only") unless mount.writable?
+
+        respond_json(response, 200, PackageSaver.new(mount).save(@workdir))
+      end
+    end
+  end
+end

data/lib/capsium/reactor/graphql_api.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "graphql"
+require "json"
+
+module Capsium
+  class Reactor
+    # GraphQL over a mount's datasets (POST and GET <mount>/graphql):
+    # executes the schema GraphqlSchema derives from the package's
+    # storage and maps the overlay's typed errors into the "errors"
+    # array (never a 500 on user error). Query fields read the merged
+    # collection; mutations match the REST semantics, schema validation
+    # included.
+    class GraphqlApi
+      include Responses
+
+      PATH = "/graphql"
+
+      def self.path?(inner_path)
+        inner_path == PATH
+      end
+
+      def initialize(mount)
+        @mount = mount
+        @schema = GraphqlSchema.new(mount, self).build
+      end
+
+      def handle(request, response)
+        case request.request_method
+        when "POST" then handle_post(request, response)
+        when "GET" then handle_get(request, response)
+        else respond_method_not_allowed(response)
+        end
+      end
+
+      # Query/mutation resolvers (public; called from the derived
+      # schema's fields).
+      def collection(dataset, id: nil)
+        return @mount.overlay.items(dataset) if id.nil?
+
+        [@mount.overlay.item(dataset, id)]
+      rescue Overlay::Error => e
+        raise execution_error(e)
+      end
+
+      def create_item(dataset, item:)
+        ensure_writable!
+        @mount.overlay.append_item(dataset, item)
+        item
+      rescue Overlay::Error => e
+        raise execution_error(e)
+      end
+
+      def update_item(dataset, id:, item:)
+        ensure_writable!
+        @mount.overlay.replace_item(dataset, id, item)
+        item
+      rescue Overlay::Error => e
+        raise execution_error(e)
+      end
+
+      def remove_item(dataset, id:)
+        ensure_writable!
+        @mount.overlay.delete_item(dataset, id)
+        true
+      rescue Overlay::Error => e
+        raise execution_error(e)
+      end
+
+      private
+
+      def handle_post(request, response)
+        payload = JSON.parse(request.body.to_s)
+        unless payload.is_a?(Hash) && payload["query"].is_a?(String)
+          return respond_error(response, 400, "GraphQL POST body must be " \
+                                              '{"query": "...", "variables": {...}}')
+        end
+
+        execute(response, payload["query"], variables: payload["variables"],
+                                            operation_name: payload["operationName"])
+      rescue JSON::ParserError => e
+        respond_error(response, 400, "invalid JSON body: #{e.message}")
+      end
+
+      def handle_get(request, response)
+        query = request.query["query"]
+        return respond_error(response, 400, "missing GraphQL query") if query.nil?
+
+        execute(response, query, variables: parse_variables(request.query["variables"]),
+                                 operation_name: request.query["operationName"])
+      end
+
+      def parse_variables(raw)
+        return nil if raw.nil?
+
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def execute(response, query, variables:, operation_name:)
+        result = @schema.execute(query, variables: variables || {},
+                                        operation_name: operation_name)
+        respond_json(response, 200, result.to_h)
+      end
+
+      def ensure_writable!
+        return if @mount.writable?
+
+        raise GraphQL::ExecutionError, "package #{@mount.package.name} is read-only"
+      end
+
+      def execution_error(error)
+        message = if error.is_a?(Overlay::SchemaViolationError)
+                    error.messages.join("; ")
+                  else
+                    error.message
+                  end
+        GraphQL::ExecutionError.new(message)
+      end
+    end
+  end
+end