diametric 0.0.4 → 0.1.1

data/ext/diametric/DiametricService.java

@@ -0,0 +1,102 @@
+package diametric;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class DiametricService implements BasicLibraryService {
+
+    @Override
+    public boolean basicLoad(Ruby runtime) throws IOException {
+        RubyModule diametric = runtime.defineModule("Diametric");
+        RubyModule persistence = diametric.defineModuleUnder("Persistence");
+
+        RubyModule diametric_peer = persistence.defineModuleUnder("Peer");
+        diametric_peer.defineAnnotatedMethods(DiametricPeer.class);
+
+        RubyClass connection = persistence.defineClassUnder("Connection", runtime.getObject(), CONNECTION_ALLOCATOR);
+        connection.defineAnnotatedMethods(DiametricConnection.class);
+
+        RubyClass uuid = persistence.defineClassUnder("UUID", runtime.getObject(), UUID_ALLOCATOR);
+        uuid.defineAnnotatedMethods(DiametricUUID.class);
+
+        RubyClass diametric_object = persistence.defineClassUnder("Object", runtime.getObject(), DIAMETRIC_OBJECT_ALLOCATOR);
+        diametric_object.defineAnnotatedMethods(DiametricObject.class);
+
+        RubyClass diametric_query_result = persistence.defineClassUnder("Collection", runtime.getObject(), COLLECTION_ALLOCATOR);
+        diametric_query_result.defineAnnotatedMethods(DiametricCollection.class);
+
+        RubyClass diametric_listenable = persistence.defineClassUnder("ListenableFuture", runtime.getObject(), LISTENABLE_ALLOCATOR);
+        diametric_listenable.defineAnnotatedMethods(DiametricListenableFuture.class);
+
+        RubyClass diametric_database = persistence.defineClassUnder("Database", runtime.getObject(), DATABASE_ALLOCATOR);
+        diametric_database.defineAnnotatedMethods(DiametricDatabase.class);
+
+        RubyClass diametric_entity = persistence.defineClassUnder("Entity", runtime.getObject(), ENTITY_ALLOCATOR);
+        diametric_entity.defineAnnotatedMethods(DiametricEntity.class);
+
+        RubyModule diametric_utils = persistence.defineModuleUnder("Utils");
+        diametric_utils.defineAnnotatedMethods(DiametricUtils.class);
+
+        setupClojureRT();
+
+        return false;
+    }
+
+    public static final ObjectAllocator CONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricConnection(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator UUID_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricUUID(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator DIAMETRIC_OBJECT_ALLOCATOR = new ObjectAllocator() {
+        DiametricObject diametric_object = null;
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            if (diametric_object == null) diametric_object = new DiametricObject(runtime, klazz);
+            try {
+                return (DiametricObject) diametric_object.clone();
+            } catch (CloneNotSupportedException e) {
+                return new DiametricObject(runtime, klazz);
+            }
+        }
+    };
+
+    public static final ObjectAllocator COLLECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricCollection(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator LISTENABLE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricListenableFuture(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator DATABASE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricDatabase(runtime, klazz);
+        }
+    };
+
+    public static final ObjectAllocator ENTITY_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new DiametricEntity(runtime, klazz);
+        }
+    };
+
+    private void setupClojureRT() {
+        clojure.lang.RT.var("clojure.core", "require").invoke(clojure.lang.Symbol.intern("datomic.api"));
+    }
+}

data/ext/diametric/DiametricUUID.java

