arcadedb 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d7f1f29472b0fb31734654c9456ec5bdfb31cd42fd46b658139ac840691c6f6
-  data.tar.gz: 4c1c95707c8e2c528654f2a7509b1b6943ef9615fe203c81cd421d52636dcac7
+  metadata.gz: f030932c1444832b3ea224120f71cc655837ca732717b896ed8587a8cefc0dd4
+  data.tar.gz: 96f05185b21af4820ebc667d796635e4b0c6c3ac42b59dc360212df7b287934e
 SHA512:
-  metadata.gz: f54746f04760ebfbc8c1588e66fb0bb52e820eef83df564e3563e37219835ff86c93e5b3d2e2a7617452218938c30a5aabff099361d0fd829890e2ac83411fc8
-  data.tar.gz: 0f8bf3623302c5204ca56552fb41694bfd506c493dc72463b8000e66c82aacddb7f42188f41508c84e9fc5bf93fa78e42e4235ed904982b97d38a4a5c8d4ff40
+  metadata.gz: 92ab840638f4a8e0cf56a5138d870bbb282223b9cc0c4b8f5bab39184712ce6742862ea0683a73b917e0b5a94acbd1bccc12ec6a52863caeba9a28b2aacf3132
+  data.tar.gz: 6fd195fb51f62fbcea2945f0688626084f8991936b745d6c939bae35bce4912414a80376535a379c3ca1166c4b62ffb2089c041d3951d87fe78ab5dcb421eae0

data/CHANGELOG.md

@@ -31,3 +31,20 @@ All notable changes to this project will be documented in this file.
 - Arcade::Match simple match-statement generator
 - return to Arcade::QueryError messages instead of HTTPX::HTTPError
 - The ProjectRoot Const is used to read configuration files (Changed from Arcade::ProjectRoot)
+
+## 0.5.1 - 2024-1-16
+- Included Arcade::RevisionRecord and Arcade::Revision model classes
+- Both provide basic support for audit proofed bookings
+## 0.5.2 - 2025-02-11
+- Include method Object#descendants (part of active-support)
+- Separate Dry::Type definitions to /lib/types.rb
+- added Vertex#coe (count of edeges) as service method for to_human
+- updated Match#inE, #outE methods to facilitate queries on properties on edges
+##       - 2025-03-15
+- support of Match.new vertex: {a prefetched Arcade::Vertex} and match.node( vertex: ...) 
+##       - 2025-03-25
+- support of Vertex.match( where conditions [, as: :return_element] )
+- added Vertex#match to build  'MATCH type: {class} rid: {rid}'
+
+
+

data/README.md

@@ -7,7 +7,7 @@ The server's response is then mapped to an ORM (Object-Relational Mapping) based
 Each database type is represented by a dedicated Model Class, where complex queries are encapsulated. 
 The program also includes a  Query-Preprocessor and Match-statment generator for constructing custom queries in ruby fashion.
 
-***ArcadeDB internally uses `Arcade` as primary namespace**** 
+***ArcadeDB internally uses `Arcade` as primary namespace*** 
 
 ## Prerequisites
 
@@ -76,9 +76,9 @@ __END__
 
 Only the `name` attribute is declared. 
 
-`Demo::User.create_type`  creates the type and executes provided database-commands after __END__.   
+`Demo::User.create_type`  creates the type and executes provided database-commands after `__END__`.   
 
-Other properties are schemaless, but have to be declared in the model-file. 
+Other properties are schemaless. They are present in the database and are mapped to the `value`-attribute on the ruby side.  
 
 ```ruby
 Person.insert name: "Hubert", age: 35
@@ -97,8 +97,8 @@ Person.delete all: true || where: age: 56 , ...
 
 Suppose
 ```ruby 
-m = Person.create name: 'Hubert', age: '25'
-f = Person.create name: 'Pauline', age: '28'
+m = Person.insert name: 'Hubert', age: 25
+f = Person.insert name: 'Pauline', age: 28
 m.assign via: IsMarriedTo, vertex: f , divorced: false
 
 ```
@@ -116,7 +116,7 @@ pauline = hubert.nodes( :out, via: IsMarriedTo ).first
 pauline = hubert.out.first
 
 ```
-Conditions may be set, to. 
+Conditions may be set, too. 
 ```ruby
 hubert.nodes( :out, via: IsMarriedTo, where: "age < 30" )
 ```
@@ -128,15 +128,15 @@ Person.nodes( :outE, via: IsMarriedTo, where: { divorced: false } )
 ```
 gets all wives where the divorced-condition, which is set on the edge, is false. 
 
-## Query
+### Query
 
 A **Query Preprocessor** is implemented. Its adapted from ActiveOrient. The [documentation](https://github.com/topofocus/active-orient/wiki/OrientQuery)
-is still valid,  however the class has changed to `Arcade::Query`. 
+is still valid, but the class has changed to `Arcade::Query`. 
 
-## Match
+### Match
 
-A simple **Match Statement Generator** is provided for convenience. As the [declarative syntax](https://github.com/ArcadeData/arcadedb-docs/blob/main/src/main/asciidoc/sql/SQL-Match.adoc)  seems to be  very  intuitive, a preprocessor should not be 
-necessary. With the help of some ruby magic, the creation of match-statements is simply an no-brainer.
+A simple **Match Statement Generator** is provided for convenience. As the [declarative syntax](https://github.com/ArcadeData/arcadedb-docs/blob/main/src/main/asciidoc/sql/SQL-Match.adoc)  is very intuitive, a preprocessor should not be 
+necessary. However, with the help of some ruby magic, the creation of match-statements is simply an no-brainer.
 
 ```ruby
 a =  Arcade::Match.new( type: Person, as: :persons)
