Updated to accept java.time.Instant in as-of and since calls

Author: Paula Gearon

src/asami/durable/graph.cljc

@@ -2,7 +2,6 @@
       :author "Paula Gearon"}
     asami.durable.graph
     (:require [asami.graph :as graph]
-              [asami.internal :refer [now instant? long-time]]
               [asami.common-index :as common-index :refer [?]]
               [asami.durable.common :as common :refer [TxData Transaction Closeable
                                                        find-tuples tuples-at write-new-tx-tuple!

src/asami/internal.cljc

@@ -3,32 +3,44 @@
     asami.internal
   (:require [asami.graph :as graph]
             [asami.cache :refer [lookup hit miss lru-cache-factory]])
-  #?(:clj (:import [java.util Date])))
+  #?(:clj (:import [java.util Date]
+                   [java.time Instant])))
 
 #?(:clj (set! *warn-on-reflection* true))
 
+(defprotocol TimeType
+  (instant? [this] "Indicates if this object is a time type that supports an instant")
+  (long-time [this] "Returns a long value as the number of milliseconds since the epoch")
+  (to-timestamp [this] "Converts to a common time type. Useful for comparison"))
+
+(extend-protocol TimeType
+  #?(:clj Date :cljs js/Date)
+  (instant? [_] true)
+  (long-time [this] (.getTime this))
+  (to-timestamp [this] this)
+
+  #?@(:clj
+      [Instant
+       (instant? [_] true)
+       (long-time [this] (.toEpochMilli this))
+       (to-timestamp [this] (Date. (.toEpochMilli this)))])
+
+  #?(:clj Object :cljs default)
+  (instant? [_] false)
+  (long-time [this] (throw (ex-info (str "Unable to convert " (type this) " to a time") {:object this})))
+  (to-timestamp [this] (throw (ex-info (str "Unable to convert " (type this) " to a time") {:object this}))))
+
 (defn now
   "Creates an object to represent the current time"
   []
   #?(:clj (Date.)
      :cljs (js/Date.)))
 
-(defn instant?
-  "Tests if a value is a timestamp"
-  [t]
-  (= #?(:clj Date :cljs js/Date) (type t)))
-
 (defn instant
   "Creates an instant from a long millisecond value"
   [^long ms]
   #?(:clj (Date. ms) :cljs (js/Date. ms)))
 
-(defn long-time
-  "Converts a timestamp to a long value as the number of milliseconds"
-  #?(:clj [^java.util.Date t]
-     :cljs [t])
-  (.getTime t))  ;; this is an identical operation in both Java and Javascript
-
 (def project-args {:new-node graph/new-node
                    :node-label graph/node-label})
 

src/asami/memory.cljc

@@ -2,7 +2,7 @@
       :author "Paula Gearon"}
     asami.memory
     (:require [asami.storage :as storage :refer [ConnectionType DatabaseType UpdateData]]
-              [asami.internal :refer [now instant?]]
+              [asami.internal :refer [now instant? to-timestamp]]
               [asami.index :as mem]
               [asami.multi-graph :as multi]
               [asami.graph :as gr :refer [GraphType]]
@@ -119,10 +119,11 @@
   [{:keys [graph history timestamp] :as db} :- DatabaseType
    t :- (s/cond-pre s/Int (s/pred instant?))]
   (cond
-    (instant? t) (if (>= (compare t timestamp) 0)
-                   db
-                   (nth history
-                        (find-index history t #(compare (:timestamp %1) %2))))
+    (instant? t) (let [ts (to-timestamp t)]
+                   (if (>= (compare ts timestamp) 0)
+                     db
+                     (nth history
+                          (find-index history ts #(compare (:timestamp %1) %2)))))
     (int? t) (if (>= t (count history))
                db
                (nth history (min (max t 0) (dec (count history)))))))
@@ -143,13 +144,14 @@
   [{:keys [graph history timestamp] :as db} :- DatabaseType
    t :- (s/cond-pre s/Int (s/pred instant?))]
   (cond
-    (instant? t) (cond
-                   (> (compare t timestamp) 0) nil
-                   (< (compare t (:timestamp (first history))) 0) (first history)
-                   :default (let [tx (inc (find-index history t #(compare (:timestamp %1) %2)))]
-                              (if (= tx (count history))
-                                db
-                                (nth history tx))))
+    (instant? t) (let [ts (to-timestamp t)]
+                   (cond
+                     (> (compare ts timestamp) 0) nil
+                     (< (compare ts (:timestamp (first history))) 0) (first history)
+                     :default (let [tx (inc (find-index history ts #(compare (:timestamp %1) %2)))]
+                                (if (= tx (count history))
+                                  db
+                                  (nth history tx)))))
     (int? t) (cond (>= t (count history)) nil
                    (= (count history) (inc t)) db
                    :default (nth history (min (max (inc t) 0) (dec (count history)))))))

test/asami/api_test.cljc

@@ -12,7 +12,13 @@
                :cljs [clojure.test :refer-macros [is run-tests use-fixtures testing]])
             #?(:clj  [schema.test :as st :refer [deftest]]
                :cljs [schema.test :as st :refer-macros [deftest]]))
-  #?(:clj (:import [clojure.lang ExceptionInfo])))
+  #?(:clj (:import [clojure.lang ExceptionInfo]
+                   [java.time Instant])))
+
+(defn other-now
+  "Create a different kind of instant object on the JVM"
+  []
+  #?(:clj (Instant/now) :cljs (now)))
 
 (deftest test-create
   (let [c1 (create-database "asami:mem://babaco")
@@ -304,7 +310,7 @@
         _ (sleep 100)
         c (connect "asami:mem://test5")
         _ (sleep 100)
-        t1 (now)
+        t1 (other-now)
         maksim {:db/id -1
                 :db/ident :maksim
                 :name  "Maksim"
@@ -323,7 +329,7 @@
         _ (sleep 100)
         _ @(transact c [anna])
         _ (sleep 100)
-        t3 (now)
+        t3 (other-now)
         latest-db (db c)
         db0 (as-of latest-db t0)  ;; before
         db1 (as-of latest-db t1)  ;; empty