arcadedb 0.3.1 → 0.4

data/lib/arcade/database.rb

@@ -0,0 +1,367 @@
+module Arcade
+  ##
+  # Implements the Database-Adapter
+  #
+  #  currently, only attributes of type String are supported
+  #
+  #  {Database-instance}.database points to the connected Aradedb-database
+  #  DB.hi
+  #
+  ##
+  class Database
+    include Logging
+    extend Dry::Core::ClassAttributes
+    include Support::Model                          #  provides  allocate_model
+
+    defines :namespace
+    defines :environment
+
+    def initialize  environment=:development
+      self.class.configure_logger( Config.logger ) 
+      @connection =  connect environment
+      if self.class.environment.nil?    # class attribute is set on the first call
+                                        # further instances of Database share the same environment
+        self.class.environment  environment
+      end
+      self.class.namespace  Object.const_get( Config.namespace )
+    end
+
+    def database
+      @database ||= Config.database[self.class.environment]
+    end
+
+    # ------------  types ------------...
+    # returns an Array of type-attributes
+    # [{:name=>"Account", :type=>"document"},
+    # {:name=>"test", :type=>"vertex"},
+    # {:name=>"test1", :type=>"vertex"},
+    # {:parentTypes=>["test1"], :name=>"test2", :type=>"vertex"}]
+    #
+    def types refresh=false
+      #  uses API
+      if $types.nil? || refresh
+       $types = Api.query(database, "select from schema:types"   )
+                   .map{ |x| x.transform_keys &:to_sym     }   #  symbolize keys
+                   .map{ |y| y.delete_if{|_,b,| b.empty? } }   #  eliminate  empty entries
+      end
+      $types
+      ## upom startup, this is the first access to the database-server
+    rescue NoMethodError => e
+      logger.fatal "Could not read Database Types. \n Is the database running?"
+      Kernel.exit
+    end
+
+    def indexes
+      DB.types.find{|x| x.key? :indexes }[:indexes]
+    end
+
+    # ------------ hierarchy -------------
+    #  returns an Array of types
+    #
+    #  each  entry is an Array
+    #  => [["test"], ["test1", "test2"]]   (using the example above)
+    #
+    #  Parameter:  type --  one of  'vertex', 'document', 'edge'
+    def hierarchy type: 'vertex'
+      #  uses API
+      # gets all types depending  on the parent-type
+      pt = ->( s ) { types.find_all{ |x| x[:parentTypes] &.include?(s) }.map{ |v| v[:name] } }
+      # takes an array of base-types. gets recursivly all childs
+      child_types = -> (base_types) do
+        base_types.map do | bt |
+          if pt[ bt ].empty?
+            [ bt ]
+          else
+            [bt, child_types[ pt[ bt  ]  ] ].flatten
+          end
+        end
+      end
+
+      # gets child-types  for all   base-types
+      child_types[ types.find_all{ |x| !x[:parentTypes]  && x[:type] == type.to_s }.map{ |v| v[:name] } ]
+
+    end
+
+
+    # ------------ create type -----------
+    #  returns an Array
+    #  Example:  > create_type :vertex, :my_vertex
+    #           => [{"typeName"=>"my_vertex", "operation"=>"create vertex type"}]
+    #
+    #  takes additional arguments:  extends: '<a supertype>'  (for inheritance)
+    #                               bucket:  <a list of  bucket-id's >
+    #                               buckets:  <how many bukets to assign>
+    #
+    #  additional arguments are just added to the command
+    #
+    # its aliased as `create_class`
+    #
+    def create_type kind, type, **args
+
+      exe = -> do
+        case kind.to_s.downcase
+        when /^v/
+          "create vertex type #{type} "
+        when /^d/
+          "create document type #{type} "
+        when /^e/
+          "create edge type #{type} "
+        end.concat( args.map{|x,y| "#{x} #{y} "}.join)
+      end
+      db= Api.execute database, &exe
+      types( true )  # update cached schema
+      db
+
+    rescue HTTPX::HTTPError => e
+#      puts "ERROR:  #{e.message.to_s}"
+      if e.status == 500 && e.message.to_s =~ /already exists/
+        Arcade::Database.logger.warn "Database type #{type} already present"
+      else
+        raise
+      end
+    end
+
+    alias create_class create_type
+
+    # ------------ drop type  -----------
+    #  delete any record prior to the attempt to drop a type.
+    #  The `unsafe` option is nit implemented.
+    def drop_type  type
+      Api.execute database, "drop type #{type} if exists"
+    end
+
+    # ------------ create  -----------
+    # returns an rid of the successfully  created vertex or document
+    #
+    #  Parameter:  name of the vertex or document type
+    #              Hash of attributes
+    #
+    #  Example:   > DB.create :my_vertex, a: 14, name: "Hugo"
+    #             => "#177:0"
+    #
+    def create type, **params
+      #  uses API
+      Api.create_document database, type,  **params
+    end
+
+    def insert  **params
+
+      content_params = params.except( :type, :bucket, :index, :from, :return )
+      target_params = params.slice( :type, :bucket, :index )
+      if  target_params.empty?
+        logger.error "Could not insert: target mising (type:, bucket:, index:)"
+      elsif content_params.empty?
+        logger.error "Nothing to Insert"
+      else
+        content =  "CONTENT #{ content_params.to_json }"
+        target =  target_params.map{|y,z|  y==:type ?  z : "#{y.to_s} #{ z } "}.join
+        Api.execute( database, "INSERT INTO #{target} #{content} ") &.first.allocate_model(false)
+      end
+    end
+
+    # ------------------------------  get        ------------------------------------------------------ #
+    # Get fetches the record associated with the rid given as parameter.
+    #
+    # The rid is accepted as
+    #   DB.get "#123:123",   DB.get "123:123"  or DB.get 123, 123
+    #
+    #  Links are autoloaded  (can be suppressed by the optional Block (false))
+    #
+    # puts DB.get( 19,0 )
+    # <my_document[#19:0]: emb : ["<my_alist[#33:0]: name : record 1, number : 1>", "<my_alist[#34:0]: name : record 2, number : 2>"]>
+    # puts DB.get( 19,0 ){ false  }
+    # <my_document[#19:0]: emb : ["#33:0", "#34:0"]>
+    #
+    #
+    def get *rid
+      autocomplete = block_given? ? yield :  true
+      rid =  rid.join(':')
+      rid = rid[1..-1] if rid[0]=="#"
+      if rid.rid?
+        Api.query( database, "select from #{rid}" ).first &.allocate_model(autocomplete)
+      else
+        raise Arcade::QueryError "Get requires a rid input", caller
+      end
+    end
+
+    # ------------------------------  property        ------------------------------------------------- #
+    # Adds properties to the type
+    #
+    #  call via
+    #  Api.property <database>, <type>, name1: a_format , name2: a_format
+    #
+    #  Format is one of
+    #   Boolean, Integer, Short, Long, Float, Double, String
+    #   Datetime, Binary, Byte, Decimal, Link
+    #   Embedded, EmbeddedList, EmbeddedMap
+    #
+    #   In case of an Error,  anything is rolled back and nil is returned
+    #
+    def self.property database, type, **args
+
+      begin_transaction database
+      success = args.map do | name, format |
+        r= execute(database) {" create property #{type.to_s}.#{name.to_s} #{format.to_s} " } &.first
+        if r.nil?
+          false
+        else
+          r.keys == [ :propertyName, :typeName, :operation ] && r[:operation] == 'create property'
+        end
+      end.uniq
+      if success == [true]
+        commit database
+        true
+      else
+        rollback database
+      end
+
+
+    end
+
+    # ------------------------------ index            ------------------------------------------------- #
+    def self.index database, type,  name ,  *properties
+      properties = properties.map( &:to_s )
+      unique_requested = "unique" if properties.delete("unique")
+      unique_requested = "notunique" if  properties.delete("notunique" )
+      automatic = true if
+      properties << name  if properties.empty?
+    end
+
+    def delete rid
+      r =  Api.execute( database ){ "delete from #{rid}" }
+      success =  r == [{ :count => 1 }]
+    end
+
+    # execute a command  which modifies the database
+    #
+    # The operation is performed via Transaction/Commit
+    # If an Error occurs, its rolled back
+    #
+    def execute   &block
+      s = Api.begin_transaction database
+  #    begin
+      response = Api.execute database, nil, s, &block
+    #  rescue HTTPX::HTTPError => e
+    #    raise e.message
+    #    puts  e.methods
+    #    puts e.status
+    #    puts e.response
+    #    puts e.message
+    #    puts e.exception
+    #    puts e.cause
+    #  end
+      # puts response.inspect  # debugging
+      r= if  response.is_a? Hash
+           _allocate_model res
+#         elsif response.is_a? Array
+           # remove empty results
+#           response.delete_if{|y| y.empty?}
+          # response.map do | res |
+          #   if res.key? :"@rid"
+          #     allocate_model res
+          #   else
+          #     res
+          #   end
+          # end
+         else
+           response
+         end
+     if Api.commit( database, s) == 204
+        r # return associated array of Arcade::Base-objects
+     else
+       []
+     end
+    rescue  Dry::Struct::Error, HTTPX::HTTPError, Arcade::QueryError => e
+      Api.rollback database, s
+      logger.error "Execution  FAILED -->  Status #{e.status}"
+ #     logger.error "Execution  FAILED --> #{e.exception.message}"
+      []  #  return empty result
+    end
+
+    # returns an array of results
+    #
+    # detects database-records and  allocates them as model-objects
+    #
+    def query  query_object
+      Api.query database, query_object.to_s
+    end
+
+    #  returns an array of rid's   (same logic as create)
+    def create_edge  edge_class, from:, to:,  **attributes
+
+      content = attributes.empty? ?  "" : "CONTENT #{attributes.to_json}"
+      cr = ->( f, t ) do
+        begin
+        edges = Api.execute( database, "create edge #{edge_class} from #{f.rid} to #{t.rid} #{content}").allocate_model(false)
+        rescue HTTPX::HTTPError => e
+         # if e.status == 503
+         #   puts e.status
+         # puts e.message
+         # puts e.message.class
+         # end
+          raise unless e.message =~ /Found duplicate key/
+         puts "#"+e.message.split("#").last[0..-3]
+        end
+        #else
+        #  logger.error "Could not create Edge  #{edge_class} from #{f} to #{t}"
+        ##  logger.error edges.to_s
+        #end
+      end
+      from =  [from] unless from.is_a? Array
+      to =  [to] unless to.is_a? Array
+
+      from.map do | from_record |
+        to.map { | to_record | cr[ from_record, to_record ] if  to_record.rid? } if from_record.rid?
+      end.flatten
+
+    end
+
+
+    # query all:  select @rid, *  from {database}
+
+#  not used
+ #  def get_schema
+ #    query( "select from schema:types" ).map do |a|
+ #      puts "a: #{a}"
+ #      class_name = a["name"]
+ #      inherent_class =  a["parentTypes"].empty? ? [Object,nil] : a["parentTypes"].map(&:camelcase_and_namespace)
+ #       namespace, type_name = a["type"].camelcase_and_namespace
+ #       namespace= Arcade if namespace.nil?
+ #      klass=  Dry::Core::ClassBuilder.new(  name: type_name,
+ #                                          parent: nil,
+ #                                          namespace:  namespace).call
+ #    end
+ #  rescue NameError
+ #    logger.error "Dataset type #{e} not defined."
+ #    raise
+ #  end
+   #  Postgres is not implemented
+   # connects to the database and initialises @connection
+    def connection
+      @connection
+    end
+
+    def connect environment=:development   # environments:  production devel test
+      if [:production, :development, :test].include? environment
+
+        #  connect through the ruby  postgres driver
+#       c= PG::Connection.new  dbname: Config.database[environment],
+#         user: Config.username[environment],
+#         password: Config.password[environment],
+#         host:  Config.pg[:host],
+#         port:  Config.pg[:port]
+#
+     end
+    rescue PG::ConnectionBad => e
+      if e.to_s  =~  /Credentials/
+        logger.error  "NOT CONNECTED ! Either Database is not present or credentials (#{ Config.username[environment]} / #{Config.password[environment]}) are wrong"
+        nil
+      else
+        raise
+      end
+    end  # def
+
+
+
+  end  # class
+end  #  module

