arangorb 1.4.1 → 2.0.0

data/lib/Edge.rb

@@ -0,0 +1,104 @@
+# === GRAPH VERTEX ===
+
+module Arango
+  class Edge < Arango::Document
+    def initialize(name: nil, collection:, body: {}, rev: nil, from: nil,
+      to: nil)
+      assign_collection(collection)
+      body[:_key]  ||= name
+      body[:_rev]  ||= rev
+      body[:_from] ||= from
+      body[:_to]   ||= to
+      body[:_id]   ||= "#{@collection.name}/#{name}" unless name.nil?
+      assign_attributes(body)
+    end
+
+# === DEFINE ===
+
+    attr_reader :collection, :database, :server, :graph
+
+    def collection=(collection)
+      satisfy_class?(collection, [Arango::Collection])
+      if collection.graph.nil?
+        raise Arango::Error.new err: :collection_does_not_have_a_graph, data:
+          {"name_collection": collection.name, "graph": nil}
+      end
+      @collection = collection
+      @graph      = @collection.graph
+      @database   = @collection.database
+      @server     = @database.server
+    end
+    alias assign_collection collection=
+
+# == GET ==
+
+    def retrieve(if_match: false)
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("GET", "edge/#{@collection.name}/#{@body[:_key]}",
+        headers: headers, key: :edge)
+      return_element(result)
+    end
+
+# == POST ==
+
+    def create(body: {}, waitForSync: nil)
+      body = @body.merge(body)
+      query = {
+        "waitForSync": waitForSync,
+        "_from":      @body[:_from],
+        "_to":        @body[:_to]
+      }
+      result = @graph.request("POST", "edge/#{@collection.name}", body: body,
+        query: query, key: :edge)
+      return result if @server.async != false
+      body2 = result.clone
+      body = body.merge(body2)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+# == PUT ==
+
+    def replace(body: {}, waitForSync: nil, keepNull: nil, if_match: false)
+      query = {
+        "waitForSync": waitForSync,
+        "keepNull":    keepNull
+      }
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("PUT", "edge/#{@collection.name}/#{@body[:_key]}",
+        body: body, query: query, headers: headers, key: :edge)
+      return result if @server.async != false
+      body2 = result.clone
+      body = body.merge(body2)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+    def update(body: {}, waitForSync: nil, if_match: false)
+      query = {"waitForSync": waitForSync}
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("PATCH", "edge/#{@collection.name}/#{@body[:_key]}",
+        body: body, query: query, headers: headers, key: :edge)
+      return result if @server.async != false
+      body2 = result.clone
+      body = body.merge(body2)
+      body = @body.merge(body)
+      assign_attributes(body)
+      return return_directly?(result) ? result : self
+    end
+
+# === DELETE ===
+
+    def destroy(waitForSync: nil, if_match: false)
+      query = {"waitForSync": waitForSync}
+      headers = {}
+      headers[:"If-Match"] = @body[:_rev] if if_match
+      result = @graph.request("DELETE", "edge/#{@collection.name}/#{@body[:_key]}",
+        query: query, headers: headers)
+      return_delete(result)
+    end
+  end
+end

data/lib/Error.rb