@@ -148,9 +148,61 @@ a.to_s
 a.execute.select_results  #  sends the statement to the database and returns Arcade Objects. 
 ```
 
-Arcade::Match-objects can be used as `from:` argument to Arcade::Query-Statements, thus hybrid queries are 
+To query properties on Edges, `inE`, and `outE` are present.
+```ruby
+a =  Arcade::Match.new( type: Person, as: :persons)   ->  Match { type: person, as: persons}
+a.outE via: IsMarriedTo, where: { year: 1990..2000 }  ->  .outE('is_married_to'){ where: year between 1990 and 2000}
+                                                      ->  .outV('is_maried_to')  ...
+
+a.outE via: [IsMarriedTo, IsMarriedIn], where: { year: 1990..2000 }, as: :bride 
+                                                      ->   .outV('is_married_in') ... 
+```
+
+Match statements can also refer to a vertex:
+```ruby 
+p = Person.find name: 'tux'
+c = Person.find name: 'hilde'
+a = Arcade::Match.new( vertex: p )                    -> Match { type: person, rid: 2:0 }
+                 .out( IsMarriedTo )                  ->       .out('is_married_to')
+                 .node( as: :wife )                   ->       { as: wife }
+                 .out( HasChild )                     ->       .out('has_child')
+                 .node( vertex: c )                   ->       { type: person, rid: 2:1 }
+                                                      -> Return wife
+``` 
+fetches the vertex between two known vertices. This is the fastest lookup mechanism if the vertices are prefetched. 
+
+Arcade::Match-objects can be used as `from:` argument to Arcade::Query-Statements; hybrid queries are 
 easily constructed without extensive string-manipulations.
 
+#### Vertex based Match statements
+
+A `match`-method is implemented for  Vertex-Classes and vertices.
+
+The class-method takes any argument (except `as:`) as part of a `where`-condition.
+
+```ruby
+  
+m = Watchlist.match( symbol: 'iBit', as: :ibit ) 
+             .out( HasUnderlying)
+             .node( as: :u )
+           
+m.to_s
+  => "MATCH { type: watchlist, where: ( symbol='iBit' ), as: ibit }
+            .out('has_underlying'){ as: u } 
+      RETURN ibit,u "
+```
+
+The instance-method is extremly handy in web-applications. If the `rid` is part of the `params`-hash,
+associated nodes are easily selected
+
+```ruby
+params[:rid] =>  "#49:0"
+
+m= params[:rid].load_rid.match.out( HasUnterlying ).node( as: :u )
+m.to_s
+ => "MATCH { type: strategie, rid: #49:0 }.out('has_underlying'){ as: u } RETURN u "
+```
+## Low Level Database Requests
 The **second Layer** handles Database-Requests.  
 In its actual implementation, these requests are delegated to the HTTP/JSON-API.
 
@@ -158,35 +210,36 @@ In its actual implementation, these requests are delegated to the HTTP/JSON-API.
 The database-handle is always present through `Arcade::Init.db`
 
 ```ruby
-DB =  Arcade::Init.db
+db =  Arcade::Init.db
 
-$ DB.get nn, mm                                 # returns a Aracde:Base object
+$ db.get nn, mm  # nn=2; mm=0                   # returns a Aracde:Base object
                                                 # rid is either "#11:10:" or two numbers
-$ DB.query querystring                          # returns either an Array of results (as  Hash) 
-$ DB.execute { querystring }                    # execute a non idempotent query within a (nested) transaction
-$ DB.create <name>, attribute: value ....       # Creates a new <Document | Vertex> and returns the rid
+$ db.query querystring                          # returns either an Array of results (as  Hash) 
+$ db.execute { querystring }                    # execute a non idempotent query within a (nested) transaction
+$ db.create <name>, attribute: value ....       # Creates a new <Document | Vertex> and returns the rid
                                                 # Operation is performed as Database-Transaction and is rolled back on error
-$ DB.insert <name>, attribute: value ....       # Inserts a new <Document | Vertex> and returns the new object
-$ DB.create_edge <name>, from: <rid> or [rid, rid, ..] , to: <rid> or [rid, rid, ..]
+$ db.insert <name>, attribute: value ....       # Inserts a new <Document | Vertex> and returns the new object
+$ db.create_edge <name>, from: <rid> or [rid, rid, ..] , to: <rid> or [rid, rid, ..]
 
 ```
 
 **Convert database input to Arcade::Base Models**
 
-Either  `DB.query` or  `DB.execute` return the raw JSON-input from the database. It can always converted to model-objects by chaining
+Either  `db.query` or  `db.execute` return the raw JSON-input from the database. It can always converted to model-objects by chaining
 `allocate_model` or `select_result`.
 
 ```ruby
-$ DB.query "select from my_names limit 1"
+$ db.query "select from my_names limit 1"
 # which is identical to
-$ My::Names.query( limit: 1).query
+$ My::Names.query( limit: 1).execute
  => [{:@out=>0, :@rid=>"#225:6", :@in=>0, :@type=>"my_names", :@cat=>"v", :name=>"Zaber"}] 
 # then
-$ My::Names.query( limit: 1).query.allocate_model.to_human
+$ My::Names.query( limit: 1).execute.allocate_model.to_human
  => ["<my_names[#225:6]: name: Zaber>" ]
  # replaces the hash with a My::Names Object 
 ```
 
+
 The **Base Layer** implements a low level access to the database API. 
 
 ```ruby
