pglpg 0.2.0 → 0.3.0

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

data/lib/pglpg/schema/element_type.rb

@@ -10,16 +10,21 @@ module Pglpg
       name.to_sym
     end
 
-    # Shared by node and edge types: declared properties. Types are closed:
-    # a property that is not declared is rejected.
+    # Declared properties stay typed. Explicit open types also accept a
+    # restricted JSON-native value set without guessing a schema for extras.
     class ElementType
       attr_reader :name
 
-      def initialize(name)
+      def initialize(name, open: false)
+        raise SchemaError, "open: must be true or false" unless open.equal?(true) || open.equal?(false)
+
         @name = Schema.check_name!(name, "type")
         @own_properties = {}
+        @open = open
       end
 
+      def open? = @open
+
       def property(name, type, required: false, values: nil, of: nil)
         name = Schema.check_name!(name, "property")
         raise SchemaError, "#{self.name}.#{name} is declared twice" if @own_properties.key?(name)
@@ -36,20 +41,50 @@ module Pglpg
 
       def required_properties = properties.values.select(&:required?)
 
+      # @api private
+      # Construction-only resolution; the descriptor is frozen afterwards.
+      def resolve_open!(columns, parents: [])
+        @open ||= parents.any?(&:open?)
+        @extra_reserved_names = (Column::RESERVED + Temporal::NAMES + columns.keys).uniq.freeze
+      end
+
+      # Normalize before the writer generates/merges keys, so ambiguous
+      # String/Symbol aliases cannot disappear before validation.
+      # @api private
+      def normalize_properties(props)
+        return (props || {}).transform_keys(&:to_sym) unless open?
+
+        (props || {}).each_with_object({}) do |(name, value), out|
+          unless (name.is_a?(String) || name.is_a?(Symbol)) && name.to_s.match?(NAME_FORMAT)
+            raise ValidationError, "invalid open property name"
+          end
+          name = name.to_sym
+          raise ValidationError, "duplicate property #{name}" if out.key?(name)
+          if !properties.key?(name) && @extra_reserved_names.include?(name)
+            raise ValidationError, "#{name} is reserved and cannot be an extra property"
+          end
+
+          out[name] = value
+        end
+      end
+
       # Validates +props+ and returns the JSON hash to store. nil values are
       # dropped (null means absent). With +partial+, required properties may be
       # missing but may not be set to nil.
       def encode_properties(props, partial: false)
-        props = (props || {}).transform_keys(&:to_sym)
+        props = normalize_properties(props)
         unknown = props.keys - properties.keys
-        raise ValidationError, "#{name} has no propert#{unknown.size == 1 ? "y" : "ies"} #{unknown.join(", ")}" if unknown.any?
+        if !open? && unknown.any?
+          raise ValidationError, "#{name} has no propert#{unknown.size == 1 ? "y" : "ies"} #{unknown.join(", ")}"
+        end
 
         required_properties.each do |p|
           next if partial && !props.key?(p.name)
           raise ValidationError, "#{name}.#{p.name} is required" if props[p.name].nil?
         end
         props.each_with_object({}) do |(k, v), out|
-          encoded = properties.fetch(k).encode(v)
+          prop = properties[k]
+          encoded = prop ? prop.encode(v) : encode_extra(v)
           out[k.to_s] = encoded unless encoded.nil?
         end
       end
@@ -57,9 +92,47 @@ module Pglpg
       def decode_properties(json)
         (json || {}).each_with_object({}) do |(k, v), out|
           prop = properties[k.to_sym]
-          out[k.to_sym] = prop ? prop.decode(v) : v
+          out[k.to_sym] = prop ? prop.decode(v) : freeze_extra(v)
         end.freeze
       end
+
+      private
+
+      def encode_extra(value)
+        return nil if value.nil?
+        return encode_extra_scalar(value) unless value.instance_of?(Array)
+
+        kinds = value.map { (_1.equal?(true) || _1.equal?(false)) ? :boolean : _1.class }.uniq
+        raise ValidationError, "extra property lists must be homogeneous scalar arrays" if kinds.size > 1
+
+        value.map { encode_extra_scalar(_1) }
+      end
+
+      def encode_extra_scalar(value)
+        if value.instance_of?(String)
+          begin
+            text = value.encode(Encoding::UTF_8)
+          rescue EncodingError
+            raise ValidationError, "extra property strings must be valid UTF-8"
+          end
+          raise ValidationError, "extra property strings must be valid UTF-8" unless text.valid_encoding?
+          raise ValidationError, "extra property strings cannot contain NUL" if text.include?("\0")
+
+          return text
+        end
+        return value if value.instance_of?(Integer) || value.equal?(true) || value.equal?(false)
+        return value if value.instance_of?(Float) && value.finite?
+
+        raise ValidationError, "extra property values must be JSON-native scalars or homogeneous scalar arrays"
+      end
+
+      def freeze_extra(value)
+        case value
+        when Array then value.each { freeze_extra(_1) }
+        when Hash then value.each { |key, child| freeze_extra(key); freeze_extra(child) }
+        end
+        value.freeze
+      end
     end
   end
 end