@@ -0,0 +1,125 @@
+# === ERROR ===
+
+module Arango
+  class Error < StandardError
+    @@list_arango_rb_errors = {
+      no_other_aql_next: {
+        code: 10001, message: "No other values with AQL next"
+      },
+      no_other_simple_next: {
+        code: 10002, message: "No other values with AQL next"
+      },
+      is_a_edge_collection: {
+        code: 10003, message: "This collection is an Edge collection"
+      },
+      is_a_document_collection: {
+        code: 10004, message: "This collection is a Document collection"
+      },
+      database_graph_no_same_as_collection_database: {
+        code: 10005, message: "Database of graph is not the same as the class"
+      },
+      wrong_type_instead_of_expected_one: {
+        code: 10006, message: "Expected a type, received another"
+      },
+      no_other_export_next: {
+        code: 10007, message: "No other values with AQL next"
+      },
+      no_aql_id_available: {
+        code: 10008, message: "AQL does not have id. It could have already been killed"
+      },
+      id_is_not_valid: {
+        code: 10009, message: "Given attribute is not a valid document id or an Arango::Document"
+      },
+      collection_does_not_have_a_graph: {
+        code: 10010, message: "Collection does not have a graph"
+      },
+      arangodb_did_not_return_a_valid_result: {
+        code: 10011, message: "ArangoDB didn't return a valid result"
+      },
+      read_or_write_should_be_string_or_collections: {
+        code: 10012, message: "read or write should be an array of name classes or Arango::Collections"
+      },
+      wrong_class: {
+        code: 10013, message: "Wrong class"
+      },
+      wrong_element: {
+        code: 10014, message: "Element is not part of the list"
+      },
+      orphan_collection_used_by_edge_definition: {
+        code: 10015, message: "Orphan collection is already used by an edge definition"
+      },
+      impossible_to_parse_arangodb_response: {
+        code: 10016, message: "Impossible to parse ArangoDB response"
+      },
+      batch_query_not_valid: {
+        code: 10017, message: "Query is not valid"
+      },
+      arangorb_didnt_return_a_valid_result: {
+        code: 10018, message: "ArangoRB didn't return a valid result"
+      },
+      impossible_to_connect_with_database: {
+        code: 10019, message: "Impossible to connect with database"
+      },
+      you_cannot_assign_from_or_to_to_a_vertex: {
+        code: 10020, message: "You cannot assign from or to to a Vertex"
+      },
+      wrong_start_vertex_type: {
+        code: 10021, message: "Starting vertex should be an Arango::Vertex, an Arango::Document (not Edge) or a valid vertex id"
+      },
+      database_undefined_for_traversal: {
+        code: 10022, message: "Database undefined for traversal"
+      },
+      edge_collection_should_be_of_type_edge: {
+        code: 10022, message: "Database undefined for traversal"
+      }
+    }
+
+    def initialize(err:, data: nil, skip_assignment: false)
+      unless skip_assignment
+        @message = @@list_arango_rb_errors[err][:message]
+        @code = @@list_arango_rb_errors[err][:code]
+        @internal_code = err
+        @data = data
+      end
+      super(@message)
+    end
+    attr_reader :data, :code, :message
+
+    def to_h
+      {
+        "message": @message,
+        "code": @code,
+        "data": @data,
+        "internal_code": @internal_code
+      }.delete_if{|k,v| v.nil?}
+    end
+  end
+end
+
+module Arango
+  class ErrorDB < Arango::Error
+    def initialize(message:, code:, data:, errorNum:, action:, url:, request:)
+      @message  = message
+      @code     = code
+      @data     = data
+      @errorNum = errorNum
+      @action   = action
+      @url      = url
+      @request  = request
+      super(err: nil, skip_assignment: true)
+    end
+    attr_reader :message, :code, :data, :errorNum, :action, :url, :request
+
+    def to_h
+      {
+        "action": @action,
+        "url": @url,
+        "request": @request,
+        "message": @message,
+        "code": @code,
+        "data": @data,
+        "errorNum": @errorNum
+      }.delete_if{|k,v| v.nil?}
+    end
+  end
+end

data/lib/Foxx.rb