@@ -306,7 +359,29 @@ db.commit
 db.rollback
 
 ```
+### Audit proofed Bookings
+
+Although ArcadeDB is a mutable database, the ruby-Interface supports basic audit proofed transactions.
+Two specialized Database-Types are included:
+
+* Arcade::RevisionRecord –  A document class, intended to be embedded in Revision-Records
+* Arcade::Revision       –  A vertex-class with specialized `insert-` and `update-` methods
 
+If a vertex is based on `Arcade::Revision`, a `protocol`-property is included. Its initialised with a single `Arcade::RevisionRecord` Object. Each `update` adds an `Arcade::RevisionRecord` to the protocol stack.
+
+```ruby
+  m= Member.insert( name: "Hubert", 
+                 surname: "Hugo", 
+                   birth: Date.new( 1976,3,15  ) ) { 'record initiated' }
+
+  m.update( birth: Date.new( 1978,3,15  )  ) { "member provided correct date via mail"  }
+    
+  m.protocol  =>  Date    | User |  Action                                | old
+             --------------------------------------------------------------------------------
+             =>  1.1.2024 | root |  record initiated                      |
+             =>  1.2.2024 | root |  member provided correct date via mail | birth: "1976-3-15"
+
+```
 
 ## Contributing
 

data/arcade.yml

@@ -3,20 +3,20 @@
   :test:
     dbname: playground
     user:  root
-    pass: *** 
+    pass:  topo1focus
   :development:
     dbname: devel
     user: root
-    pass:  ***
+    pass:  topo1focus
   :production:
     dbname: production
     user: root
-    pass: ***
+    pass: topo1focus
 :admin:
-  :host: 10.247.8.109
+  :host: localhost
   :port: 2480
   :user: root
-  :pass: ***
+  :pass: topo1focus
 :logger: stdout           # 'file' or 'stdout'
 :namespace: Arcade        # Default Namespace
 :autoload: true           # load model if a link is detected in a record

data/bin/console

@@ -9,6 +9,7 @@
 require 'bundler/setup'
 #require 'terminal-table'
 require 'zeitwerk'
+ProjectRoot =  Pathname.new( Dir.pwd ).parent
 require 'pastel'
 require 'arcade'
 #require 'pry'

data/lib/arcade/api/operations.rb

@@ -32,6 +32,13 @@ module Arcade
       get_data 'databases'
     end
 
+    # ------------------------------ database?        ------------------------------------------------- #
+    #  returns true if the database exists                                                              #
+
+    def self.database? name
+      get_data "exists/#{name}"
+    end
+
     # ------------------------------ create database  ------------------------------------------------- #
     #  creates a database if not present                                                                #
     def self.create_database name
@@ -54,23 +61,6 @@ module Arcade
       logger.fatal "Drop database #{name} through \"POST drop database/#{name}\" failed"
       raise
     end
-    # ------------------------------  create document ------------------------------------------------- #
-    # adds a document to the specified database table
-    #
-    # specify database-fields as hash-type parameters
-    #
-    # i.e   Arcade::Api.create_document 'devel', 'documents',  name: 'herta meyer', age: 56, sex: 'f'
-    #
-    # returns the rid of the inserted dataset
-    #
-    def self.create_document database, type, session_id: nil, **attributes
-      payload = { "@type" => type }.merge( attributes )
-      if session_id.nil?
-        post_data "document/#{database}", payload
-      else
-        post_transaction "document/#{database}", payload, session_id: session_id
-      end
-    end
 
     # ------------------------------  execute         ------------------------------------------------- #
     # executes a sql-query in the specified database
@@ -94,13 +84,28 @@ module Arcade
     # ------------------------------  query           ------------------------------------------------- #
     # same for idempotent queries
     def self.query database, query, session_id: nil
-      if session_id.nil?
-        post_data   "query/#{database}" , provide_payload(query)
-      else
-        post_transaction "query/#{database}" , provide_payload(query), session_id: session_id
-      end
+#      if session_id.nil?
+        get_data   "query/#{database}/sql/" + provide_payload(query, action: :get)[:query]
+ #     else
+ #       post_transaction "query/#{database}" , provide_payload(query), session_id: session_id
+ #     end
     end
 
+    # ------------------------------  create Document   ------------------------------------------------- #
+    # adds a record ( document, vertex or edge ) to the specified database type
+    #
+    # specify database-fields as hash-type parameters
+    #
+    # i.e   Arcade::Api.create_record 'devel', 'documents',  name: 'herta meyer', age: 56, sex: 'f'
+    #
+    # returns the rid of the inserted dataset
+    #
+    def self.create_document database, type, session_id: nil, **attributes
+        content = "CONTENT #{ attributes.to_json }"
+        result = execute( database, session_id: session_id ){ "INSERT INTO #{type} #{content} "}
+        result.first[:@rid]   #  emulate the »old« behavior of the /post/create_document api endpoint
+    end
+    
     # ------------------------------  get_record      ------------------------------------------------- #
     # fetches a record by providing  database and  rid
     # and returns the result as hash
@@ -114,7 +119,7 @@ module Arcade
       rid =  rid.join(':')
       rid = rid[1..-1] if rid[0]=="#"
       if rid.rid?
-      get_data  "document/#{database}/#{rid}"
+        get_data( "query/#{database}/sql/" + URI.encode_uri_component("select from #{rid}")) &.first
       else
         raise Error "Get requires a rid input"
       end
@@ -181,7 +186,11 @@ module Arcade
                                 the_yield.map do | key,  value |
                                   case key
                                   when :query
-                                   action == :post ? [ :command, value ] : [ :query, value ]
+                                    if action == :post
+                                      [ :command, value ]
+                                    else
+                                      [ :query, URI.encode_uri_component(value )]
+                                    end
                                   when :limit
                                     [ :limit , value ]
                                   when :params

data/lib/arcade/api/primitives.rb

@@ -9,6 +9,12 @@ module Arcade
 
     def http
 #     break_on = -> (response) { response.status == 500  }
+      #     Version 23.12: Persistent connection are inactive after 3 sec.
+      #     Implemented a walk around, that renews the connection after 2 sec. of inactivity
+      t = Time.now
+      @t ||= Time.now
+      @http = nil if t-@t > 2
+      @t = t
       @http ||= HTTPX.plugin(:basic_auth).basic_auth(auth[:username], auth[:password])
                   .plugin(:persistent)
                   .plugin(:circuit_breaker)
@@ -49,7 +55,7 @@ module Arcade
 
     # ------------------------------ post data -------------------------------------------------------- #
     def post_data command,  payload
-      case response = http.post( Config.base_uri + command, json:  payload )
+        case response = http.post( Config.base_uri + command, json:  payload )
         in {status: 200..299}
           # success
         JSON.parse( response.body, symbolize_names: true )[:result]
@@ -64,7 +70,7 @@ module Arcade
              sleep 1
              post_data command,  payload
            else
-           raise Arcade::QueryError.new **response.json( symbolize_names: true  )
+             raise Arcade::QueryError.new **response.json( symbolize_names: true  )
            end
       else
         #   # http error
@@ -87,6 +93,7 @@ module Arcade
     # ------------------------------ post transaction ------------------------------------------------- #
     def post_transaction command, params, session_id:
       http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
+      puts "params #{params.inspect}"
       case response = http_a.post( Config.base_uri + command, json:  params )
         in {status: 200..299}
           # success

data/lib/arcade/base.rb

@@ -1,4 +1,5 @@
 module Arcade
+
   class Base  < Dry::Struct
 
     extend Arcade::Support::Sql
@@ -20,6 +21,9 @@ module Arcade
     ## ----------------------------------------- Class Methods------------------------------------ ##
     #                                                                                               #
     class << self
+     def descendants
+         ObjectSpace.each_object(Class).select { |klass| klass < self }
+     end
 
       # this has to be implemented on class level
       # otherwise it interfere  with attributes
@@ -294,16 +298,19 @@ module Arcade
         Query.new( **{ from: self }.merge(args) )
       end
 
-      # immutable support
-      # to make a database type immutable add
+      # ## Immutable Support
+      #
+      # To make a database type immutable add  
       #  `not_permitted :update, :upsert, :delete`
       # to the model-specification
       #
+      # Even after applying `not_permitted` the database-type can be modified via class-methods.
+      #
       def not_permitted *m
         m.each do | def_m |
-          define_method(  def_m ) do | v = nil |
-          raise ArcadeImmutableError "operation not permitted", caller
-        end
+          define_method( def_m ) do | v = nil |
+            raise  Arcade::ImmutableError.new( "operation  #{def_m} not permitted" )
+          end
         end
       end
 
@@ -366,8 +373,6 @@ module Arcade
     end
 
     def to_human
-
-
 		"<#{ self.class.to_s.snake_case }" + rid? ? "[#{ rid }]: " : " " + invariant_attributes.map do |attr, value|
 			v= case value
 				 when Base
@@ -428,7 +433,7 @@ module Arcade
 
     def update **args
       Query.new( from: rid , kind: :update, set: args).execute
-      refresh
+      refresh   # return the updated record (the object itself is untouched!)
     end
 
     # inserts or updates a embedded document
@@ -448,21 +453,37 @@ module Arcade
       db.transmit { " update #{rid} set `#{embedded}`.`#{embedded_property}` =  #{value.to_or}" }
     end
 