@@ -0,0 +1,61 @@
+package diametric;
+
+import java.util.UUID;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+@JRubyClass(name = "Diametric::Persistence::UUID")
+public class DiametricUUID extends RubyObject {
+    private static final long serialVersionUID = 2083281771243513904L;
+    private java.util.UUID java_uuid = null;
+
+    public DiametricUUID(Ruby runtime, RubyClass klazz) {
+        super(runtime, klazz);
+    }
+    
+    void init(java.util.UUID java_uuid) {
+        this.java_uuid = java_uuid;
+    }
+    
+    java.util.UUID getUUID() {
+        return java_uuid;
+    }
+    
+    @JRubyMethod(name = "new", meta = true)
+    public static IRubyObject rbNew(ThreadContext context, IRubyObject klazz) {
+        RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::UUID");
+        DiametricUUID diametric_uuid = (DiametricUUID)clazz.allocate();
+        try {
+            java.util.UUID java_uuid = (UUID) clojure.lang.RT.var("datomic.api", "squuid").invoke();
+            diametric_uuid.init(java_uuid);
+            return diametric_uuid;
+        } catch (Throwable t) {
+            throw context.getRuntime().newRuntimeError(t.getMessage());
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject to_java(ThreadContext context) {
+        return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), java_uuid);
+    }
+    
+    @JRubyMethod
+    public IRubyObject to_s(ThreadContext context) {
+        if (java_uuid == null) return context.getRuntime().getNil();
+        return RubyString.newString(context.getRuntime(), java_uuid.toString());
+    }
+    
+    @JRubyMethod
+    public IRubyObject generate(ThreadContext context, IRubyObject arg) {
+        if (java_uuid == null) return context.getRuntime().getNil();
+        return RubyString.newString(context.getRuntime(), java.util.UUID.randomUUID().toString());
+    }
+}

data/ext/diametric/DiametricUtils.java