data/lib/pglpg/schema/graph_type.rb

@@ -27,9 +27,15 @@ module Pglpg
         node_types.values.select { _1.label?(label) }
       end
 
+      def temporal? = edge_types.values.any?(&:temporal?)
+
       def resolve!
         node_types.each_value { _1.resolve!(self) }
         edge_types.each_value { _1.resolve!(self) }
+        if temporal?
+          collisions = (node_columns.keys + edge_columns.keys + node_types.values.flat_map { _1.properties.keys } + edge_types.values.flat_map { _1.properties.keys }) & Temporal::NAMES
+          raise SchemaError, "reserved temporal names: #{collisions.join(", ")}" unless collisions.empty?
+        end
         [node_types, edge_types, node_columns, edge_columns].each(&:freeze)
         freeze
       end
@@ -41,19 +47,19 @@ module Pglpg
         @graph_type = graph_type
       end
 
-      def node(name, extends: [], abstract: false, &block)
-        type = NodeType.new(name, extends:, abstract:)
+      def node(name, extends: [], abstract: false, open: false, &block)
+        type = NodeType.new(name, extends:, abstract:, open:)
         raise SchemaError, "type #{type.name} is declared twice" if declared?(type.name)
 
         NodeBuilder.new(type).instance_eval(&block) if block
         @graph_type.node_types[type.name] = type
       end
 
-      def edge(name, from:, to:, unique: nil, symmetric: false, allow_self_loops: false, temporal: false, &block)
-        type = EdgeType.new(name, from:, to:, unique:, symmetric:, allow_self_loops:, temporal:)
+      def edge(name, from:, to:, unique: nil, symmetric: false, allow_self_loops: false, temporal: false, open: false, &block)
+        type = EdgeType.new(name, from:, to:, unique:, symmetric:, allow_self_loops:, temporal:, open:)
         raise SchemaError, "type #{type.name} is declared twice" if declared?(type.name)
 
-        ElementBuilder.new(type).instance_eval(&block) if block
+        EdgeBuilder.new(type).instance_eval(&block) if block
         @graph_type.edge_types[type.name] = type
       end
 
@@ -89,12 +95,20 @@ module Pglpg
       end
     end
 
+    class EdgeBuilder < ElementBuilder
+      def key(*names, generate: nil, scope: nil)
+        raise SchemaError, "Edge scope: is not supported" unless scope.nil?
+
+        @type.key_property(*names, generate:)
+      end
+    end
+
     class NodeBuilder < ElementBuilder
       # Declares an exclusive key. Interactive inserts get a value from
       # +generate+ (default: a random UUID). Scoped keys may be caller-chosen
       # with an explicit key_scope_allowed grant.
-      def key(name, generate: nil, scope: nil)
-        @type.key_property(name, generate:, scope:)
+      def key(*names, generate: nil, scope: nil)
+        @type.key_property(*names, generate:, scope:)
       end
     end
   end

data/lib/pglpg/schema/key.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Pglpg
+  module Schema
+    # One required, immutable property tuple. Shared by schema validation,
+    # index generation and ON CONFLICT so their equality cannot diverge.
+    class Key
+      TYPES = %i[string integer boolean enum].freeze
+      DEFAULT_GENERATOR = ->(_type) { SecureRandom.uuid }
+
+      attr_reader :properties, :declared_on, :scope, :generator
+
+      def initialize(names, declared_on:, generate: nil, scope: nil, generation: true)
+        @names = names.map { Schema.check_name!(_1, "key property") }.freeze
+        raise SchemaError, "a key needs distinct properties" if @names.empty? || @names.uniq != @names
+        raise SchemaError, "scope needs a single key property" if scope && @names.size != 1
+        raise SchemaError, "key generator must respond to call" if generate && !generate.respond_to?(:call)
+        raise SchemaError, "composite keys cannot have a generator" if generate && @names.size != 1
+
+        @scope = scope && Schema.check_name!(scope, "key scope")
+        @properties = [@scope, *@names].compact.freeze
+        raise SchemaError, "scope must differ from key property" if @properties.uniq != @properties
+        raise SchemaError, "key has too many components" if @properties.size > 32
+
+        @declared_on = declared_on
+        @generator = generate
+        @generation = generation
+      end
+
+      # Legacy single/scoped keys expose their generated property.
+      def property = @names.size == 1 ? @names.first : nil
+
+      def generated? = !generator.nil?
+
+      def generate(type) = generator.call(type)
+
+      def resolve!(type)
+        properties.each do |name|
+          prop = type.properties[name]
+          raise SchemaError, "key #{declared_on}.#{name} is not a declared property" unless prop
+          unless prop.required? && TYPES.include?(prop.type)
+            raise SchemaError, "key #{declared_on}.#{name} must be a required #{TYPES.join('/')} property"
+          end
+        end
+        if scope && properties.any? { type.properties.fetch(_1).type != :string }
+          raise SchemaError, "scoped keys require string properties"
+        end
+        if @generator && type.properties.fetch(property).type != :string
+          raise SchemaError, "only single string keys can have generators"
+        end
+        if @generation && property && type.properties.fetch(property).type == :string
+          @generator ||= DEFAULT_GENERATOR
+        end
+        @types = properties.to_h { [_1, type.properties.fetch(_1).type] }.freeze
+        freeze
+      end
+
+      def json_component?(name) = %i[integer boolean].include?(@types.fetch(name))
+
+      def expressions(connection)
+        properties.map do |name|
+          operator = json_component?(name) ? "->" : "->>"
+          "(properties#{operator}#{connection.quote(name.to_s)})"
+        end
+      end
+
+      # Lookups accept literal complete keys, never query operators/arrays/nil.
+      def validate_values!(type, values)
+        unless values.keys.sort == properties.sort
+          raise ArgumentError, "#{declared_on} requires the complete key #{properties.inspect}"
+        end
+        properties.each do |name|
+          raise ValidationError, "#{declared_on}.#{name} is required" if values[name].nil?
+
+          type.properties.fetch(name).encode(values[name])
+        end
+      end
+    end
+  end
+end