-    def update_list list, value
-      value = if value.is_a? Document
+    # Adds List-Elements to embedded List
+    #
+    # Arguments:
+    # * list: A symbol of the list property
+    # * value: A embedded document or a hash
+    # * modus: :auto, :first, :append
+    #
+    # Prefered modus operandi
+    # * the-element.insert  (...) , #{list}:[]
+    # * the_element.update_list list, value: :append
+    #
+    def update_list list, value, modus: :auto
+      value = if value.is_a? Document   # embedded mode
                 value.to_json
               else
                 value.to_or
               end
-      if send( list ).nil? || send( list ).empty?
-        db.transmit { "update #{ rid } set  #{ list } =  [#{ value }]" }
+      if modus == :auto
+        modus =  db.query( "select #{list}.size() from #{rid}" ).select_result.first.zero? ? :first : :append
+      end
+
+     if modus == :first
+        db.transmit { "update #{ rid } set  #{ list } = [#{ value }]" }
       else
         db.transmit { "update #{ rid } set  #{ list } += #{ value }" }
       end
-      refresh
+     # refresh
     end
 
     # updates a map  property ,  actually adds the key-value pair to the property
+    ## does not work on reduced model records
     def update_map m, key, value
       if send( m ).nil?
         db.transmit { "update #{ rid } set #{ m } = MAP ( #{ key.to_s.to_or } , #{ value.to_or } ) "  }

data/lib/arcade/database.rb

@@ -157,7 +157,7 @@ module Arcade
 
 
 
-    # ------------ create  -----------
+    # ------------ create  -----------  ## not supported anymore  by the api
     # returns an rid of the successfully  created vertex or document
     #
     #  Parameter:  name of the vertex or document type
@@ -192,13 +192,14 @@ module Arcade
       elsif content_params.empty?
         logger.error "Nothing to Insert"
       else
-        content =  "CONTENT #{ content_params.to_json }"
+        content = "CONTENT #{ content_params.to_json }"
         target =  target_params.map{|y,z|  y==:type ?  z : "#{y.to_s} #{ z } "}.join
-        result = Api.execute( database, session_id: session ){ "INSERT INTO #{target} #{content} "}
+        result =  Api.execute( database, session_id: session ){ "INSERT INTO #{target} #{content} "}
         result &.first.allocate_model(false)
       end
     end
 
+
     # ------------------------------  get        ------------------------------------------------------ #
     # Get fetches the record associated with the rid given as parameter.
     #
@@ -224,7 +225,7 @@ module Arcade
       end
     end
 
-    # ------------------------------  get        ------------------------------------------------------ #
+    # ------------------------------  delete     ------------------------------------------------------ #
     #
     #  Delete the specified rid
     #
@@ -272,7 +273,7 @@ module Arcade
      end
     rescue  Dry::Struct::Error, Arcade::QueryError => e
       Api.rollback database, session_id: s, log: false
-      logger.info "Execution  FAILED -->  Status #{e.status}"
+      logger.fatal "Execution  FAILED -->  Status #{e}"
       []  #  return empty result
     end
 