@@ -0,0 +1,183 @@
+package diametric;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBignum;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyHash;
+import org.jruby.RubyNil;
+import org.jruby.RubyString;
+import org.jruby.RubyTime;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import datomic.Util;
+
+@JRubyModule(name="Diametric::Persistence::Utils")
+public class DiametricUtils {
+
+    @JRubyMethod(meta=true)
+    public static IRubyObject read_all(ThreadContext context, IRubyObject klazz, IRubyObject arg) {
+        String filename = null;
+        if (arg instanceof RubyString) {
+            filename = DiametricUtils.rubyStringToJava(arg);
+        } else {
+            throw context.getRuntime().newArgumentError("Argument should be filename");
+        }
+        Reader reader = null;
+        try {
+            reader = new FileReader(filename);
+            List list = (List) Util.readAll(reader);
+            RubyArray array = RubyArray.newArray(context.getRuntime(), list.size());
+            array.addAll(list);
+            return array;
+        } catch (Exception e) {
+            throw context.getRuntime().newRuntimeError(e.getMessage());
+        } finally {
+            try {
+                if (reader != null) reader.close();
+            } catch (IOException e) {
+                // no-op
+            }
+        }
+    }
+
+    static String rubyStringToJava(IRubyObject arg) {
+        if (arg instanceof RubyString) {
+            // TODO probably, we need to specify encoding.
+            return (String) ((RubyString)arg).toJava(String.class);
+        } else {
+            return null;
+        }
+    }
+    
+    static Object convertRubyToJava(ThreadContext context, IRubyObject value) {
+        if (value instanceof RubyString) {
+            String str = (String)((RubyString)value).toJava(String.class);
+            try {
+                return (Object)UUID.fromString(str);
+            } catch (IllegalArgumentException e) {
+                return (Object)str;
+            }
+        }
+        if (value instanceof RubyBoolean) return (Object)((RubyBoolean)value).toJava(Boolean.class);
+        if (value instanceof RubyFixnum) return (Object)((RubyFixnum)value).toJava(Long.class);
+        if (value instanceof DiametricUUID) return ((DiametricUUID)value).getUUID();
+        if (value instanceof RubyBignum) {
+            RubyString svalue = (RubyString)((RubyBignum)value).to_s();
+            java.math.BigInteger bivalue = new java.math.BigInteger((String)svalue.toJava(String.class));
+            return (Object)bivalue;
+        }
+        if (value instanceof RubyFloat) return (Object)((RubyFloat)value).toJava(Double.class);
+        if (value instanceof RubyTime) {
+            RubyTime tmvalue = (RubyTime)value;
+            return (Object)tmvalue.getJavaDate();
+        }
+        if (value.respondsTo("to_time")) {
+            // DateTime or Date
+            RubyTime tmvalue = (RubyTime)RuntimeHelpers.invoke(context, value, "to_time");
+            return (Object)tmvalue.getJavaDate();
+        }
+        //System.out.println("NOT YET CONVERTED");
+        //System.out.println("RESPONDSTO? TO_A:" + value.respondsTo("to_a"));
+        if (value.respondsTo("to_a")) { // might be Set for cardinality many type
+            RubyArray ruby_array = (RubyArray)RuntimeHelpers.invoke(context, value, "to_a");
+            List<Object> list = new ArrayList<Object>();
+            while (true) {
+                IRubyObject element = ruby_array.shift(context);
+                if (element.isNil()) break;
+                list.add(DiametricUtils.convertRubyToJava(context, element));
+            }
+            return Collections.unmodifiableList(list);
+        }
+        if (value instanceof DiametricObject) {
+            return ((DiametricObject)value).toJava();
+        }
+        return (Object)value.toJava(Object.class);
+    }
+   
+    static IRubyObject convertJavaToRuby(ThreadContext context, Object value) {
+        Ruby runtime = context.getRuntime();
+        if (value instanceof String) return RubyString.newString(runtime, (String)value);
+        if (value instanceof Boolean) return RubyBoolean.newBoolean(runtime, (Boolean)value);
+        if (value instanceof Long) return RubyFixnum.newFixnum(runtime, (Long)value);
+        if (value instanceof clojure.lang.Keyword) {
+            return RubyString.newString(runtime, ((clojure.lang.Keyword)value).toString());
+        }
+        if (value instanceof java.math.BigInteger) return RubyBignum.newBignum(runtime, ((java.math.BigInteger)value).longValue());
+        if (value instanceof Double) return RubyFloat.newFloat(runtime, (Double)value);
+        if (value instanceof Date) return RubyTime.newTime(runtime, ((Date)value).getTime());
+        if (value instanceof java.util.UUID) {
+            RubyClass clazz = (RubyClass)context.getRuntime().getClassFromPath("Diametric::Persistence::UUID");
+            DiametricUUID diametric_uuid = (DiametricUUID)clazz.allocate();
+            diametric_uuid.init((java.util.UUID)value);
+            return diametric_uuid;
+        }
+        return JavaUtil.convertJavaToUsableRubyObject(runtime, value);
+    }
+
+    static List<Object> convertRubyTxDataToJava(ThreadContext context, IRubyObject arg) {
+        List<Object> tx_data = null;
+        if (arg instanceof RubyArray) {
+            tx_data = fromRubyArray(context, arg);
+        } else {
+            Object obj = arg.toJava(Object.class);
+            if (obj instanceof clojure.lang.PersistentVector) {
+                tx_data = (clojure.lang.PersistentVector)obj;
+            }
+        }
+        return tx_data;
+    }
+
+    private static List<Object> fromRubyArray(ThreadContext context, IRubyObject arg) {
+        RubyArray ruby_tx_data = (RubyArray)arg;
+        List<Object> java_tx_data = new ArrayList<Object>();
+        for (int i=0; i<ruby_tx_data.getLength(); i++) {
+            IRubyObject element = (IRubyObject) ruby_tx_data.get(i);
+            if (element instanceof RubyHash) {
+                RubyHash ruby_hash = (RubyHash) element;
+                Map<Object, Object> keyvals = new HashMap<Object, Object>();
+                while (true) {
+                    IRubyObject pair = ruby_hash.shift(context);
+                    if (pair instanceof RubyNil) break;
+                    Object key = DiametricUtils.convertRubyToJava(context, ((RubyArray) pair).shift(context));
+                    Object value = DiametricUtils.convertRubyToJava(context, ((RubyArray) pair).shift(context));
+                    keyvals.put(key, value);
+                }
+                java_tx_data.add(Collections.unmodifiableMap(keyvals));
+            } else if (element instanceof RubyArray) {
+                RubyArray ruby_array = (RubyArray) element;
+                List<Object> keyvals = new ArrayList<Object>();
+                while (true) {
+                    IRubyObject ruby_element = ruby_array.shift(context);
+                    if (ruby_element instanceof RubyNil) break;
+                    Object key_or_value = DiametricUtils.convertRubyToJava(context, ruby_element);
+                    keyvals.add(key_or_value);
+                }
+                java_tx_data.add(Collections.unmodifiableList(keyvals));
+            } else {
+                continue;
+            }
+        }
+        return java_tx_data;
+    }
+}

data/lib/boolean_type.rb

@@ -0,0 +1,3 @@
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end

data/lib/diametric.rb

@@ -6,6 +6,30 @@ require "diametric/errors"
 
 require 'diametric/config'
 