data/lib/pglpg/schema/node_type.rb

@@ -1,27 +1,14 @@
 # frozen_string_literal: true
 
-require "securerandom"
-
 module Pglpg
   module Schema
     # A node type: a key label, inherited labels and property types
     # (GQL node types, PG-Schema inheritance).
     class NodeType < ElementType
-      # An exclusive, mandatory string key, optionally scoped by another
-      # required string property. Caller-chosen scoped keys need an explicit
-      # occupancy grant; omitted keys use +generator+.
-      Key = Struct.new(:property, :declared_on, :generator, :scope, keyword_init: true) do
-        def properties = [scope, property].compact.freeze
-
-        def generate(type) = generator.call(type)
-      end
-
-      DEFAULT_KEY_GENERATOR = ->(_type) { SecureRandom.uuid }
-
       attr_reader :parents, :labels, :key, :ancestors
 
-      def initialize(name, extends: [], abstract: false)
-        super(name)
+      def initialize(name, extends: [], abstract: false, open: false)
+        super(name, open:)
         @parents = Array(extends).map { Schema.check_name!(_1, "type") }.freeze
         @abstract = abstract ? true : false
         @own_key = nil
@@ -29,11 +16,10 @@ module Pglpg
 
       def abstract? = @abstract
 
-      def key_property(name, generate: nil, scope: nil)
+      def key_property(*names, generate: nil, scope: nil)
         raise SchemaError, "#{self.name} declares more than one key" if @own_key
-        raise SchemaError, "key generator for #{self.name} must respond to call" if generate && !generate.respond_to?(:call)
 
-        @own_key = Key.new(property: name.to_sym, declared_on: self.name, generator: generate || DEFAULT_KEY_GENERATOR, scope: scope && Schema.check_name!(scope, "key scope"))
+        @own_key = Key.new(names, declared_on: self.name, generate:, scope:)
       end
 
       def own_key = @own_key
@@ -51,6 +37,7 @@ module Pglpg
         @ancestors = parent_types.flat_map { [_1.name, *_1.ancestors] }.uniq.freeze
         @labels = ([name] + @ancestors).map(&:to_s).sort.freeze
         @properties = merge_properties(parent_types)
+        resolve_open!(graph_type.node_columns, parents: parent_types)
         @key = resolve_key(parent_types)
         @resolved = true
         freeze
@@ -82,19 +69,8 @@ module Pglpg
         key = keys.first
         return nil unless key
 
-        prop = @properties[key.property]
-        raise SchemaError, "key #{key.declared_on}.#{key.property} is not a declared property" unless prop
-        raise SchemaError, "key #{key.declared_on}.#{key.property} must be required" unless prop.required?
-        raise SchemaError, "key #{key.declared_on}.#{key.property} must be a string" unless prop.type == :string
-
-        if key.scope
-          raise SchemaError, "scope must differ from key property" if key.scope == key.property
-          scope = @properties[key.scope]
-          unless scope && scope.required? && scope.type == :string
-            raise SchemaError, "key scope #{key.scope} must be a declared required string property"
-          end
-        end
-        key.freeze
+        # Inherited descriptors are already resolved and immutable.
+        key.frozen? ? key : key.resolve!(self)
       end
     end
   end