data/lib/arcade/init.rb

@@ -14,7 +14,8 @@ module Arcade
   #
   class Init
     extend Dry::Core::ClassAttributes
-    defines :db    # database handle
+    defines :db        # database handle
+    defines :models    # static array of database name for arcade-model classes
 
     def self.connect e= :development
 
@@ -25,10 +26,12 @@ module Arcade
              else
                :development
              end
-      #      set the class attribute
 
+      # set the class attributes
+      models Base.descendants.map{|x| x.to_s.split("Arcade::").last }
       db Database.new(env)
     end
+
   end
 
   # Provides method  `db` to every Model class

data/lib/arcade/match.rb

@@ -4,22 +4,64 @@ module Arcade
     include Arcade::Support::Sql
 
 =begin
-  This is a very simple wrapper for the match statement
+  This is a wrapper for the match statement
 
   Initialize:  a= Arcade::Match.new type: Arcade::DatabaseType, where: { property: 'value' }, as: :alias
   Complete:    b = a.out( Arcade::EdgeType ).node( while: true, as: item )[ .in.node ... ]
   Inspect      b.to_s
   Query DB     b.execute [.allocate_model]
                          [.analyse_result]
+  Customize the return values:
+               b.to_s{ "customized return statement" }
+               b.execute{ "customized return statment" }
+               
+  Conditions on edges:
+        m =  Match.new type: Arcade::DatabaseType
+        m.inE via: Arcade::Edge  || via: [Arcade::Edge1, Arcade::Edge2], where: { var: 3..6 }  
+         --->  inE('edge(1)'){ where: (var between 3 and 6 )}.outV('edge(2)')
+
+  Address a single database record:
+        m = Match.new( vertex: { Arcade::Vertex-Instance } )
+            .....
+            .node( vertex: { Arcade::Vertex-Instance } )     # instead of where statement           
+
+  Example
+
+   symbol_or_title =  symbol.present? ? { :symbol => symbol } : { :title => title }
+   where = { :right => right }
+
+   a= Arcade::Match.new( type: self.class, where: symbol_or_title )
+                   .out( Arcade::HasContract )
+                   .node( as: :c, where: where )
+   a.execute do "c.last_trading_day as expiry,         # c is returned form the query [as: :c]                                               
+                 count(c) as contracts,
+                 min(c.strike) as s_min,
+                 max(c.strike) as s_max
+                 group by c.last_trading_day order by c.last_trading_day"
+             end
 
-=end
 
-    def initialize type: , **args
+=end
 
+    def initialize  **args
+      type = args.delete :type
+      vertex =  args.delete :vertex
+      rid =  args.delete :rid
+      raise "MATCH#new:: parameter rid is not supported. Use `vertex: Arcade::Vertex.instance` instead." if rid.present?
       @args = args
       @as = []
 
-      @stack = [ "MATCH { type: #{type.database_name}, #{ assigned_parameters } }" ]
+      @stack = if vertex.is_a?( Arcade::Vertex ) && args.empty?
+         [ "MATCH { type: #{vertex.class.database_name }, rid: #{vertex.rid} }" ]
+               elsif  vertex.is_a?( Arcade::Vertex ) 
+         [ "MATCH { type: #{vertex.class.database_name }, rid: #{vertex.rid}, #{ assigned_parameters } }" ]
+               elsif  type.is_a?( Class) && type.ancestors.include?(Arcade::Vertex) && args.empty?
+         [ "MATCH { type: #{type.database_name} }" ]
+               elsif  type.is_a?( Class) && type.ancestors.include?(Arcade::Vertex)
+         [ "MATCH { type: #{type.database_name}, #{ assigned_parameters } }" ]
+               else
+         raise "Match:: Either type  (Arcade::Vertex-Class) or vertex (Arcade::Vertex-Object) is required as parameter"
+               end
 
       return self
     end
@@ -49,49 +91,55 @@ module Arcade
     end
 
 
-    # todo : metaprogramming!
-    def out edge=""
-      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
-      @stack << ".out(#{edge.is_a?(Class) ? edge.database_name.to_or : ''})"
-      return self
-    end
-    def in edge=""
-      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
-      @stack << ".in(#{edge.is_a?(Class) ? edge.database_name.to_or : ''})"
-      return self
-    end
-    def both edge=""
-      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
-      @stack << ".both(#{edge.is_a?(Class) ? edge.database_name.to_or : ''})"
-      return self
+
+    def self.define_base_edge *direction
+      direction.each do | e_d |
+        define_method e_d do | edge = "" |
+          raise "edge must be a Database-class" unless edge.is_a?(Class) || edge.empty?
+          @stack << ".#{ e_d  }(#{edge.is_a?(Class) ? edge.database_name.to_or : ''})"
+          self
+        end
+      end
     end
 
+
     # add conditions on  edges to the match statement
-    def inE edge="", **args
-      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
-      @stack << ".inE(#{edge.is_a?(Class) ? edge.database_name.to_or : ''}) #{assigned_parameters}.outV()"
-      return self
-    end
-    def outE edge="", **args
-      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
-      @stack << ".outE(#{edge.is_a?(Class) ? edge.database_name.to_or : ''}) #{assigned_parameters}.inV()"
-      return self
-    end
-    def bothE edge="", **args
-      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
-      @stack << ".bothE(#{edge.is_a?(Class) ? edge.database_name : ''}) #{assigned_parameters}.bothV()"
-      return self
+    def self.define_inner_edge start_dir, final_dir
+      define_method start_dir do | edge = "", **a |
+        raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
+
+        print_edges = -> (e){ e.is_a?(Class) ? e.database_name.to_or : ''}
+        edges = [ a.delete(:via) ].flatten
+        edges << edge unless edge == ''
+        n = if a.empty?
+              ""
+            else
+              @args = a
+              "{ #{ assigned_parameters } }"
+            end
+        @stack << ".#{ start_dir }(#{print_edges.call(edges.first)})#{ n }.#{ final_dir }(#{print_edges.call(edges.last)})"
+        return self
+      end
+
     end
 