+def is_jruby?
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+    true
+  else
+    false
+  end
+end
+
+if is_jruby?
+  require 'lock_jar'
+  jar_file = File.join(File.dirname(__FILE__), "..", "Jarfile")
+  lock_file = File.join(File.dirname(__FILE__), "..", "Jarfile.lock")
+  current_dir = Dir.pwd
+  Dir.chdir(File.dirname(lock_file))
+  LockJar.lock(jar_file)
+  LockJar.install(lock_file)
+  LockJar.load(lock_file)
+  Dir.chdir(current_dir)
+
+  require 'diametric_service.jar'
+  require 'diametric/diametric'
+  require 'diametric/persistence/peer'
+end
+
 if defined?(Rails)
   require 'diametric/railtie'
 end

data/lib/diametric/entity.rb

@@ -3,6 +3,9 @@ require "edn"
 require 'active_support/core_ext'
 require 'active_support/inflector'
 require 'active_model'
+require 'set'
+require 'value_enums'
+require 'boolean_type'
 
 module Diametric
 
@@ -29,15 +32,19 @@ module Diametric
   #   @return [Integer]
   module Entity
     Ref = "ref"
+    UUID = "uuid"
+    Double = "double"
     # Conversions from Ruby types to Datomic types.
     VALUE_TYPES = {
       Symbol => "keyword",
       String => "string",
       Integer => "long",
-      Float => "float",
+      Float => "double",
       BigDecimal => "bigdec",
       DateTime => "instant",
-      URI => "uri"
+      Boolean => "boolean",
+      URI => "uri",
+      UUID => "uuid"
     }
 
     DEFAULT_OPTIONS = {
@@ -56,6 +63,7 @@ module Diametric
       base.class_eval do
         @attributes = {}
         @defaults = {}
+        @enums = {}
         @namespace_prefix = nil
         @partition = :"db.part/user"
       end
@@ -163,18 +171,57 @@ module Diametric
         @attributes.keys
       end
 
+      # @return [Array<Symbol>] Names of the entity's enums.
+      def enum_names
+        @enums.keys
+      end
+
+      # Add an enum to a {Diametric::Entity}.
+      #
+      # enum is used when attribute type is Ref and refers
+      # a set of values.
+      # name should be the same as corresponding attribute name.
+      #
+      # @example Add an enum of colors
+      #   class Palette
+      #     attribute :color, Ref
+      #     enum :color, [:blue, :green, :yellow, :orange]
+      #   end
+      #   p = Pallet.new
+      #   p.color = Pallet::Color::Green
+      #
+      # @param name [Symbol] The enum's name.
+      # @param values [Array] The enum values.
+      #
+      # @return void
+      def enum(name, values)
+        enum_values = nil
+        enum_values = values.to_set if values.is_a?(Array)
+        enum_values = values if values.is_a?(Set)
+        raise RuntimeError "values should be Array or Set" if enum_values.nil?
+        enum_name = name.to_s.capitalize
+        syms = values.collect(&:to_s).collect(&:upcase).collect(&:to_sym)
+        class_eval("module #{enum_name};enum #{syms};end")
+        @enums[name] = syms
+      end
+
       # Generates a Datomic schema for a model's attributes.
       #
       # @return [Array] A Datomic schema, as Ruby data that can be
       #   converted to EDN.
       def schema
+        return peer_schema if self.instance_variable_get("@peer")
+        rest_schema
+      end
+
+      def rest_schema
         defaults = {
           :"db/id" => tempid(:"db.part/db"),
           :"db/cardinality" => :"db.cardinality/one",
           :"db.install/_attribute" => :"db.part/db"
         }
 
-        @attributes.reduce([]) do |schema, (attribute, opts)|
+        schema_array = @attributes.reduce([]) do |schema, (attribute, opts)|
           opts = opts.dup
           value_type = opts.delete(:value_type)
 
@@ -193,19 +240,147 @@ module Diametric
                                      :"db/valueType" => value_type(value_type),
                                    }).merge(opts)
         end