data/lib/arcade/errors.rb

@@ -0,0 +1,71 @@
+module Arcade
+
+  # Error handling
+  class Error < RuntimeError
+  end
+
+  class ArgumentError < ArgumentError
+  end
+
+  class SymbolError < ArgumentError
+  end
+
+  class LoadError < LoadError
+  end
+
+  class ImmutableError < RuntimeError
+  end
+  class IndexError < RuntimeError
+  end
+
+  class RollbackError < RuntimeError
+  end
+
+  class QueryError < RuntimeError
+  end
+
+  # used by Dry::Validation,  not covered by "error"
+  class InvalidParamsError < StandardError
+    attr_reader :object
+    # @param [Hash] object that contains details about params errors.
+    # # @param [String] message of the error.
+    def initialize(object, message)
+      @object = object
+      super(message)
+    end
+  end
+
+end # module  Arcade
+
+# Patching Object with universally accessible top level error method. 
+# The method is used throughout the lib instead of plainly raising exceptions. 
+# This allows lib user to easily inject user-specific error handling into the lib 
+# by just replacing Object#error method.
+#def error message, type=:standard, backtrace=nil
+#  e = case type
+#  when :standard
+#    Arcade::Error.new message
+#  when :args
+#    Arcade::ArgumentError.new message
+#  when :symbol
+#    Arcade::SymbolError.new message
+#  when :load
+#    Arcade::LoadError.new message
+#  when :immutable
+#    Arcade::ImmutableError.new message
+#  when :commit
+#    Arcade::RollbackError.new message
+#  when :query
+#    Arcade::QueryError.new message
+#  when :args
+#    IB::ArgumentError.new message
+#  when :flex
+#    IB::FlexError.new message
+#  when :reader
+#    IB::TransmissionError.new message
+#  when :verify
+#    IB::VerifyError.new message
+#  end
+#  e.set_backtrace(backtrace) if backtrace
+#  raise e
+#end

