pglpg 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 64d4bfb95eeacd8297e72c8dc02b95bcda6354e5c3c157655483c13d78e9b9a8
+  data.tar.gz: c75cbedcd42f7fe07265f8aecfea1e78adc5e44f3651587b069955ea6c47f254
+SHA512:
+  metadata.gz: 1b0d31c4236eac2f7b3cb22b65d7650c1a01d3687ea5505b44e64b540e54f9d6e880344e2bbc1f90a6bb1512dcfdaad5c06ea0dc58ea621f768e82c50926e513
+  data.tar.gz: a8bcb6da10e7779df9409d7dc5923a0f172177d4d2acb8f695a347adf89019bc1d04b4a5187b8c85560b7043b171bfc0bc464c1256189c4ae43db59d5c4f0a5d

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## 0.1.0 (2026-10-28)
+
+First version, following the accepted 0.1 baseline (knowen.md bb topic 145).
+Requires Ruby ≥ 4.0, ActiveRecord ≥ 8.1 and PostgreSQL ≥ 18.
+
+- Graph type DSL: node types with inheritance and abstract types, edge types,
+  typed properties (closed types), one string key per type, `unique: :pair`
+  edge types, application columns.
+- Storage: two tables per graph, generated constraints (endpoint foreign keys
+  with `ON DELETE RESTRICT`, keys unique across a type and its subtypes, pair
+  uniqueness, typed required-property checks), `sync_constraints!`,
+  `label_drift` and `relabel!`.
+- `Pglpg::Ref`: immutable, graph-scoped element references.
+- `Graph#for(viewer:)` as the only entry point.
+- Writes: interactive inserts with generated keys, updates and edge deletes;
+  a trusted writer (granted by the application) for caller-chosen keys,
+  upserts and node deletes. The write policy checks the request in Ruby;
+  visibility and the policy's conditions on the stored row run inside the
+  statement; edge endpoints are checked and locked `FOR SHARE`.
+- Fixed-length pattern queries with structured conditions, ordering,
+  pagination, `count`, `exists?`, `first`, `distinct` and typed results.
+- Shared leak specs (`it_behaves_like "a pglpg visibility policy"`).
+- Benchmark harness with time and buffer limits.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 valamon.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,153 @@
+# pglpg
+
+Labeled property graphs stored in plain PostgreSQL tables, for Ruby.
+
+pglpg follows the ISO GQL property graph model and PG-Schema / PG-Keys. It
+needs no PostgreSQL extension and no second database: each graph is two
+ordinary tables, written inside your own transactions. Every query applies
+your visibility policy to every node and edge on every hop, so hidden records
+never act as bridges and never show up in counts or limits.
+
+Status: **0.1, pre-release.** The design and its decisions live in the
+[pglpg.md](https://knowen.md/nodes/36325) knowledge base. Requires Ruby ≥ 4.0,
+ActiveRecord ≥ 8.1 and PostgreSQL ≥ 18: the versions CI tests.
+
+## Define a graph
+
+```ruby
+Kg = Pglpg::Graph.define(:kg) do
+  # Application columns: real, indexed columns your policies filter on.
+  column :classification, :integer, null: false, covering: true
+
+  node :Person do
+    property :uid, :string, required: true
+    property :name, :string
+    property :born, :date
+    key :uid                       # unique across Person and its subtypes
+  end
+  node :Employee, extends: :Person # labels {Employee, Person}
+  node :Project do
+    property :uid, :string, required: true
+    property :headcount, :integer
+    key :uid, generate: ->(_type) { "PRJ-#{SecureRandom.hex(6)}" }
+  end
+
+  edge :WORKS_ON, from: :Person, to: :Project, unique: :pair do
+    property :role, :string
+  end
+  edge :KNOWS, from: :Person, to: :Person
+end
+```
+
+Property types: `string integer float decimal boolean date datetime enum list`
+(`enum` takes `values:`, `list` takes `of:`). Types are closed: undeclared
+properties are rejected. A nil value means the property is absent.
+
+In a migration:
+
+```ruby
+def up   = Kg.storage.create!            # tables, indexes, constraints
+def down = Kg.storage.drop!
+# After changing the graph type:
+Kg.storage.sync_constraints!
+Kg.storage.relabel!                      # when inherited labels changed
+```
+
+`Kg.storage.label_drift` returns `{}` when stored labels match the schema;
+put it in a spec.
+
+## Policies
+
+```ruby
+Pglpg.configure do |c|
+  c.visibility = ClearancePolicy        # required for reads
+  c.write_policy = ClearanceWritePolicy # required for writes
+  c.trusted_writer_allowed = ->(ctx) { ctx.viewer.importer? } # off when unset
+end
+
+module ClearancePolicy                  # Arel conditions, applied to every alias
+  def self.node(table, viewer) = table[:classification].lteq(viewer.clearance)
+  def self.edge(table, viewer) = table[:classification].lteq(viewer.clearance)
+end
+
+module ClearanceWritePolicy
+  # The requested operation and new state (a Pglpg::WriteRequest).
+  def self.authorize?(req) = req.attrs.fetch(:classification, 0) <= req.viewer.clearance
+
+  # Optional: a condition on the stored row, checked inside the statement
+  # (for example, allowed old -> new transitions).
+  def self.existing(table, req) = nil
+end
+```
+
+Policies can also be passed per graph to `Graph.define`.
+
+## Write
+
+```ruby
+g = Kg.for(viewer: current_viewer)
+
+ann = g.insert_node(:Person, properties: { name: "Ann" }, attrs: { classification: 1 })
+# => #<Pglpg::Ref kg:node:1>   (uid is generated; passing one raises ArgumentError)
+g.update_node(ann, properties: { born: Date.new(1990, 1, 1) })
+g.insert_edge(:KNOWS, from: ann, to: bob, attrs: { classification: 1 })
+
+w = g.trusted_writer                    # raises NotTrusted unless granted
+p = w.upsert_node(:Person, key: { uid: "PER-12" }, properties: { name: "Bob" }, attrs: { classification: 1 })
+w.upsert_edge(:WORKS_ON, from: p, to: project, properties: { role: "lead" }, attrs: { classification: 1 })
+```
+
+A refused write raises `Pglpg::WriteRejected` with no Ref and no row data,
+whether the target is hidden, missing or not allowed. Writes run in a
+savepoint, so a refusal never aborts your transaction.
+
+## Query
+
+```ruby
+rows = g.match
+        .node(:p, :Person, uid: "PER-12")
+        .out(:WORKS_ON, :j, :Project, edge: :w)
+        .in(:WORKS_ON, :q, :Person, from: :j)      # branch from an earlier variable
+        .where(j: { headcount: Pglpg.gt(0) }, w: { role: "lead" })
+        .return(:q, :j)
+        .order(q: :name)
+        .limit(50)
+        .to_a
+rows.first[:q]   # => #<Pglpg::Node ...>
+
+g.find(ref)                         # visible node or edge, else nil
+g.find_node(:Person, uid: "PER-12")
+query.count; query.exists?; query.first; query.distinct; query.explain(analyze: true)
+```
+
+Conditions are structured only: a value (equality), an array (one of), nil
+(absent), or `Pglpg.gt / gte / lt / lte / ne / in`. Queries without a limit
+raise `Pglpg::TooManyRows` beyond `max_rows` (default 1000); reads run under
+`statement_timeout` (default 5 s) and raise `Pglpg::QueryTimeout`.
+
+## Leak specs for your policy
+
+```ruby
+require "pglpg/testing"
+
+RSpec.describe ClearancePolicy do
+  it_behaves_like "a pglpg visibility policy" do
+    let(:pglpg_visibility)    { ClearancePolicy }
+    let(:pglpg_viewer)        { Viewer.new(clearance: 2) }
+    let(:pglpg_columns)       { { classification: [:integer, { null: false }] } }
+    let(:pglpg_visible_attrs) { { classification: 2 } }
+    let(:pglpg_hidden_attrs)  { { classification: 3 } }
+  end
+end
+```
+
+## Development
+
+```bash
+createdb pglpg_test
+bundle install
+bundle exec rspec
+```
+
+`PGLPG_DATABASE_URL` overrides the test database (use one per worktree).
+The benchmark is described in [bench/README.md](bench/README.md).

data/lib/pglpg/condition.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pglpg
+  # A structured property condition. Plain values mean equality, arrays mean
+  # "one of", nil means "absent". Use Pglpg.gt(3) and friends for the rest.
+  Condition = Data.define(:op, :value) do
+    def self.wrap(value)
+      case value
+      when Condition then value
+      when nil then new(op: :absent, value: nil)
+      when Array then new(op: :in, value:)
+      when Range then raise ArgumentError, "ranges are not supported; combine Pglpg.gte and Pglpg.lte"
+      else new(op: :eq, value:)
+      end
+    end
+  end
+
+  Condition::OPS = { gt: ">", gte: ">=", lt: "<", lte: "<=", ne: "<>" }.freeze
+
+  class << self
+    def gt(value) = Condition.new(op: :gt, value:)
+
+    def gte(value) = Condition.new(op: :gte, value:)
+
+    def lt(value) = Condition.new(op: :lt, value:)
+
+    def lte(value) = Condition.new(op: :lte, value:)
+
+    def ne(value) = Condition.new(op: :ne, value:)
+
+    def in(values) = Condition.new(op: :in, value: Array(values))
+  end
+end

data/lib/pglpg/configuration.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pglpg
+  # Global settings. Each graph can override visibility, write_policy and
+  # trusted_writer_allowed when it is defined.
+  class Configuration
+    # Required. An object with +node(table, viewer)+ and +edge(table, viewer)+,
+    # each returning an Arel condition on the given Arel::Table.
+    attr_accessor :visibility
+
+    # Required for writes. An object with +authorize?(request)+ and, optionally,
+    # +existing(table, request)+ returning an Arel condition on the stored row.
+    attr_accessor :write_policy
+
+    # A callable +->(context) { ... }+ returning true when the trusted writer
+    # may be used for that context. Unset means the capability is never granted.
+    attr_accessor :trusted_writer_allowed
+
+    # The ActiveRecord class whose connection pglpg uses.
+    attr_accessor :connection_class
+
+    # Queries without an explicit limit raise TooManyRows above this many rows.
+    attr_accessor :max_rows
+
+    # Statement timeout for reads, in milliseconds. nil leaves the session value.
+    attr_accessor :statement_timeout
+
+    def initialize
+      @connection_class = nil
+      @max_rows = 1000
+      @statement_timeout = 5000
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/pglpg/context.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Pglpg
+  # A graph seen by one viewer. Created by Graph#for; immutable. Every query
+  # and write built from it applies the graph's policies for this viewer.
+  class Context
+    attr_reader :graph, :viewer
+
+    def initialize(graph, viewer)
+      @graph = graph
+      @viewer = viewer
+      freeze
+    end
+
+    # Starts a fixed-length pattern query.
+    def match = Query.new(self)
+
+    # The visible node or edge behind +ref+, or nil. A hidden element and a
+    # missing one look the same.
+    def find(ref)
+      raise InvalidRef, "expected a Pglpg::Ref" unless ref.is_a?(Ref)
+
+      graph.check_ref!(ref, ref.kind)
+      return match.node(:n, ref:).first&.fetch(:n) if ref.node?
+
+      sql = Sql.new(graph.connection)
+      e = "e"
+      sql << "SELECT to_jsonb(e) AS e FROM " << table_sql(graph.edges_table) << " AS e"
+      sql << " JOIN " << table_sql(graph.nodes_table) << " AS s ON s.id = e.source_id AND "
+      append_node_visible(sql, "s")
+      sql << " JOIN " << table_sql(graph.nodes_table) << " AS t ON t.id = e.target_id AND "
+      append_node_visible(sql, "t")
+      sql << " WHERE e.id = "
+      sql.bind(ref.id, "bigint") << " AND "
+      append_edge_visible(sql, e)
+      row = read(sql).first
+      row && graph.build_edge(JSON.parse(row["e"]))
+    end
+
+    # The visible node of +type+ (or a subtype) with the given key, or nil.
+    #   ctx.find_node(:Person, uid: "PER-12")
+    def find_node(type, **key)
+      node_type = graph.type.node_type!(type)
+      unless node_type.key && key.keys == [node_type.key.property]
+        raise ArgumentError, "#{type} is looked up by #{node_type.key&.property.inspect}"
+      end
+
+      match.node(:n, type, **key).first&.fetch(:n)
+    end
+
+    def insert_node(type, properties: {}, attrs: {}) = writer.insert_node(type, properties:, attrs:)
+
+    def update_node(ref, properties: {}, attrs: {}) = writer.update_node(ref, properties:, attrs:)
+
+    def insert_edge(type, from:, to:, properties: {}, attrs: {}) = writer.insert_edge(type, from:, to:, properties:, attrs:)
+
+    def update_edge(ref, properties: {}, attrs: {}) = writer.update_edge(ref, properties:, attrs:)
+
+    def delete_edge(ref) = writer.delete_edge(ref)
+
+    # The trusted writer: caller-chosen keys, upserts and node deletion.
+    # Raises NotTrusted unless the application's trusted_writer_allowed
+    # callable approves this context. It does not bypass validation, the
+    # write policy or endpoint checks.
+    def trusted_writer
+      allowed = graph.trusted_writer_allowed
+      raise NotTrusted, "trusted writer not granted" unless allowed.respond_to?(:call) && allowed.call(self) == true
+
+      Writer.new(self, trusted: true)
+    end
+
+    def inspect = "#<Pglpg::Context #{graph.name} viewer=#{viewer.inspect}>"
+
+    # -- internal ------------------------------------------------------------
+
+    def table_sql(name) = graph.connection.quote_table_name(name)
+
+    # Appends the visibility condition for the node alias +name+.
+    def append_node_visible(sql, name)
+      sql << "("
+      sql.arel(policy_condition(graph.visibility.node(Arel::Table.new(name), viewer)))
+      sql << ")"
+    end
+
+    def append_edge_visible(sql, name)
+      sql << "("
+      sql.arel(policy_condition(graph.visibility.edge(Arel::Table.new(name), viewer)))
+      sql << ")"
+    end
+
+    # Runs a read under the configured statement timeout.
+    def read(sql)
+      graph.with_connection do |c|
+        timeout = Pglpg.configuration.statement_timeout
+        next c.select_all(sql.to_s, "Pglpg", sql.binds).to_a if timeout.nil?
+
+        c.transaction(requires_new: true) do
+          previous = c.select_value("SELECT current_setting('statement_timeout')")
+          c.select_value("SELECT set_config('statement_timeout', '#{Integer(timeout)}', true)")
+          rows = c.select_all(sql.to_s, "Pglpg", sql.binds).to_a
+          c.select_value("SELECT set_config('statement_timeout', #{c.quote(previous)}, true)")
+          rows
+        end
+      end
+    rescue ActiveRecord::QueryCanceled
+      raise QueryTimeout
+    end
+
+    private
+
+    def writer = Writer.new(self, trusted: false)
+
+    # A policy must return an Arel condition; anything else fails closed.
+    def policy_condition(node)
+      return node if node.is_a?(Arel::Nodes::Node) || node.is_a?(Arel::Nodes::SqlLiteral)
+
+      raise ConfigurationError, "policy returned #{node.class}, expected an Arel condition"
+    end
+  end
+end

data/lib/pglpg/element.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Pglpg
+  # A node read from the graph. Values are frozen.
+  class Node
+    attr_reader :ref, :key_label, :labels, :properties, :attrs, :created_at, :updated_at
+
+    def initialize(ref:, key_label:, labels:, properties:, attrs:, created_at:, updated_at:)
+      @ref = ref
+      @key_label = key_label
+      @labels = labels
+      @properties = properties
+      @attrs = attrs
+      @created_at = created_at
+      @updated_at = updated_at
+      freeze
+    end
+
+    def id = ref.id
+
+    def [](name) = properties[name.to_sym]
+
+    def label?(label) = labels.include?(label.to_sym)
+
+    def ==(other) = other.is_a?(Node) && other.ref == ref
+
+    alias eql? ==
+
+    def hash = ref.hash
+
+    def inspect = "#<Pglpg::Node #{ref} #{key_label} #{properties.inspect}>"
+  end
+
+  # An edge read from the graph. Values are frozen.
+  class Edge
+    attr_reader :ref, :type, :source, :target, :properties, :attrs, :created_at, :updated_at
+
+    def initialize(ref:, type:, source:, target:, properties:, attrs:, created_at:, updated_at:)
+      @ref = ref
+      @type = type
+      @source = source
+      @target = target
+      @properties = properties
+      @attrs = attrs
+      @created_at = created_at
+      @updated_at = updated_at
+      freeze
+    end
+
+    def id = ref.id
+
+    def [](name) = properties[name.to_sym]
+
+    def ==(other) = other.is_a?(Edge) && other.ref == ref
+
+    alias eql? ==
+
+    def hash = ref.hash
+
+    def inspect = "#<Pglpg::Edge #{ref} #{type} #{source.id}->#{target.id} #{properties.inspect}>"
+  end
+end

data/lib/pglpg/errors.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pglpg
+  # Base class for every error pglpg raises.
+  class Error < StandardError; end
+
+  # The graph type declaration is invalid.
+  class SchemaError < Error; end
+
+  # pglpg is used without a required policy or setting.
+  class ConfigurationError < Error; end
+
+  # A Ref belongs to another graph or is the wrong kind of element.
+  class InvalidRef < Error; end
+
+  # Properties or application columns do not match the graph type.
+  class ValidationError < Error; end
+
+  # A write was refused: by the write policy, by visibility, or because the
+  # target does not exist. The error deliberately carries no Ref and no row
+  # data, so a refusal looks the same whatever the reason.
+  class WriteRejected < Error
+    def initialize(msg = "write rejected")
+      super
+    end
+  end
+
+  # The application did not grant the trusted-writer capability.
+  class NotTrusted < Error; end
+
+  # A query without an explicit limit matched more rows than max_rows allows.
+  class TooManyRows < Error; end
+
+  # A query ran past its statement timeout.
+  class QueryTimeout < Error
+    def initialize(msg = "query timed out")
+      super
+    end
+  end
+end

data/lib/pglpg/graph.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Pglpg
+  # A property graph: its graph type, its storage, and the policies that
+  # guard it. Every read and write starts from #for.
+  #
+  #   Kg = Pglpg::Graph.define(:kg) do
+  #     node_column :classification, :integer, null: false
+  #     node :Person do
+  #       property :uid, :string, required: true
+  #       key :uid
+  #     end
+  #   end
+  #   Kg.for(viewer: current_viewer).match.node(:p, :Person).to_a
+  class Graph
+    attr_reader :name, :type, :storage
+
+    def self.define(name, nodes_table: nil, edges_table: nil, visibility: nil, write_policy: nil,
+                    trusted_writer_allowed: nil, connection_class: nil, &block)
+      type = Schema::GraphType.new
+      Schema::Builder.new(type).instance_eval(&block) if block
+      type.resolve!
+      new(name, type, nodes_table: nodes_table || "#{name}_nodes", edges_table: edges_table || "#{name}_edges",
+                      visibility:, write_policy:, trusted_writer_allowed:, connection_class:)
+    end
+
+    def initialize(name, type, nodes_table:, edges_table:, visibility:, write_policy:, trusted_writer_allowed:,
+                   connection_class:)
+      @name = Schema.check_name!(name, "graph")
+      @type = type
+      @storage = Storage.new(self, nodes_table:, edges_table:)
+      @visibility = visibility
+      @write_policy = write_policy
+      @trusted_writer_allowed = trusted_writer_allowed
+      @connection_class = connection_class
+      freeze
+    end
+
+    # The only entry point for queries and writes. The returned context is
+    # immutable and carries the viewer to everything built from it.
+    def for(viewer:)
+      Context.new(self, viewer)
+    end
+
+    def ref(kind, id) = Ref.new(graph: name, kind:, id:)
+
+    # Parses "graph:kind:id" as produced by Ref#to_s.
+    def parse_ref(string)
+      graph, kind, id = string.to_s.split(":", 3)
+      raise InvalidRef, "not a ref of graph #{name}" unless graph == name.to_s && %w[node edge].include?(kind)
+
+      ref(kind, Integer(id, 10))
+    rescue ArgumentError, TypeError
+      raise InvalidRef, "malformed ref"
+    end
+
+    # Raises unless +ref+ is a Ref of this graph and of the given kind.
+    def check_ref!(ref, kind)
+      raise InvalidRef, "expected a Pglpg::Ref" unless ref.is_a?(Ref)
+      raise InvalidRef, "ref belongs to graph #{ref.graph}, not #{name}" unless ref.graph == name
+      raise InvalidRef, "expected a #{kind} ref" unless ref.kind == kind
+
+      ref
+    end
+
+    def visibility
+      @visibility || Pglpg.configuration.visibility ||
+        raise(ConfigurationError, "no visibility policy configured for graph #{name}")
+    end
+
+    def write_policy
+      @write_policy || Pglpg.configuration.write_policy ||
+        raise(ConfigurationError, "no write policy configured for graph #{name}")
+    end
+
+    def trusted_writer_allowed = @trusted_writer_allowed || Pglpg.configuration.trusted_writer_allowed
+
+    def connection_class = @connection_class || Pglpg.configuration.connection_class || ActiveRecord::Base
+
+    def with_connection(&) = connection_class.with_connection(&)
+
+    def connection
+      connection_class.respond_to?(:lease_connection) ? connection_class.lease_connection : connection_class.connection
+    end
+
+    def nodes_table = storage.nodes_table
+
+    def edges_table = storage.edges_table
+
+    def inspect = "#<Pglpg::Graph #{name}>"
+
+    # Builds a Node from the to_jsonb() of a nodes row.
+    def build_node(row)
+      node_type = type.node_types[row["key_label"].to_sym]
+      Node.new(
+        ref: ref(:node, row["id"]), key_label: row["key_label"].to_sym,
+        labels: row["labels"].map(&:to_sym).freeze,
+        properties: node_type ? node_type.decode_properties(row["properties"]) : row["properties"].transform_keys(&:to_sym).freeze,
+        attrs: decode_attrs(type.node_columns, row),
+        created_at: Time.iso8601(row["created_at"]), updated_at: Time.iso8601(row["updated_at"])
+      )
+    end
+
+    # Builds an Edge from the to_jsonb() of an edges row.
+    def build_edge(row)
+      edge_type = type.edge_types[row["type"].to_sym]
+      Edge.new(
+        ref: ref(:edge, row["id"]), type: row["type"].to_sym,
+        source: ref(:node, row["source_id"]), target: ref(:node, row["target_id"]),
+        properties: edge_type ? edge_type.decode_properties(row["properties"]) : row["properties"].transform_keys(&:to_sym).freeze,
+        attrs: decode_attrs(type.edge_columns, row),
+        created_at: Time.iso8601(row["created_at"]), updated_at: Time.iso8601(row["updated_at"])
+      )
+    end
+
+    private
+
+    def decode_attrs(columns, row)
+      columns.each_value.to_h do |c|
+        value = row[c.name.to_s]
+        cast = begin
+          ActiveModel::Type.lookup(c.type).cast(value)
+        rescue ArgumentError
+          value
+        end
+        [c.name, cast]
+      end.freeze
+    end
+  end
+end