+
+        enum_schema = [
+          :"db/add", tempid(:"db.part/user"), :"db/ident"
+        ]
+        prefix = self.name.downcase
+        @enums.each do |key, values|
+          values.each do |value|
+            ident_value = :"#{prefix}.#{key.downcase}/#{value.to_s.sub(/_/, "-").downcase}"
+            es = [:"db/add", tempid(:"db.part/user"), :"db/ident", ident_value]
+            schema_array << es
+          end
+        end
+        schema_array
+      end
+
+      # Generates a Datomic schema for a model's attributes.
+      #
+      # @return [Array] A Datomic schema, as Ruby data that can be
+      #   converted to EDN.
+      def peer_schema
+        defaults = {
+          ":db/cardinality" => ":db.cardinality/one",
+          ":db.install/_attribute" => ":db.part/db"
+        }
+
+        schema_array = @attributes.reduce([]) do |schema, (attribute, opts)|
+          opts = opts.dup
+          value_type = opts.delete(:value_type)
+
+          unless opts.empty?
+            opts[:cardinality] = namespace("db.cardinality", opts[:cardinality])
+            opts[:unique] = namespace("db.unique", opts[:unique]) if opts[:unique]
+            opts = opts.map { |k, v|
+              k = namespace("db", k)
+              [k, v]
+            }
+            opts = Hash[*opts.flatten]
+          end
+
+          schema << defaults.merge({
+                                     ":db/id" => Diametric::Persistence::Peer.tempid(":db.part/db"),
+                                     ":db/ident" => namespace(prefix, attribute),
+                                     ":db/valueType" => value_type(value_type),
+                                   }).merge(opts)
+        end
+
+        prefix = self.name.downcase
+        @enums.each do |key, values|
+          values.each do |value|
+            ident_value = ":#{prefix}.#{key.downcase}/#{value.to_s.sub(/_/, "-").downcase}"
+            es = [":db/add", Diametric::Persistence::Peer.tempid(":db.part/user"), ":db/ident", ident_value]
+            schema_array << es
+          end
+        end
+        schema_array
       end
 
       # Given a set of Ruby data returned from a Datomic query, this
       # can re-hydrate that data into a model instance.
       #
       # @return [Entity]
-      def from_query(query_results)
+      def from_query(query_results, connection=nil, resolve=false)
         dbid = query_results.shift
         widget = self.new(Hash[attribute_names.zip query_results])
         widget.dbid = dbid
+
+        if resolve
+          widget = resolve_ref_dbid(widget, connection)
+        end
         widget
       end
 
+      def resolve_ref_dbid(parent, connection)
+        parent.class.attribute_names.each do |e|
+          if parent.class.attributes[e][:value_type] == "ref"
+            ref = parent.instance_variable_get("@#{e.to_s}")
+            if ref.is_a?(Fixnum) || ref.is_a?(Java::DatomicQuery::EntityMap)
+              child = from_dbid_or_entity(ref, connection)
+              child = resolve_ref_dbid(child, connection)
+              parent.instance_variable_set("@#{e.to_s}", child)
+            elsif ref.is_a?(Set)
+              children = ref.inject(Set.new) do |memo, entity|
+               child = from_dbid_or_entity(entity, connection)
+                memo.add(child)
+                memo
+              end
+              parent.instance_variable_set("@#{e.to_s}", children)
+            end
+          end
+        end
+        parent
+      end
+
+      def from_dbid_or_entity(thing, conn_or_db=nil, resolve=false)
+        conn_or_db ||= Diametric::Persistence::Peer.connect.db
+
+        if conn_or_db.respond_to?(:db)
+          conn_or_db = conn_or_db.db
+        end
+
+        if thing.is_a? Fixnum
+          dbid = thing
+          entity = conn_or_db.entity(dbid)
+        elsif thing.respond_to?(:eid)
+          dbid = thing.eid
+          if entity.respond_to?(:keys)
+            entity = thing
+          else
+            entity = conn_or_db.entity(dbid)
+          end
+        elsif thing.respond_to?(:to_java)
+          dbid = thing.to_java
+          entity = conn_or_db.entity(dbid)
+        else
+          return thing
+        end
+        first_key = entity.keys.first
+        match_data = /:([a-zA-Z0-9_]+)\/([a-zA-Z0-9_]+)/.match(first_key)
+        entity_name = match_data[1].capitalize.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}"}
+        instance = eval("#{entity_name}.new")
+        instance.send("#{match_data[2]}=", entity[first_key])
+        entity.keys[1..-1].each do |key|
+          match_data = /:([a-zA-Z0-9_]+)\/([a-zA-Z0-9_]+)/.match(key)
+          instance.send("#{match_data[2]}=", entity[key])
+        end
+        instance.send("dbid=", Diametric::Persistence::Object.new(dbid))
+
+        if resolve
+          instance = resolve_ref_dbid(instance, conn_or_db)
+        end
+
+        instance
+      end
+
+      def find(id)
+        if self.instance_variable_get("@peer")
+          connection ||= Diametric::Persistence::Peer.connect
+        end
+        from_dbid_or_entity(id, connection)
+      end
+
       # Returns the prefix for this model used in Datomic. Can be
       # overriden by declaring {#namespace_prefix}
       #