data/lib/arcade/logging.rb

@@ -0,0 +1,38 @@
+#require_relative 'default_formatter'
+module Arcade
+	module Logging
+		def self.included(base)
+			base.extend ClassMethods
+			base.send :define_method, :logger do
+				base.logger
+			end
+		end
+
+		module ClassMethods
+			def logger
+				@logger
+			end
+
+			def logger=(logger)
+				@logger = logger
+			end
+
+			def configure_logger(log= STDOUT)
+        if log.is_a? Logger
+					@logger = log
+				else
+					@logger = Logger.new log
+        end
+        @logger.level = Logger::INFO
+        @logger.formatter = DefaultFormatter
+      end
+		end
+
+	class DefaultFormatter < Logger::Formatter
+		def self.call(severity, time, program_name, msg)
+			"#{time.strftime("%d.%m.(%X)")}#{"%5s" % severity}->#{msg}\n"
+		end
+	end
+end
+end
+# source: https://github.com/jondot/sneakers/blob/master/lib/sneakers/concerns/logging.rb

data/lib/arcade/version.rb

@@ -0,0 +1,3 @@
+module Arcade
+  VERSION = "0.4"
+end

data/lib/arcade.rb

@@ -0,0 +1,36 @@
+module Arcade
+
+end
+
+require "arcade/version"
+require "dry/configurable"
+require "dry/struct"
+require "dry/core/class_builder"
+require "dry/core/class_attributes"
+require 'json'
+
+module Types
+  include Dry.Types()
+end
+require 'yaml'
+require 'securerandom'
+require 'httpx'
+require 'arcade/errors'
+require_relative '../lib/support/object'
+require_relative '../lib/support/string'
+require_relative '../lib/support/class'
+require_relative '../lib/support/sql'
+require_relative '../lib/support/model'
+require_relative '../lib/arcade/logging'
+require_relative '../lib/config'
+require_relative '../lib/support/conversions'
+require_relative '../lib/arcade/api/primitives'
+require_relative '../lib/arcade/api/operations'
+require_relative '../lib/arcade/base'
+require_relative '../lib/arcade/database'
+require_relative '../lib/init'
+require_relative "../lib/models"
+require_relative '../lib/query'
+require_relative '../lib/match'
+require_relative '../lib/railtie'  if defined? Rails::Railtie
+