+    define_base_edge :out, :in, :both
+    define_inner_edge :inE, :outV
+    define_inner_edge :outE, :inV
+
+
 
     # general declation of a node (ie. vertex)
     def node **args
+      vertex =  args.delete :vertex
+      rid =  args.delete :rid
+      raise "MATCH#node:: parameter rid is not supported. Use `vertex: Arcade::Vertex.instance` instead." if rid.present?
       @args = args
       @stack << if args.empty?
-       "{}"
-              else
-       "{ #{ assigned_parameters } }"
-              end
+       vertex.present? ? "{ type: #{vertex.class.database_name }, rid: #{vertex.rid} }" : "{}"
+                else
+       vertex.present? ? "{ type: #{vertex.class.database_name }, rid: #{vertex.rid}, #{assigned_parameters} }" :  "{ #{ assigned_parameters } }"
+                end
       return self
     end
 

data/lib/arcade/query.rb

@@ -27,7 +27,8 @@ module Arcade
 								[],   # aliases
 								'',  # database
 								[],   #set,
-								[]  # remove
+								[],  # remove
+							  []   # group by
 			  args.each{|k,v| send k, v}
 				@fill = block_given? ?   yield  : 'and'
 		end
@@ -62,12 +63,10 @@ module Arcade
 			@q[:kind]
 			end
 		end
-=begin
-  Output the compiled query
-  Parameter: destination (rest, batch )
-  If the query is submitted via the REST-Interface (as get-command), the limit parameter is extracted.
-=end
-
+    # ------------------ compose---------------------------------------
+    #  Output the compiled query
+    #  Parameter: destination (rest, batch )
+    #  If the query is submitted via the REST-Interface (as get-command), the limit parameter is extracted.
 		def compose(destination: :batch)
 			if kind.to_sym == :update
 				return_statement = "return after " + ( @q[:aliases].empty? ?  "$current" : @q[:aliases].first.to_s)
@@ -126,9 +125,8 @@ module Arcade
 			end
 		end
 
-=begin
-	from can either be a Databaseclass to operate on or a Subquery providing data to query further
-=end
+	# -------------------- from ---------------------------------------
+	#  arg  can either be a Database class to operate on or a Subquery providing data to query further
 		def from arg = nil
 			if arg.present?
 				@q[:database] =  arg
@@ -315,11 +313,8 @@ end # class << self
 			self
     end
 
-#		# connects by adding {in_or_out}('edgeClass')
-#		def connect_with in_or_out, via: nil
-#			 argument = " #{in_or_out}(#{via.to_or if via.present?})"
-#		end
 
+    # ------------------ nodes ---------------------------------------
 		# adds a connection
 		#  in_or_out:  :out  --->  out('edgeClass')[where-condition]
 		#              :in   --->  in('edgeClass')[where-condition]
@@ -335,7 +330,7 @@ end # class << self
 
 		def nodes in_or_out = :out, via: nil, where: nil, expand:  false
 
-			 condition = where.present? ?  "[ #{generate_sql_list(where)} ]" : ""
+			 condition = where.present? ? "[ #{generate_sql_list(where)} ]" : ""
        via = resolve_edge_name(via) unless via.nil?
 
        argument = if in_or_out.to_s[-1] == 'E'

data/lib/arcade/support/model.rb

@@ -15,35 +15,31 @@ module Arcade
         end.join(',')
       end
 
-
     #  used by array#allocate_model
       def _allocate_model response=nil, auto = Config.autoload
 
-
       if response.is_a? Hash
         # save rid to a safe place
-        temp_rid = response.delete :"@rid"
-        type     = response.delete :"@type"
-        cat      = response.delete :"@cat"
+        temp_rid = response.delete( :"@rid"  ) || response.delete( :rid ) || "#0:0"
+        type     = response.delete( :"@type" ) || response.delete( :type )  || nil
+        cat      = response.delete( :"@cat"  ) || response.delete( :cat )  || "d"
 
         return response if type.nil?
-        temp_rid = "#0:0" if temp_rid.nil?
-        type = "d" if type.nil?
         # extract type infos  and convert to database-name
         namespace, type_name = type.camelcase_and_namespace
         namespace = self.namespace if namespace.nil?
         # autoconvert rid's in attributes to model-records  (exclude edges!)
         if auto && !(cat.to_s =='e')
-          response.transform_values! do  |x|
+          response.transform_values do  |x|
             case x
             when String
               x.rid? ?  x.load_rid : x                   # follow links
             when Array
               a =[]
-              x.map do| y |
-                # Thread.new do  ## thread or fiber decrease the performance significantly.
+              x.map do | y |
+                # Thread.new do  ## using thread or fiber decreases the performance significantly.
                   if y.is_a?(Hash) && y.include?(:@type)   # if embedded documents are present, load them
-                    y.allocate_model(false)
+                    _allocate_model(y,false)
                   elsif y.rid?                             # if links are present, load the object
                     y.load_rid(false) # do not autoload further records, prevents from recursive locking
                   else
@@ -82,7 +78,7 @@ module Arcade
      elsif response.rid?
        # Autoload rid's
        response.load_rid
-      # auto ? response.load_rid : response
+     #  auto ? response.load_rid : response
      else
        response
       end

data/lib/arcade/support/sql.rb