@@ -0,0 +1,277 @@
+# === FOXX ===
+
+module Arango
+  class Foxx
+    include Arango::Helper_Error
+    include Arango::Helper_Return
+    include Arango::Database_Return
+
+    def self.new(*args)
+      hash = args[0]
+      super unless hash.is_a?(Hash)
+      database = hash[:database]
+      if database.is_a?(Arango::Database) && database.server.active_cache && !hash[:mount].nil?
+        cache_name = "#{database.name}/#{hash[:mount]}"
+        cached = database.server.cache.cache.dig(:foxx, cache_name)
+        if cached.nil?
+          hash[:cache_name] = cache_name
+          return super
+        else
+          body = hash[:body] || {}
+          [:mount, :development, :legacy, :provides, :name, :version,
+            :type, :setup, :teardown].each{|k| body[k] ||= hash[k]}
+          cached.assign_attributes(body)
+          return cached
+        end
+      end
+      super
+    end
+
+    def initialize(database:, body: {}, mount:, development: nil, legacy: nil,
+      provides: nil, name: nil, version: nil, type: "application/json",
+      setup: nil, teardown: nil, cache_name: nil)
+      assign_database(database)
+      unless cache_name.nil?
+        @cache_name = cache_name
+        @server.cache.save(:foxx, cache_name, self)
+      end
+      assign_attributes(body)
+      assign_type(type)
+      @mount       ||= mount
+      @development ||= development
+      @setup       ||= setup
+      @legacy      ||= legacy
+      @provides    ||= provides
+      @name        ||= name
+      @version     ||= version
+      @teardown    ||= teardown
+    end
+
+# === DEFINE ===
+
+    attr_reader :database, :server, :type, :body, :cache_name
+    attr_accessor :name, :development, :legacy, :provides,
+      :version, :mount, :setup, :teardown
+
+    def body=(result)
+      if result.is_a?(Hash)
+        @body        = result
+        @name        = result[:name]        || @name
+        @version     = result[:version]     || @version
+        @mount       = result[:mount]       || @mount
+        @development = result[:development] || @development
+        @legacy      = result[:legacy]      || @legacy
+        @provides    = result[:provides]    || @provides
+        if @server.active_cache && @cache_name.nil?
+          @cache_name = "#{@database.name}/#{@mount}"
+          @server.cache.save(:task, @cache_name, self)
+        end
+      end
+    end
+    alias assign_attributes body=
+
+    def type=(type)
+      satisfy_category?(type, ["application/zip", "zip", "application/javascript", "javascript", "application/json", "json", "multipart/form-data", "data"], "type")
+      type = "application/#{type}" if ["zip", "javascript", "json"].include?(type)
+      type = "multipart/form-data" if type == "data"
+      @type = type
+    end
+    alias assign_type type=
+
+# === TO HASH ===
+
+    def to_h
+      {
+        "name": @name,
+        "version": @version,
+        "mount": @mount,
+        "development": @development,
+        "legacy": @legacy,
+        "provides": @provides,
+        "type": @type,
+        "teardown": @teardown,
+        "cache_name": @cache_name,
+        "database": @database.name
+      }.delete_if{|k,v| v.nil?}
+    end
+
+    def return_foxx(result, val=nil)
+      return result if @server.async != false
+      case val
+      when :configuration
+        @configuration = result
+      when :dependencies
+        @dependencies = result
+      else
+        assign_attributes(result)
+      end
+      return return_directly?(result) ? result : self
+    end
+    private :return_foxx
+
+  # === ACTIONS ===
+
+    def retrieve
+      query = {"mount": @mount}
+      result = @database.request("GET", url: "_api/foxx/service")
+      return_foxx(result)
+    end
+
+    def create(body: @body, type: @type, development: @development,
+      setup: @setup, legacy: @legacy)
+      headers = {"Accept": type}
+      skip_to_json = type != "application/json"
+      query = {
+        "mount":        @mount,
+        "setup":        setup,
+        "development ": development ,
+        "legacy":       legacy
+      }
+      result = @database.request("POST",
+        url: "_api/foxx", body: body, headers: headers,
+        skip_to_json: skip_to_json, query: query)
+      return_foxx(result)
+    end
+
+    def destroy(teardown: @teardown)
+      query = {
+        "mount":    @mount,
+        "teardown": teardown
+      }
+      result = @database.request("DELETE", "_api/foxx/service", query: query)
+      return_foxx(result)
+    end
+
+    def replace(body: @body, type: @type, teardown: @teardown, setup: @setup,
+      legacy: @legacy)
+      headers = {"Accept": type}
+      skip_to_json = type != "application/json"
+      query = {
+        "mount": @mount,
+        "setup": setup,
+        "development ": development,
+        "legacy": legacy
+      }
+      result = @database.request("PUT", "_api/foxx/service", body: body,
+        headers: headers, skip_to_json: skip_to_json, query: query)
+      return_foxx(result)
+    end
+
+    def update(body: @body, type: @type, teardown: @teardown,
+      setup: @setup, legacy: @legacy)
+      assign_type(type)
+      headers = {"Accept": type}
+      skip_to_json = @type != "application/json"
+      query = {
+        "mount":        @mount,
+        "setup":        setup,
+        "development ": development,
+        "legacy":       legacy
+      }
+      result = @database.request("PATCH", "_api/foxx/service", body: body,
+        headers: headers, skip_to_json: skip_to_json, query: query)
+      return_foxx(result)
+    end
+
+  # === CONFIGURATION ===
+
+    def retrieveConfiguration
+      query = {"mount": @mount}
+      result = @database.request("GET", "_api/foxx/configuration", query: query)
+      return_foxx(result, :configuration)
+    end
+
+    def updateConfiguration(body:)
+      query = {"mount": @mount}
+      result = @database.request("PATCH", "_api/foxx/configuration", query: query, body: body)
+      return_foxx(result, :configuration)
+    end
+
+    def replaceConfiguration(body:)
+      query = {"mount": @mount}
+      result = @database.request("PUT", "_api/foxx/configuration", query: query, body: body)
+      return_foxx(result, :configuration)
+    end
+
+    # === DEPENDENCY ===
+
+    def retrieveDependencies
+      query = {"mount": @mount}
+      result = @database.request("GET", "_api/foxx/dependencies", query: query)
+      return_foxx(result, :dependencies)
+    end
+
+    def updateDependencies(body:)
+      query = {"mount": @mount}
+      result = @database.request("PATCH", "_api/foxx/dependencies", query: query, body: body)
+      return_foxx(result, :dependencies)
+    end
+
+    def replaceDependencies(body:)
+      query = {"mount": @mount}
+      result = @database.request("PUT", "_api/foxx/dependencies", query: query, body: body)
+      return_foxx(result, :dependencies)
+    end
+
+    # === MISCELLANEOUS
+
+    def scripts
+      query = {"mount": @mount}
+      @database.request("GET", "_api/foxx/scripts", query: query)
+    end
+
+    def run_script(name:, body: {})
+      query = {"mount": @mount}
+      @database.request("POST", "_api/foxx/scripts/#{name}", query: query, body: body)
+    end
+
+    def tests(reporter: nil, idiomatic: nil)
+      satisfy_category?(reporter, [nil, "default", "suite", "stream", "xunit", "tap"])
+      headers = {}
+      headers[:"Content-Type"] = case reporter
+      when "stream"
+        "application/x-ldjson"
+      when "tap"
+        "text/plain, text/*"
+      when "xunit"
+        "application/xml, text/xml"
+      else
+        nil
+      end
+      query = {"mount": @mount}
+      @database.request("GET", "_api/foxx/scripts", query: query, headers: headers)
+    end
+
+    def enableDevelopment
+      query = {"mount": @mount}
+      @database.request("POST", "_api/foxx/development", query: query)
+    end
+
+    def disableDevelopment
+      query = {"mount": @mount}
+      @database.request("DELETE", "_api/foxx/development", query: query)
+    end
+
+    def readme
+      query = {"mount": @mount}
+      @database.request("GET", "_api/foxx/readme", query: query)
+    end
+
+    def swagger
+      query = {"mount": @mount}
+      @database.request("GET", "_api/foxx/swagger", query: query)
+    end
+
+    def download(path:, warning: @server.warning)
+      query = {"mount": @mount}
+      @server.download("POST", "_db/#{@database.name}/_api/foxx/download",
+        path: path, query: query)
+      puts "File saved in #{path}" if warning
+    end
+
+    def commit(body:, replace: nil)
+      query = {"replace": replace}
+      @database.request("POST", "_api/foxx/commit", body: body, query: query)
+    end
+  end
+end