data/lib/config.rb

@@ -0,0 +1,72 @@
+module Arcade
+  class Config
+    extend Dry::Configurable
+    # central place to initialize constants
+    #
+    # ProjectRoot has to be a Pathname-Object
+    #
+    #puts "expand: #{File.expand_path(__dir__)}"
+    unless Arcade.const_defined?( :ProjectRoot )
+      Arcade::ProjectRoot = if defined?( Rails.env )
+                              Rails.root
+                            else
+                              STDERR.puts "Using default (arcadedb gem)  database credentials and settings"
+      # logger is not present at this stage
+                              Pathname.new(  File.expand_path( "../../", __FILE__ ))
+      end
+    else
+      STDERR.puts "Using provided database credentials and settings fron #{Arcade::ProjectRoot}"
+    end
+
+
+    # initialised a hash  { environment => property }
+    setting :username, default: :user,      reader: true,
+      constructor:  ->(v) { yml(:environment).map{|x,y|  [x , y[v.to_s]] }.to_h }
+    setting :password, default: :password,  reader: true,
+      constructor:  ->(v) { yml(:environment).map{|x,y|  [x , y["pass"]] }.to_h }
+    setting :database, default: :database,  reader: true,
+      constructor:  ->(v) { yml(:environment).map{|x,y|  [x , y["dbname"]] }.to_h }
+    setting(:base_uri, default: :host ,    reader: true,
+            constructor:  ->(v) { "http://"+yml(:admin)[v]+':'+yml(:admin)[:port].to_s+"/api/v1/" })
+    setting :autoload,      default: :autoload,       reader: true , constructor:  ->(v) { yml(v) }
+    setting :pg,      default:  :pg,       reader: true , constructor:  ->(v) { yml(v) }
+    setting :admin,   default:  :admin,    reader: true , constructor:  ->(v) { yml(v) }
+    setting :logger,  default:  :logger,   reader: true ,
+      constructor:  ->(v) do
+                            if defined?( Rails.env )
+                              Rails.logger
+                            elsif Object.const_defined?(:Bridgetown)
+                            else
+                              output = yml(v)
+                              if output.upcase == 'STDOUT'
+                                Logger.new STDOUT
+                              else
+                                Logger.new File.open( output, 'a' )
+                              end
+                            end
+                          end
+    setting :namespace, default:  :namespace, reader: true , constructor:  ->(v) { yml(v) }
+    setting :secret, reader: true,  default: 12, constructor:  ->(v) { seed(v) }
+     private
+     # if a config dir exists, use it.
+     # Standard:  ProjectRoot/config.yml
+     def self.config_file
+
+       configdir =  -> do
+         pr =  ProjectRoot.is_a?(Pathname)?  ProjectRoot : Pathname.new( ProjectRoot )
+         ( cd =  pr + 'arcade.yml' ).exist? || ( cd =   pr + 'config' + 'arcade.yml' ).exist? || ( cd =   pr + 'config.yml' )
+         cd
+       end
+
+       @cd ||= configdir[]
+     end
+
+    def self.yml key=nil
+      y= YAML::load_file( config_file )
+      key.nil?  ?  y : y[key]
+    end
+    def self.seed( key= nil )
+      SecureRandom.hex( 40 )
+    end
+  end
+end

data/lib/init.rb

@@ -0,0 +1,50 @@
+module Arcade
+
+  # Arcade::Init.connect  environment
+  #  --------------------------------
+  # initializes the database connection
+  # and returns the active database handle
+  #
+  # The database cannot switched later
+  #
+  #
+  # Arcade::Init.db
+  #  --------------
+  # returns an instance of the database handle
+  #
+  class Init
+    extend Dry::Core::ClassAttributes
+    defines :db    # database handle
+
+    def self.connect e= :development
+
+      env =  if e.to_s =~ /^p/
+               :production
+             elsif e.to_s =~ /^t/
+               :test
+             else
+               :development
+             end
+      #      set the class attribute
+
+      db Database.new(env)
+    end
+  end
+
+  # Provides method  `db` to every Model class
+  class Base
+    def self.db
+      Init.db
+    end
+    # expose db  to instance methods as well
+    private  define_method :db, &method(:db)
+    private_class_method  :db
+  end
+  # Provides method  `db` to every Query-Object
+  class Query
+    def db
+      Init.db
+    end
+  end
+
+end