@@ -44,7 +44,7 @@ If »NULL« should be addressed, { key: nil } is translated to "key = NULL"  (us
           attributes.map do |key, value|
             case value
             when nil
-              "#{key}=NULL"
+              "#{key} is NULL"
             when ::Array
               if value == [nil]
                 "#{key} is NULL"

data/lib/arcade/support/string.rb

@@ -11,9 +11,12 @@ module Arcade
           delimiters = Regexp.union(['-', '_'])
           n,c= self.split(delimiters).then { |first, *rest| [first.tap {|s| s[0] = s[0].upcase}, rest.map(&:capitalize).join]  }
           ## if base is the first part of the type-name, probably Arcade::Base is choosen a namespace. thats wrong
-          namespace_present = unless n == 'Base'
+          # Arcade::Base descendants are prefetched in Init.models
+          # They have to be fetched to  load both  `Arcade::Ge` and `Arcade::GeSomething`
+          #                (otherwise: Arcade::Ge and Arcade::Ge::Something)
+          namespace_present = unless n == 'Base'  ||  Arcade::Init.models.include?(n)
                                 Object.const_get(n)  rescue  false # Database.namespace
-                              else 
+                              else
                                 false
           end
           # if no namespace is found, leave it empty and return the capitalized string as class name
@@ -22,6 +25,10 @@ module Arcade
           [ Database.namespace, self.capitalize ]
         end
       end
+      def camelcase
+      # Split the string into words, capitalize each word, and join them together
+        self.split('_').map(&:capitalize).join
+      end
 
       def snake_case
         n= if split('::').first == Database.namespace.to_s
@@ -51,7 +58,7 @@ module Arcade
       end
 #  return a valid rid (format: "nn:mm") or nil
       def rid
-        self["#"].nil? ? "#"+ self : self if rid? 
+        self["#"].nil? ? "#"+ self : self if rid?
       end
 
       def where **args
@@ -80,7 +87,7 @@ module Arcade
       ## Load the database object if the string is a rid
       # (Default: No Autoloading of rid-links)
       def load_rid autocomplete = false
-        db.get( self ){  autocomplete }  if rid?  rescue nil
+        db.get( self.strip ){  autocomplete }  if rid?  rescue nil
       end
 
       # updates the record    ### retired in favour of Arcade::Base.update
@@ -104,13 +111,3 @@ module Arcade
 end
 
 String.include Arcade::Support::String
-
-module Types
-  include Dry.Types()
-
-  # include in attribute definitions
-  Rid = String.constrained( format:  /\A[#]{1}[0-9]{1,}:[0-9]{1,}\z/ )
-  Blockchain =  String.constrained( format: /^(algo|eth|btc)$/ )  #  add other blockchain symbols here
-  Email = String.constrained( format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i )
-
-end

data/lib/arcade/version.rb

@@ -1,3 +1,3 @@
 module Arcade
-  VERSION = "0.5.0"
+  VERSION = "0.5.2"
 end

data/lib/arcade.rb

@@ -9,13 +9,13 @@ require "dry/core/class_builder"
 require "dry/core/class_attributes"
 require 'json'
 
-module Types
-  include Dry.Types()
-end
+require_relative '../lib/types'
+#module Types
+#  include Dry.Types()
+#end
 require 'yaml'
 require 'securerandom'
 require 'httpx'
-require 'arcade/errors'
 require_relative '../lib/arcade/support/object'
 require_relative '../lib/arcade/support/string'
 require_relative '../lib/arcade/support/class'
@@ -24,6 +24,7 @@ require_relative '../lib/arcade/support/model'
 require_relative '../lib/arcade/support/conversions'
 require_relative '../lib/arcade/api/primitives'
 require_relative '../lib/arcade/api/operations'
+require_relative '../lib/arcade/errors'
 require_relative '../lib/arcade/base'
 require_relative '../lib/arcade/logging'
 require_relative '../lib/arcade/config'

data/lib/model/document.rb

@@ -11,7 +11,7 @@ module Arcade
    end
 
 =begin
-    Document.delete fires a "delete vertex" command to the database.
+    Document.delete fires a "delete" command to the database.
     To remove all records  use  »all: true« as argument
 
     The "where" parameter is optional

data/lib/model/edge.rb

@@ -27,6 +27,23 @@ module Arcade
 
     end
 
+
+    ## class-method: Delete Edge between two vertices
+    ##
+    ## returns the count of deleted edges
+    ##
+    ## todo: add conditions
+    def self.delete from:, to:
+      return 0 if from.nil? || to.nil?
+      raise "parameter ( from: ) must be a String or a Vertex" unless from.is_a?(String) || from.is_a?( Arcade::Vertex)
+      raise "parameter ( to: ) must be a String or a Vertex" unless to.is_a?(String) || to.is_a?( Arcade::Vertex)
+      raise "parameters (from: + to:) must respond to `.rid`" unless from.respond_to?( :rid) && to.respond_to?(:rid)
+
+      db.execute{ "delete edge from #{from.rid} to #{to.rid} " } &.select_result &.first
+    end
+
+
+    ## instance method: Delete specified edge
     def delete
       db.execute{  "delete edge #{ rid }" }.select_result
     end

data/lib/model/revision.rb

@@ -0,0 +1,41 @@
+module Arcade
+  class  Revision < Arcade::Vertex
+    attribute :protocol?, Types::Nominal::Array
+
+    @@u='root'  # default user
+    @@i = 'Record initiated'
+
+  def self.set_user u
+    @@u = u
+  end
+
+  def self.set_initial_message m
+    @@i = m
+  end
+
+  def self.insert **attr
+
+    action = block_given? ?  yield : @@i
+    i= super **attr
+    i.update_list :protocol,
+                   Arcade::RevisionRecord.create( user: @@u, action: action ),
+                   modus: :first
+    i.refresh
+
+  end
+
+
+  def update **attr
+    hist_state =  attr.keys.map do |k|
+                  [ k,  send( k ) ]
+    end.to_h
+    super **attr
+    revision = if block_given?
+         Arcade::RevisionRecord.create( user: @@u, action: yield,  fields: hist_state )
+               else
+                 Arcade::RevisionRecord.create( fields: hist_state )
+               end
+    update_list :protocol, revision, modus: :append
+  end
+  end
+end

data/lib/model/revision_record.rb

@@ -0,0 +1,29 @@
+module Arcade
+  class RevisionRecord  < Document
+    attribute  :user, Types::Nominal::String.default( 'root'.freeze )
+    attribute  :action, Types::Nominal::String.default( "Property changed".freeze )
+    attribute  :date, Types::Nominal::Date.default( Date.today.freeze )
+    attribute  :fields?, Types::Nominal::Hash
+
+   #  Revision Records are always embedded.
+   #  create and insert methods return an new ruby record
+   def self.create **attr
+     new **( { rid: '#0:0', date: Date.today}.merge attr )
+   end
+   def self.insert **attr
+     new **( { rid: '#0:0', date: Date.today}.merge **attr )
+   end
+
+=begin
+  Its not allowed to delete records.
+=end
+    def self.delete where: {} , **args
+      raise ArcadeQueryError, "Its not possible to delete revision records"
+    end
+
+    def delete
+      raise ArcadeQueryError, "Its not possible to delete revision records"
+    end
+
+  end
+end

data/lib/model/vertex.rb

@@ -213,6 +213,50 @@ or
     nil
   end
 
+=begin
+----------------------------------- Match ------------------------------------------
+(ClassMethod)
+
+Creates a Match-Statement based on the vertex type
+
+```
+m = Watchlist.match( symbol: 'iBit', as: :ibit ) 
+           .out( HasUnderlying)
+           .node( as: :u )
+           
+m.to_s
+  => "MATCH { type: watchlist, where: ( symbol='iBit' ), as: ibit }
+            .out('has_underlying'){ as: u } 
+      RETURN ibit,u "
+```
+=end
+  def self.match **args
+       as = args.delete( :as) || :a
+       args = args.delete( :where ) if args.key?( :where )
+       Arcade::Match.new type: self,  where: args, as: as
+  end
+
+=begin
+----------------------------------- Match ------------------------------------------
+(InstanceMethod)
+
+Creates a Match-Statement based on the current vertex ( i.e  as response to a website-request )
+
+```
+params[:rid] =>  "#49:0"
+
+m= params[:rid].load_rid.match.out( HasUnterlying ).node( as: :u )
+m.to_s
+ => "MATCH { type: strategie, rid: #49:0 }.out('has_underlying'){ as: u } RETURN u "
+```
+=end
+  def match as: nil
+    if as.nil?
+      Arcade::Match.new vertex: self
+    else
+      Arcade::Match.new vertex: self, as: as
+    end
+  end
 
   def remove
     db.execute{ "delete vertex #{rid}" }
@@ -224,7 +268,7 @@ Format: < Classname: Edges, Attributes >
 =end
 	def to_human
 
-    in_and_out =  "{#{inE.count}->}{->#{outE.count }}, "
+    in_and_out =  coe.then{| i,o| "{#{i}->}{->#{o}}, "}
 
 		#Default presentation of Arcade::Base::Model-Objects
 
@@ -244,6 +288,13 @@ Format: < Classname: Edges, Attributes >
 	end
 
 
+ # Count Of Edges (coe)
+ # returns an Array: [ count-of-in-edges, count-of-out-edges ]
+   def coe 
+      db.query( "select in().size() as ie, out().size() as oe from #{rid}" ) &.first.values
+   end
+	            
+
     def refresh
       # force reloading of edges and nodes
       # edges are not cached (now)

data/lib/models.rb

@@ -1,6 +1,8 @@
 require_relative "../lib/model/document.rb"
+require_relative "../lib/model/revision_record.rb"
 require_relative "../lib/model/vertex.rb"
 require_relative "../lib/model/edge.rb"
+require_relative "../lib/model/revision.rb"
 require_relative "../lib/model/basicvertex.rb"
 require_relative "../lib/model/basicdocument.rb"
 require_relative "../lib/model/basicedge.rb"

data/lib/types.rb

@@ -0,0 +1,35 @@
+module Types
+  include Dry.Types()
+
+  # include in attribute definitions
+  Rid = String.constrained( format:  /\A[#]{1}[0-9]{1,}:[0-9]{1,}\z/ )
+  Blockchain =  String.constrained( format: /^(algo|eth|btc)$/ )  #  add other blockchain symbols here
+  Email = String.constrained( format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i )
+
+
+  # Define a type for your DateTime with timezone.  Crucially, use
+# the `.constructor` to handle the string parsing and potential errors. (source: Gemini)
+Types::DateTime = Types::Any.constructor do |value|
+  begin
+    case value
+      when String
+    ::DateTime.parse(value)
+      when Integer
+      ::Time.at(value).to_datetime
+      else
+      ::DateTime.now
+    end
+  rescue ArgumentError
+    # Handle invalid date strings.  Options:
+    # 1. Raise an exception (recommended for API responses)
+    raise Dry::Types::CoercionError.new(
+      value, DateTime, "Invalid DateTime format: #{value}"
+    )
+    # 2. Return nil (less strict, but might lead to unexpected behavior)
+    # nil
+    # 3. Use a default value (be careful with this, as it might mask errors)
+    # DateTime.now
+  end
+end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arcadedb
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Hartmut Bischoff
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-12 00:00:00.000000000 Z
+date: 2025-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -170,8 +170,11 @@ files:
 - lib/model/basicvertex.rb
 - lib/model/document.rb
 - lib/model/edge.rb
+- lib/model/revision.rb
+- lib/model/revision_record.rb
 - lib/model/vertex.rb
 - lib/models.rb
+- lib/types.rb
 - rails.md
 - rails/arcade.rb
 - rails/config.yml
@@ -180,7 +183,7 @@ homepage: https://github.com/topofocus/arcadedb
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -195,8 +198,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key: 
+rubygems_version: 3.5.23
+signing_key:
 specification_version: 4
 summary: Ruby Interface to ArcadeDB
 test_files: []