@@ -227,7 +402,15 @@ module Diametric
       #
       # @return [EDN::Type::Unknown] Temporary id placeholder.
       def tempid(*e)
-        EDN.tagged_element('db/id', e)
+        if self.instance_variable_get("@peer")
+          if e[0].to_s.include?("user")
+            return Diametric::Persistence::Peer.tempid(":db.part/user")
+          else
+            return Diametric::Persistence::Peer.tempid(":db.part/db")
+          end
+        else
+          EDN.tagged_element('db/id', e)
+        end
       end
 
       # Namespace a attribute for Datomic.
@@ -237,9 +420,13 @@ module Diametric
       #
       # @return [Symbol] Namespaced attribute.
       def namespace(ns, attribute)
-        [ns.to_s, attribute.to_s].join("/").to_sym
+        if self.instance_variable_get("@peer")
+          ":" + [ns.to_s, attribute.to_s].join("/")
+        else
+          [ns.to_s, attribute.to_s].join("/").to_sym
+        end
       end
-      
+
       # Raise an error if validation failed.
       #
       # @example Raise the validation error.
@@ -253,7 +440,7 @@ module Diametric
       private
 
       def value_type(vt)
-        if vt.is_a?(Class)
+        if vt.is_a?(Class) || vt.is_a?(Module)
           vt = VALUE_TYPES[vt]
         end
         namespace("db.type", vt)
@@ -323,6 +510,7 @@ module Diametric
       attribute_names.each do |attribute_name|
         cardinality = self.class.attributes[attribute_name.to_sym][:cardinality]
 
+        #if cardinality == :many && self.class.instance_variable_get("@peer").nil?
         if cardinality == :many
           txes += cardinality_many_tx_data(attribute_name)
         else
@@ -331,9 +519,13 @@ module Diametric
       end
 
       if entity_tx.present?
-        txes << entity_tx.merge({:"db/id" => dbid || tempid})
+        if self.class.instance_variable_get("@peer")
+          @dbid ||= tempid
+          txes << entity_tx.merge({":db/id" => dbid})
+        else
+          txes << entity_tx.merge({:"db/id" => dbid || tempid})
+        end
       end
-
       txes
     end
 
@@ -344,13 +536,26 @@ module Diametric
       protractions = curr - prev
       retractions = prev - curr
 
-      txes = []
       namespaced_attribute = self.class.namespace(self.class.prefix, attribute_name)
-      txes << [:"db/retract", (dbid || tempid), namespaced_attribute, retractions.to_a] unless retractions.empty?
-      txes << [:"db/add", (dbid || tempid) , namespaced_attribute, protractions.to_a] unless protractions.empty?
+      txes = []
+      if self.class.instance_variable_get("@peer")
+        @dbid ||= tempid
+        txes_data(txes, ":db/retract", namespaced_attribute, retractions) unless retractions.empty?
+        txes_data(txes, ":db/add", namespaced_attribute, protractions) unless protractions.empty?
+      else
+        txes << [:"db/retract", (dbid || tempid), namespaced_attribute, retractions.to_a] unless retractions.empty?
+        txes << [:"db/add", (dbid || tempid) , namespaced_attribute, protractions.to_a] unless protractions.empty?
+      end
       txes
     end
-    
+
+    def txes_data(txes, op, namespaced_attribute, set)
+      set.to_a.each do |s|
+        value = s.respond_to?(:dbid) ? s.dbid : s
+        txes << [op, @dbid, namespaced_attribute, value]
+      end
+    end
+
     # Returns hash of all attributes for this object
     #
     # @return [Hash<Symbol, object>] Hash of atrributes