pglpg 0.2.0 → 0.4.0

data/lib/pglpg/match_parser.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Pglpg
+  # The text front end builds the same immutable query state as the Ruby DSL.
+  class MatchParser
+    MAX_BYTES = 8 * 1024
+    MAX_HOPS = 8
+    MAX_PREDICATES = 32
+    MAX_PARAMETERS = 32
+
+    IDENTIFIER = /[A-Za-z_][A-Za-z_0-9]*/
+    PARAMETER = /\$#{IDENTIFIER}/
+    TOKEN = /#{PARAMETER}|#{IDENTIFIER}|[0-9]+|->|<-|[^\s]/
+    KEYWORDS = %w[MATCH WHERE AND RETURN DISTINCT ORDER BY ASC DESC LIMIT].freeze
+    UNSUPPORTED_WORDS = %w[OPTIONAL CREATE INSERT DELETE DETACH SET REMOVE MERGE
+                           CALL WITH UNION OFFSET SKIP GROUP HAVING].freeze
+    CONDITION_PREFIXES = %w[NOT ANY ALL NONE SINGLE EXISTS].freeze
+    CONDITION_OPERATORS = %w[IS IN NOT STARTS ENDS CONTAINS LIKE BETWEEN].freeze
+    CONDITION_CONNECTORS = %w[OR XOR].freeze
+    Token = Data.define(:text, :position)
+
+    def initialize(context, text, params)
+      raise ArgumentError, "MATCH text must be a String" unless text.is_a?(String)
+
+      @context = context
+      @text = text
+      @params = params
+      @bindings = {}
+      @types = {}
+    end
+
+    def parse
+      validate_text!
+      @scanner = StringScanner.new(@text)
+      advance
+      expect("MATCH")
+      start = node_pattern
+      hops = []
+      hops << edge_pattern while %w[- <- ~].include?(@token.text)
+      fail_at(:unsupported, "multiple patterns are outside the MATCH subset") if @token.text == ","
+      predicates = read_predicates
+      expect("RETURN")
+      distinct = accept("DISTINCT")
+      returns = [return_binding]
+      returns << return_binding while accept(",")
+      order = read_order if accept("ORDER")
+      limit = take_integer if accept("LIMIT")
+      accept(";")
+      expect_end!
+
+      if distinct && order && returns.none? { |var| var.text == order.first.text }
+        fail_at(:syntax, "DISTINCT ordering requires a returned binding", order.first)
+      end
+      check_cap(hops.size, MAX_HOPS, "hops", hops[MAX_HOPS]&.first)
+      check_cap(predicates.size, MAX_PREDICATES, "WHERE predicates", predicates[MAX_PREDICATES]&.first)
+      row_limit = validate_limit(limit)
+      values = parameter_values(predicates.map(&:last))
+
+      query = build_pattern(start, hops)
+      predicates.each do |var, name, param|
+        property!(var, name)
+        begin
+          query = query.where(var.text.to_sym => { name.text.to_sym => values.fetch(param.text.delete_prefix("$")) })
+        rescue ValidationError, ArgumentError, RangeError
+          fail_at(:parameter, "invalid equality value", param)
+        end
+      end
+      returns.each { type_for!(_1) }
+      query = query.return(*returns.map { _1.text.to_sym })
+      query = query.distinct if distinct
+      if order
+        var, name, direction = order
+        property!(var, name)
+        query = query.order(var.text.to_sym => { name.text.to_sym => direction })
+      end
+      row_limit ? query.limit(row_limit) : query
+    end
+
+    private
+
+    def validate_text!
+      unless [Encoding::UTF_8, Encoding::US_ASCII].include?(@text.encoding)
+        fail_at(:syntax, "text must use UTF-8 or US-ASCII", Token.new(nil, 0))
+      end
+      if @text.bytesize > MAX_BYTES
+        fail_at(:limit_exceeded, "text exceeds #{MAX_BYTES} bytes", Token.new(nil, MAX_BYTES))
+      end
+      return if @text.valid_encoding?
+
+      offset = 0
+      @text.each_char do |char|
+        fail_at(:syntax, "invalid text encoding", Token.new(nil, offset)) unless char.valid_encoding?
+        offset += char.bytesize
+      end
+    end
+
+    def advance
+      @scanner.skip(/\s+/)
+      position = @scanner.pos
+      if (comment = @scanner.scan(%r{//|/\*}))
+        fail_at(:unsupported, "comments are outside the MATCH subset", Token.new(comment, position))
+      end
+      @token = Token.new(@scanner.scan(TOKEN), position)
+    end
+
+    def take
+      token = @token
+      advance
+      token
+    end
+
+    def accept(text)
+      take if @token.text&.casecmp?(text)
+    end
+
+    def expect(text)
+      accept(text) || unexpected("expected #{text}")
+    end
+
+    def expect_end!
+      unexpected("expected end of input") if @token.text
+    end
+
+    def unexpected(message)
+      text = @token.text
+      unsupported = text && (UNSUPPORTED_WORDS.include?(text.upcase) || %w[{ } | & ! * + %].include?(text))
+      fail_at(unsupported ? :unsupported : :syntax, message)
+    end
+
+    def identifier
+      return take if @token.text&.match?(/\A#{IDENTIFIER}\z/)
+
+      unexpected("expected an identifier")
+    end
+
+    def binding
+      token = identifier
+      name = token.text
+      if name.start_with?("_") || KEYWORDS.include?(name.upcase) || @bindings.key?(name)
+        fail_at(:syntax, "reserved or duplicate binding", token)
+      end
+      @bindings[name] = true
+      token
+    end
+
+    def node_pattern
+      expect("(")
+      var = binding
+      expect(":")
+      label = identifier
+      expect(")")
+      [var, label]
+    end
+
+    def edge_pattern
+      connector = take
+      direction, ending = case connector.text
+                          when "-" then [:out, "->"]
+                          when "<-" then [:in, "-"]
+                          when "~" then [:both, "~"]
+                          end
+      expect("[")
+      var = binding unless @token.text == ":"
+      expect(":")
+      type = identifier
+      expect("]")
+      if direction == :out && @token.text == "-"
+        fail_at(:unsupported, "use a directed arrow or a symmetric tilde")
+      end
+      expect(ending)
+      [connector, direction, var, type, node_pattern]
+    end
+
+    def read_predicates
+      return [] unless accept("WHERE")
+
+      predicates = []
+      loop do
+        # Contextual keywords can still name a binding in a property reference.
+        prefix = CONDITION_PREFIXES.include?(@token.text&.upcase) && !@scanner.check(/\s*\./)
+        if @token.text == "(" || prefix
+          fail_at(:unsupported_condition, "only AND-joined equality predicates are supported")
+        end
+        var, property = property_reference
+        unless accept("=")
+          fail_at(:unsupported_condition, "only equality predicates are supported") if %w[< > !].include?(@token.text) ||
+            CONDITION_OPERATORS.include?(@token.text&.upcase)
+          unexpected("expected =")
+        end
+        unless @token.text&.match?(/\A#{PARAMETER}\z/)
+          fail_at(:unsupported_condition, "equality requires a named parameter") if @token.text && @token.text != "$" && !KEYWORDS.include?(@token.text.upcase)
+          unexpected("expected a named parameter")
+        end
+        predicates << [var, property, take]
+        fail_at(:unsupported_condition, "only AND conjunctions are supported") if CONDITION_CONNECTORS.include?(@token.text&.upcase)
+        break unless accept("AND")
+      end
+      predicates
+    end
+
+    def property_reference
+      var = identifier
+      expect(".")
+      [var, identifier]
+    end
+
+    def return_binding
+      var = identifier
+      fail_at(:unsupported, "RETURN accepts element bindings only") if %w[. ( AS].include?(@token.text&.upcase)
+      var
+    end
+
+    def read_order
+      expect("BY")
+      var, name = property_reference
+      direction = accept("DESC") ? :desc : :asc
+      accept("ASC") if direction == :asc
+      fail_at(:unsupported, "ORDER BY accepts one term") if @token.text == ","
+      [var, name, direction]
+    end
+
+    def take_integer
+      return take if @token.text&.match?(/\A[0-9]+\z/)
+
+      unexpected("expected a decimal integer")
+    end
+
+    def validate_limit(token)
+      return unless token
+
+      limit = token.text.to_i
+      fail_at(:syntax, "LIMIT must be positive", token) if limit.zero?
+      check_cap(limit, Pglpg.configuration.max_rows, "LIMIT", token)
+      limit
+    end
+
+    def parameter_values(references)
+      origin = Token.new(nil, 0)
+      fail_at(:parameter, "params must be a Hash", origin) unless @params.is_a?(Hash)
+      named = references.to_h { |token| [token.text.delete_prefix("$"), token] }
+      # The predicate cap also bounds the number of distinct references.
+      check_cap(@params.size, MAX_PARAMETERS, "parameter entries", origin)
+
+      values = {}
+      @params.each do |key, value|
+        unless (key.is_a?(String) || key.is_a?(Symbol)) &&
+               key.to_s.ascii_only? && key.to_s.match?(/\A#{IDENTIFIER}\z/)
+          fail_at(:parameter, "invalid parameter key", origin)
+        end
+        name = key.to_s
+        token = named[name] || origin
+        fail_at(:parameter, "duplicate parameter key", token) if values.key?(name)
+        fail_at(:parameter, "unused parameter", token) unless named.key?(name)
+        if value.nil? || value.is_a?(Array) || value.is_a?(Condition)
+          fail_at(:parameter, "equality requires a scalar value", token)
+        end
+        values[name] = value.is_a?(String) ? value.dup.freeze : value
+      end
+      named.each { |name, token| fail_at(:parameter, "missing parameter", token) unless values.key?(name) }
+      values
+    end
+
+    def build_pattern(start, hops)
+      schema = @context.graph.type
+      var, label = start
+      bind_type(var, label, schema.node_types)
+      query = @context.match.node(var.text, label.text)
+      hops.each do |connector, direction, edge, type, target|
+        edge_type = bind_type(edge, type, schema.edge_types)
+        if edge_type.symmetric? != (direction == :both)
+          fail_at(:unsupported, "edge direction does not match its type", connector)
+        end
+        var, label = target
+        bind_type(var, label, schema.node_types)
+        query = query.public_send(direction, type.text, var.text, label.text, edge: edge&.text)
+      end
+      query
+    end
+
+    def bind_type(var, name, types)
+      type = types[name.text.to_sym] || fail_at(:unknown_name, "unknown label or edge type", name)
+      @types[var.text] = type if var
+      type
+    end
+
+    def type_for!(var)
+      @types[var.text] || fail_at(:unknown_name, "unknown binding", var)
+    end
+
+    def property!(var, name)
+      property = type_for!(var).property_named(name.text)
+      fail_at(:unknown_name, "unknown declared property", name) unless property
+      fail_at(:unsupported, "property is not comparable", name) unless property.comparable?
+    end
+
+    def check_cap(count, max, unit, token)
+      fail_at(:limit_exceeded, "maximum #{unit} is #{max}", token) if count > max
+    end
+
+    def fail_at(code, message, token = @token)
+      raise ParseError.new(message, code:, text: @text, position: token.position,
+                           token: token.text || ("EOF" if token.position == @text.bytesize)), cause: nil
+    end
+  end
+  private_constant :MatchParser
+end

data/lib/pglpg/model/base.rb

@@ -64,6 +64,14 @@ module Pglpg
 
           property_names.each { attribute(_1, STRICT) }
           column_names.each { attribute(_1, STRICT) }
+          if kind == :edge && schema_type.temporal?
+            Temporal::NAMES.each do |name|
+              if instance_methods(false).include?(name) || instance_methods(false).include?(:"#{name}=")
+                raise SchemaError, "#{schema_type.name}.#{name} clashes with temporal metadata"
+              end
+              attribute(name, Edge::BOUND)
+            end
+          end
           @graph = graph
           @schema_type = schema_type
           @property_names = property_names.freeze
@@ -173,7 +181,7 @@ module Pglpg
       # only. Returns false when validation fails. Refusals (WriteRejected,
       # NotTrusted), timeouts and database errors raise; changes are kept on
       # any failure. +writer:+ hands over the context's trusted writer, for
-      # trusted-only operations; it never permits assigning a key.
+      # trusted-only operations; generated keys remain unassignable.
       #
       # Success means the statement succeeded in the caller's transaction.
       # Local state is what was assigned, not a stored snapshot (generated
@@ -197,6 +205,7 @@ module Pglpg
       # Deletes the element through the guarded write API (a node only
       # through the trusted writer). Returns true.
       def destroy(writer: nil)
+        context&.writable!
         raise ArgumentError, "only a persisted record can be destroyed" unless persisted?
 
         delete_element(write_target(writer))
@@ -252,6 +261,7 @@ module Pglpg
       # belong to this record's own context (identity).
       def write_target(writer)
         raise ArgumentError, "#{self.class} has no context; build it with Model.in(ctx).new" unless context
+        context.writable!
         raise ArgumentError, "#{self.class} was destroyed" if destroyed?
         return context if writer.nil?
         raise ArgumentError, "writer: expects a Pglpg::Writer" unless writer.is_a?(Pglpg::Writer)

data/lib/pglpg/model/edge.rb

@@ -9,6 +9,12 @@ module Pglpg
     #     graph Kg, type: :WORKS_ON
     #   end
     class Edge < Base
+      class BoundType < StrictType
+        def cast(value) = Temporal.date(value)
+        alias deserialize cast
+        alias serialize cast
+      end
+      BOUND = BoundType.new.freeze
       class << self
         def base_class = Model::Edge
 
@@ -43,6 +49,14 @@ module Pglpg
 
       def symmetric? = schema_type.symmetric?
 
+      def temporal? = schema_type.temporal?
+
+      def key
+        descriptor = schema_type.key or return nil
+        values = descriptor.properties.to_h { [_1, attribute(_1.to_s)] }
+        descriptor.property ? values[descriptor.property] : values.freeze
+      end
+
       # The endpoint opposite +ref+ (the same node for a self-loop).
       def other(ref)
         return target if ref == source
@@ -62,10 +76,24 @@ module Pglpg
       end
 
       validate :validate_endpoints
+      validate :validate_validity
+      validate :validate_keys
 
       private
 
+      def _write_attribute(name, value)
+        if Temporal::NAMES.include?(name.to_sym) && temporal?
+          value = BOUND.cast(value)
+          (@validity_assigned ||= {})[name.to_sym] = true
+        end
+        super(name, value)
+      end
+
       def load_identity(element)
+        @validity_assigned = {}
+        if temporal?
+          Temporal::NAMES.each { @attributes.write_from_database(_1.to_s, element.public_send(_1)) }
+        end
         @source = element.source
         @target = element.target
         self
@@ -83,16 +111,53 @@ module Pglpg
 
       # A symmetric edge is stored in canonical order, so the record takes it.
       def create_element(writer, properties, attrs)
-        @ref = writer.insert_edge(schema_type.name, from: source, to: target, properties:, attrs:)
+        @ref = writer.insert_edge(schema_type.name, from: source, to: target, properties:, attrs:, **validity_changes)
         @source, @target = @target, @source if symmetric? && @source.id > @target.id
       end
 
       def update_element(writer, properties, attrs)
-        writer.update_edge(ref, properties:, attrs:)
+        writer.update_edge(ref, properties:, attrs:, **validity_changes)
       end
 
       def delete_element(writer) = writer.delete_edge(ref)
 
+      def validity_changes
+        return {} unless temporal?
+
+        names = new_record? ? (@validity_assigned || {}).keys : Temporal::NAMES.select { attribute_changed?(_1.to_s) }
+        names.to_h { [_1, public_send(_1)] }
+      end
+
+      def validate_validity
+        return unless temporal?
+
+        if new_record? && !(@validity_assigned || {}).key?(:valid_from)
+          errors.add(:valid_from, "must be explicitly assigned (nil means unbounded)")
+        end
+        Temporal.validate_interval!(valid_from, valid_to)
+      rescue ValidationError => e
+        errors.add(:valid_from, e.message)
+      end
+
+      def required_now?(name)
+        return false if new_record? && schema_type.key&.generated? && schema_type.key.property == name
+
+        super
+      end
+
+      def validate_keys
+        key = schema_type.key
+        if new_record?
+          if key&.generated? && !attribute(key.property.to_s).nil?
+            errors.add(key.property, "is generated and cannot be assigned")
+          end
+        else
+          schema_type.immutable_properties.each do |property|
+            errors.add(property, "cannot be changed") if attribute_changed?(property.to_s)
+          end
+        end
+      end
+
       def validate_endpoints
         return unless new_record?
 

data/lib/pglpg/model/node.rb

@@ -131,10 +131,13 @@ module Pglpg
       # of the model's type.
       def schema_type = @schema_type || self.class.schema_type
 
-      # The value of the type's key property, or nil.
+      # A legacy scalar key, a composite property/value map, or nil.
       def key
         key = schema_type.key or return nil
-        self.class.property_names.include?(key.property) ? attribute(key.property.to_s) : extra_properties[key.property]
+        values = key.properties.to_h do |name|
+          [name, self.class.property_names.include?(name) ? attribute(name.to_s) : extra_properties[name]]
+        end
+        key.property ? values[key.property] : values.freeze
       end
 
       validate :validate_node
@@ -178,21 +181,23 @@ module Pglpg
         target.delete_node(ref)
       end
 
-      def key_property = schema_type.key&.property
+      def key_property = schema_type.key&.generated? ? schema_type.key.property : nil
 
       # The generated key is not required on insert.
       def required_now?(name) = new_record? ? name != key_property : super
 
-      # Keys are generated on insert and never change (ADR-0005, ADR-0010).
+      # Generated keys cannot be assigned; every stored key is immutable.
       def validate_node
         errors.add(:base, "#{schema_type.name} is abstract") if new_record? && schema_type.abstract?
-        key = key_property
-        return unless key && self.class.property_names.include?(key)
+        key = schema_type.key
+        return unless key
 
         if new_record?
-          errors.add(key, "is generated and cannot be assigned") unless attribute(key.to_s).nil?
+          if key.generated? && self.class.property_names.include?(key.property) && !attribute(key.property.to_s).nil?
+            errors.add(key.property, "is generated and cannot be assigned")
+          end
         else
-          schema_type.key.properties.each do |property|
+          key.properties.each do |property|
             errors.add(property, "cannot be changed") if attribute_changed?(property.to_s)
           end
         end

data/lib/pglpg/model/relation.rb

@@ -99,10 +99,16 @@ module Pglpg
 
       # Builds and saves a record; returns it, saved or not (check
       # persisted? or errors).
-      def create(writer: nil, **attributes) = new(**attributes).tap { _1.save(writer:) }
+      def create(writer: nil, **attributes)
+        context.writable!
+        new(**attributes).tap { _1.save(writer:) }
+      end
 
       # As #create, but raises RecordInvalid when validation fails.
-      def create!(writer: nil, **attributes) = new(**attributes).tap { _1.save!(writer:) }
+      def create!(writer: nil, **attributes)
+        context.writable!
+        new(**attributes).tap { _1.save!(writer:) }
+      end
 
       # The compiled Pglpg::Query, for debugging (to_sql, explain).
       def to_query = compiled
@@ -148,6 +154,7 @@ module Pglpg
         tree.each do |name, children|
           association = owner_model.respond_to?(:associations) && owner_model.associations[name]
           raise ArgumentError, "#{owner_model} has no association #{name}" unless association
+          context.temporal_mode!([context.graph.type.edge_type!(association.edge_type)])
           validate_tree(target_model(owner_model, association), children)
         end
       end

data/lib/pglpg/query.rb

@@ -246,6 +246,7 @@ module Pglpg
         raise ArgumentError, "with distinct, order only by returned variables (not #{stray.join(", ")})"
       end
 
+      context.temporal_mode!(@state.edges.map { context.graph.type.edge_type!(_1.type) })
       names = aliases
       sql = Sql.new(context.graph.connection)
       inner = kind != :rows
@@ -322,6 +323,7 @@ module Pglpg
         sql.bind(edge.type.to_s, "text")
         sql << " AND "
         context.append_edge_visible(sql, e)
+        context.append_temporal(sql, e, [context.graph.type.edge_type!(edge.type)])
         conditions_sql(sql, edge.var, e)
         # Different edges (the GQL default match mode).
         @state.edges.first(i).each do |other|
@@ -367,12 +369,20 @@ module Pglpg
         sql << " AND "
         case cond.op
         when :eq
-          if key && key.property == prop.name
-            # Matches the key's partial unique index.
-            sql << a << ".labels @> ARRAY["
-            sql.literal(key.declared_on) << "]::text[] AND (" << a << ".properties ->> "
+          if key && key.properties.include?(prop.name)
+            # Match every component of the same partial index used by the
+            # uniqueness arbiter, including jsonb numeric/boolean equality.
+            if @state.nodes.key?(var)
+              sql << a << ".labels @> ARRAY["
+              sql.literal(key.declared_on) << "]::text[]"
+            else
+              sql << a << ".type = "
+              sql.literal(key.declared_on)
+            end
+            sql << " AND (" << a << ".properties " << (key.json_component?(prop.name) ? "-> " : "->> ")
             sql.literal(prop.name) << ") = "
-            sql.bind(prop.encode(cond.value), "text")
+            encoded = prop.encode(cond.value)
+            key.json_component?(prop.name) ? sql.bind_json(encoded) : sql.bind(encoded, "text")
             next
           end
           sql << a << ".properties @> "
@@ -395,8 +405,12 @@ module Pglpg
     end
 
     def key_of(var)
-      label = @state.nodes[var]&.label
-      label && context.graph.type.node_type!(label).key
+      if (node = @state.nodes[var])
+        node.label && context.graph.type.node_type!(node.label).key
+      else
+        edge = @state.edges.find { _1.var == var }
+        edge && context.graph.type.edge_type!(edge.type).key
+      end
     end
 
     # Validates values up front, so errors surface where the query is built.

data/lib/pglpg/reachability.rb

@@ -21,6 +21,7 @@ module Pglpg
       @graph = context.graph
       @from = @graph.check_ref!(from, :node)
       @types = edge_types!(via, direction)
+      @context.temporal_mode!(@types.map { @graph.type.edge_type!(_1) })
       @direction = direction
       @max_depth = positive_integer!(max_depth, "max_depth")
       @max_nodes = positive_integer!(max_nodes, "max_nodes")
@@ -87,6 +88,7 @@ module Pglpg
       sql << " WHERE " << e << "." << near << " = ANY(b.frontier) AND " << e << ".type = ANY("
       sql.bind_text_array(@types) << ") AND "
       @context.append_edge_visible(sql, e)
+      @context.append_temporal(sql, e, @types.map { @graph.type.edge_type!(_1) })
     end
 
     def edge_types!(via, direction)

data/lib/pglpg/schema/edge_type.rb

@@ -9,17 +9,22 @@ module Pglpg
     # once with source_id < target_id (<= with allow_self_loops), and one
     # endpoint carries +from+ and the other +to+, in either order.
     class EdgeType < ElementType
-      attr_reader :from, :to, :unique
+      attr_reader :from, :to, :unique, :key, :pair_key
 
-      def initialize(name, from:, to:, unique: nil, symmetric: false, allow_self_loops: false, temporal: false)
-        super(name)
-        raise SchemaError, "temporal edge types are planned for 0.3 (#{name})" if temporal
-        raise SchemaError, "unique: must be nil or :pair (#{name})" unless [nil, :pair].include?(unique)
+      def initialize(name, from:, to:, unique: nil, symmetric: false, allow_self_loops: false, temporal: false, open: false)
+        super(name, open:)
+        raise SchemaError, "temporal: must be true or false" unless [true, false].include?(temporal)
+        @temporal = temporal
+        unless unique.nil? || unique == :pair || (unique.is_a?(Array) && !unique.empty?)
+          raise SchemaError, "unique: must be nil, :pair or a nonempty property list (#{name})"
+        end
+        @pair_key = Key.new(unique, declared_on: self.name, generation: false) if unique.is_a?(Array)
+        raise SchemaError, "pair uniqueness has too many components" if @pair_key && @pair_key.properties.size > 30
         raise SchemaError, "allow_self_loops: needs symmetric: true (#{name})" if allow_self_loops && !symmetric
 
         @from = Schema.check_name!(from, "type")
         @to = Schema.check_name!(to, "type")
-        @unique = unique
+        @unique = unique.is_a?(Array) ? unique.dup.freeze : unique
         @symmetric = symmetric == true
         @allow_self_loops = allow_self_loops == true
       end
@@ -28,6 +33,20 @@ module Pglpg
       # (the same unordered pair, for a symmetric type).
       def unique_pair? = unique == :pair
 
+      def unique_pair_properties = pair_key ? pair_key.properties : [].freeze
+
+      def unique_tuple? = unique_pair? || !pair_key.nil?
+
+      def immutable_properties = ((key&.properties || []) + unique_pair_properties).uniq
+
+      def key_property(*names, generate: nil)
+        raise SchemaError, "#{name} declares more than one key" if @key
+
+        @key = Key.new(names, declared_on: name, generate:)
+      end
+
+      def temporal? = @temporal
+
       def symmetric? = @symmetric
 
       def allow_self_loops? = @allow_self_loops
@@ -39,6 +58,9 @@ module Pglpg
           raise SchemaError, "edge #{name} refers to unknown node type #{label}"
         end
         @properties = own_properties.dup.freeze
+        resolve_open!(graph_type.edge_columns)
+        @key&.resolve!(self)
+        @pair_key&.resolve!(self)
         freeze
       end
     end